| ... | ... | @@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2414 | 2414 | } |
| 2415 | 2415 | |
| 2416 | 2416 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2417 | | @setEvalBranchQuota(5_500); |
| 2417 | @setEvalBranchQuota(9_200); |
| 2418 | 2418 | const pt = cg.pt; |
| 2419 | 2419 | const zcu = pt.zcu; |
| 2420 | 2420 | const ip = &zcu.intern_pool; |
| ... | ... | @@ -2450,23 +2450,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2450 | 2450 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); |
| 2451 | 2451 | switch (air_tags[@intFromEnum(inst)]) { |
| 2452 | 2452 | // zig fmt: off |
| 2453 | | .add, |
| 2454 | 2453 | .add_wrap, |
| 2455 | | .sub, |
| 2456 | 2454 | .sub_wrap, |
| 2457 | 2455 | => |air_tag| try cg.airBinOp(inst, air_tag), |
| 2458 | 2456 | |
| 2459 | 2457 | .shr, .shr_exact => try cg.airShlShrBinOp(inst), |
| 2460 | 2458 | .shl, .shl_exact => try cg.airShlShrBinOp(inst), |
| 2461 | 2459 | |
| 2462 | | .mul, |
| 2463 | 2460 | .mul_wrap, |
| 2464 | | .rem, |
| 2465 | 2461 | .mod, |
| 2466 | | .div_float, |
| 2467 | | .div_trunc, |
| 2468 | | .div_floor, |
| 2469 | | .div_exact, |
| 2470 | 2462 | => |air_tag| try cg.airMulDivBinOp(inst, air_tag), |
| 2471 | 2463 | |
| 2472 | 2464 | .add_sat => try cg.airAddSat(inst), |
| ... | ... | @@ -2474,23 +2466,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2474 | 2466 | .mul_sat => try cg.airMulSat(inst), |
| 2475 | 2467 | .shl_sat => try cg.airShlSat(inst), |
| 2476 | 2468 | |
| 2477 | | .sin, |
| 2478 | | .cos, |
| 2479 | | .tan, |
| 2480 | | .exp, |
| 2481 | | .exp2, |
| 2482 | | .log, |
| 2483 | | .log2, |
| 2484 | | .log10, |
| 2485 | | .round, |
| 2486 | | => |air_tag| try cg.airUnaryMath(inst, air_tag), |
| 2487 | | |
| 2488 | | .floor => try cg.airRound(inst, .{ .mode = .down, .precision = .inexact }), |
| 2489 | | .ceil => try cg.airRound(inst, .{ .mode = .up, .precision = .inexact }), |
| 2490 | | .trunc_float => try cg.airRound(inst, .{ .mode = .zero, .precision = .inexact }), |
| 2491 | | .sqrt => try cg.airSqrt(inst), |
| 2492 | | .neg => |air_tag| try cg.airFloatSign(inst, air_tag), |
| 2493 | | |
| 2494 | 2469 | .add_with_overflow => try cg.airAddSubWithOverflow(inst), |
| 2495 | 2470 | .sub_with_overflow => try cg.airAddSubWithOverflow(inst), |
| 2496 | 2471 | .mul_with_overflow => try cg.airMulWithOverflow(inst), |
| ... | ... | @@ -2524,7 +2499,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2524 | 2499 | .reduce => try cg.airReduce(inst), |
| 2525 | 2500 | .aggregate_init => try cg.airAggregateInit(inst), |
| 2526 | 2501 | .prefetch => try cg.airPrefetch(inst), |
| 2527 | | .mul_add => try cg.airMulAdd(inst), |
| 2528 | 2502 | |
| 2529 | 2503 | .atomic_store_unordered => try cg.airAtomicStore(inst, .unordered), |
| 2530 | 2504 | .atomic_store_monotonic => try cg.airAtomicStore(inst, .monotonic), |
| ... | ... | @@ -2548,16 +2522,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2548 | 2522 | .intcast_safe, |
| 2549 | 2523 | => return cg.fail("TODO implement safety_checked_instructions", .{}), |
| 2550 | 2524 | |
| 2551 | | .add_optimized => try cg.airBinOp(inst, .add), |
| 2552 | | .sub_optimized => try cg.airBinOp(inst, .sub), |
| 2553 | | .mul_optimized => try cg.airBinOp(inst, .mul), |
| 2554 | | .div_float_optimized => try cg.airMulDivBinOp(inst, .div_float), |
| 2555 | | .div_trunc_optimized => try cg.airMulDivBinOp(inst, .div_trunc), |
| 2556 | | .div_floor_optimized => try cg.airMulDivBinOp(inst, .div_floor), |
| 2557 | | .div_exact_optimized => try cg.airMulDivBinOp(inst, .div_exact), |
| 2558 | | .rem_optimized => try cg.airMulDivBinOp(inst, .rem), |
| 2559 | 2525 | .mod_optimized => try cg.airMulDivBinOp(inst, .mod), |
| 2560 | | .neg_optimized => try cg.airFloatSign(inst, .neg), |
| 2561 | 2526 | .reduce_optimized => try cg.airReduce(inst), |
| 2562 | 2527 | .int_from_float_optimized => try cg.airIntFromFloat(inst), |
| 2563 | 2528 | |
| ... | ... | @@ -2575,490 +2540,661 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2575 | 2540 | if (arg != .none) break; |
| 2576 | 2541 | } else try cg.airDbgVarArgs(); |
| 2577 | 2542 | }, |
| 2578 | | .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { |
| 2579 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 2580 | | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 2543 | .add, .add_optimized => |air_tag| if (use_old) try cg.airBinOp(inst, .add) else fallback: { |
| 2544 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 2545 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airBinOp(inst, air_tag); |
| 2581 | 2546 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2582 | | try ops[0].toSlicePtr(cg); |
| 2583 | 2547 | var res: [1]Temp = undefined; |
| 2584 | | if (ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{ |
| 2585 | | .patterns = &.{ |
| 2586 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 2548 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 2549 | .required_features = .{ .f16c, null, null, null }, |
| 2550 | .src_constraints = .{ |
| 2551 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 2552 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 2553 | .any, |
| 2587 | 2554 | }, |
| 2588 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2589 | | .each = .{ .once = &.{ |
| 2590 | | .{ ._, ._, .lea, .dst0p, .leaa(.src0, .add_src0_elem_size_times_src1), ._, ._ }, |
| 2591 | | } }, |
| 2592 | | }, .{ |
| 2593 | | .dst_constraints = .{.{ .elem_size_is = 1 }}, |
| 2594 | 2555 | .patterns = &.{ |
| 2595 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2556 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2596 | 2557 | }, |
| 2597 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2558 | .extra_temps = .{ |
| 2559 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 2560 | .unused, |
| 2561 | .unused, |
| 2562 | .unused, |
| 2563 | .unused, |
| 2564 | .unused, |
| 2565 | .unused, |
| 2566 | .unused, |
| 2567 | .unused, |
| 2568 | }, |
| 2569 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2598 | 2570 | .each = .{ .once = &.{ |
| 2599 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 2571 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 2572 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 2573 | .{ ._, .v_ss, .add, .dst0x, .dst0x, .tmp0d, ._ }, |
| 2574 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 2600 | 2575 | } }, |
| 2601 | 2576 | }, .{ |
| 2602 | | .dst_constraints = .{.{ .elem_size_is = 2 }}, |
| 2577 | .required_features = .{ .sse, null, null, null }, |
| 2578 | .src_constraints = .{ |
| 2579 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 2580 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 2581 | .any, |
| 2582 | }, |
| 2603 | 2583 | .patterns = &.{ |
| 2604 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2584 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 2605 | 2585 | }, |
| 2606 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2586 | .call_frame = .{ .alignment = .@"16" }, |
| 2587 | .extra_temps = .{ |
| 2588 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } }, |
| 2589 | .unused, |
| 2590 | .unused, |
| 2591 | .unused, |
| 2592 | .unused, |
| 2593 | .unused, |
| 2594 | .unused, |
| 2595 | .unused, |
| 2596 | .unused, |
| 2597 | }, |
| 2598 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 2607 | 2600 | .each = .{ .once = &.{ |
| 2608 | | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ }, |
| 2601 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 2609 | 2602 | } }, |
| 2610 | 2603 | }, .{ |
| 2611 | | .dst_constraints = .{.{ .elem_size_is = 2 + 1 }}, |
| 2604 | .required_features = .{ .f16c, null, null, null }, |
| 2605 | .src_constraints = .{ |
| 2606 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 2607 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 2608 | .any, |
| 2609 | }, |
| 2612 | 2610 | .patterns = &.{ |
| 2613 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2611 | .{ .src = .{ .mem, .mem, .none } }, |
| 2612 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2613 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 2614 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2614 | 2615 | }, |
| 2615 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2616 | .extra_temps = .{ |
| 2617 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 2618 | .unused, |
| 2619 | .unused, |
| 2620 | .unused, |
| 2621 | .unused, |
| 2622 | .unused, |
| 2623 | .unused, |
| 2624 | .unused, |
| 2625 | .unused, |
| 2626 | }, |
| 2627 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2616 | 2628 | .each = .{ .once = &.{ |
| 2617 | | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ }, |
| 2618 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2629 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 2630 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 2631 | .{ ._, .v_ps, .add, .dst0x, .dst0x, .tmp0x, ._ }, |
| 2632 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 2619 | 2633 | } }, |
| 2620 | 2634 | }, .{ |
| 2621 | | .dst_constraints = .{.{ .elem_size_is = 4 }}, |
| 2635 | .required_features = .{ .f16c, null, null, null }, |
| 2636 | .src_constraints = .{ |
| 2637 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 2638 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 2639 | .any, |
| 2640 | }, |
| 2622 | 2641 | .patterns = &.{ |
| 2623 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2642 | .{ .src = .{ .mem, .mem, .none } }, |
| 2643 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2644 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 2645 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2624 | 2646 | }, |
| 2625 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2647 | .extra_temps = .{ |
| 2648 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 2649 | .unused, |
| 2650 | .unused, |
| 2651 | .unused, |
| 2652 | .unused, |
| 2653 | .unused, |
| 2654 | .unused, |
| 2655 | .unused, |
| 2656 | .unused, |
| 2657 | }, |
| 2658 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2626 | 2659 | .each = .{ .once = &.{ |
| 2627 | | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ }, |
| 2660 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 2661 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 2662 | .{ ._, .v_ps, .add, .dst0y, .dst0y, .tmp0y, ._ }, |
| 2663 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 2628 | 2664 | } }, |
| 2629 | 2665 | }, .{ |
| 2630 | | .dst_constraints = .{.{ .elem_size_is = 4 + 1 }}, |
| 2666 | .required_features = .{ .f16c, null, null, null }, |
| 2667 | .src_constraints = .{ |
| 2668 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 2669 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 2670 | .any, |
| 2671 | }, |
| 2631 | 2672 | .patterns = &.{ |
| 2632 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2673 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2633 | 2674 | }, |
| 2634 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2675 | .extra_temps = .{ |
| 2676 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2677 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 2678 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 2679 | .unused, |
| 2680 | .unused, |
| 2681 | .unused, |
| 2682 | .unused, |
| 2683 | .unused, |
| 2684 | .unused, |
| 2685 | }, |
| 2686 | .dst_temps = .{.mem}, |
| 2687 | .clobbers = .{ .eflags = true }, |
| 2635 | 2688 | .each = .{ .once = &.{ |
| 2636 | | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, |
| 2637 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2689 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2690 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2691 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2692 | .{ ._, .v_ps, .add, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 2693 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 2694 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 2695 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2638 | 2696 | } }, |
| 2639 | 2697 | }, .{ |
| 2640 | | .required_features = .{ .@"64bit", null, null, null }, |
| 2641 | | .dst_constraints = .{.{ .elem_size_is = 8 }}, |
| 2698 | .required_features = .{ .avx, null, null, null }, |
| 2699 | .src_constraints = .{ |
| 2700 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2701 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2702 | .any, |
| 2703 | }, |
| 2642 | 2704 | .patterns = &.{ |
| 2643 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2705 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2644 | 2706 | }, |
| 2645 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2707 | .call_frame = .{ .alignment = .@"16" }, |
| 2708 | .extra_temps = .{ |
| 2709 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2710 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 2711 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 2712 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } }, |
| 2713 | .unused, |
| 2714 | .unused, |
| 2715 | .unused, |
| 2716 | .unused, |
| 2717 | .unused, |
| 2718 | }, |
| 2719 | .dst_temps = .{.mem}, |
| 2720 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 2646 | 2721 | .each = .{ .once = &.{ |
| 2647 | | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ }, |
| 2722 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2723 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 2724 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 2725 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 2726 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 2727 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 2728 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 2729 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2648 | 2730 | } }, |
| 2649 | 2731 | }, .{ |
| 2650 | | .required_features = .{ .@"64bit", null, null, null }, |
| 2651 | | .dst_constraints = .{.{ .elem_size_is = 8 + 1 }}, |
| 2732 | .required_features = .{ .sse4_1, null, null, null }, |
| 2733 | .src_constraints = .{ |
| 2734 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2735 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2736 | .any, |
| 2737 | }, |
| 2652 | 2738 | .patterns = &.{ |
| 2653 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2739 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2654 | 2740 | }, |
| 2655 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2741 | .call_frame = .{ .alignment = .@"16" }, |
| 2742 | .extra_temps = .{ |
| 2743 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2744 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 2745 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 2746 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } }, |
| 2747 | .unused, |
| 2748 | .unused, |
| 2749 | .unused, |
| 2750 | .unused, |
| 2751 | .unused, |
| 2752 | }, |
| 2753 | .dst_temps = .{.mem}, |
| 2754 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 2656 | 2755 | .each = .{ .once = &.{ |
| 2657 | | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, |
| 2658 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2756 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2757 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 2758 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 2759 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 2760 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 2761 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 2762 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 2763 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 2764 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2659 | 2765 | } }, |
| 2660 | 2766 | }, .{ |
| 2661 | | .dst_constraints = .{.po2_elem_size}, |
| 2767 | .required_features = .{ .sse2, null, null, null }, |
| 2768 | .src_constraints = .{ |
| 2769 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2770 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2771 | .any, |
| 2772 | }, |
| 2662 | 2773 | .patterns = &.{ |
| 2663 | | .{ .src = .{ .to_gpr, .to_mut_gpr } }, |
| 2774 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2664 | 2775 | }, |
| 2665 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2666 | | .clobbers = .{ .eflags = true }, |
| 2776 | .call_frame = .{ .alignment = .@"16" }, |
| 2777 | .extra_temps = .{ |
| 2778 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2779 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 2780 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 2781 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } }, |
| 2782 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 2783 | .unused, |
| 2784 | .unused, |
| 2785 | .unused, |
| 2786 | .unused, |
| 2787 | }, |
| 2788 | .dst_temps = .{.mem}, |
| 2789 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 2667 | 2790 | .each = .{ .once = &.{ |
| 2668 | | .{ ._, ._l, .sh, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ }, |
| 2669 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 2791 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2792 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 2793 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 2794 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 2795 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 2796 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 2797 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 2798 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 2799 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 2800 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2670 | 2801 | } }, |
| 2671 | 2802 | }, .{ |
| 2672 | | .patterns = &.{ |
| 2673 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2803 | .required_features = .{ .sse, null, null, null }, |
| 2804 | .src_constraints = .{ |
| 2805 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2806 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 2807 | .any, |
| 2674 | 2808 | }, |
| 2675 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2676 | | .clobbers = .{ .eflags = true }, |
| 2677 | | .each = .{ .once = &.{ |
| 2678 | | .{ ._, .i_, .mul, .dst0p, .src1p, .sa(.none, .add_src0_elem_size), ._ }, |
| 2679 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2680 | | } }, |
| 2681 | | } }) catch |err| switch (err) { |
| 2682 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 2683 | | @tagName(air_tag), |
| 2684 | | cg.typeOf(bin_op.lhs).fmt(pt), |
| 2685 | | ops[0].tracking(cg), |
| 2686 | | ops[1].tracking(cg), |
| 2687 | | }), |
| 2688 | | else => |e| return e, |
| 2689 | | } else { // hack around Sema OPV bugs |
| 2690 | | res[0] = ops[0]; |
| 2691 | | } |
| 2692 | | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 2693 | | }, |
| 2694 | | .ptr_sub => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { |
| 2695 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 2696 | | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 2697 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2698 | | try ops[0].toSlicePtr(cg); |
| 2699 | | var res: [1]Temp = undefined; |
| 2700 | | if (ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{ |
| 2701 | 2809 | .patterns = &.{ |
| 2702 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 2810 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2703 | 2811 | }, |
| 2704 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2812 | .call_frame = .{ .alignment = .@"16" }, |
| 2813 | .extra_temps = .{ |
| 2814 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2815 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 2816 | .{ .type = .f32, .kind = .mem }, |
| 2817 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 2818 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 2819 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addhf3" } } }, |
| 2820 | .unused, |
| 2821 | .unused, |
| 2822 | .unused, |
| 2823 | }, |
| 2824 | .dst_temps = .{.mem}, |
| 2825 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 2705 | 2826 | .each = .{ .once = &.{ |
| 2706 | | .{ ._, ._, .lea, .dst0p, .leaa(.src0, .sub_src0_elem_size_times_src1), ._, ._ }, |
| 2827 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2828 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2829 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 2830 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 2831 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2832 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 2833 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 2834 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 2835 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 2836 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 2837 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 2838 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 2839 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2707 | 2840 | } }, |
| 2708 | 2841 | }, .{ |
| 2709 | | .dst_constraints = .{.{ .elem_size_is = 1 }}, |
| 2842 | .required_features = .{ .avx, null, null, null }, |
| 2843 | .src_constraints = .{ |
| 2844 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 2845 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 2846 | .any, |
| 2847 | }, |
| 2710 | 2848 | .patterns = &.{ |
| 2711 | | .{ .src = .{ .to_gpr, .to_mut_gpr } }, |
| 2849 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2850 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 2851 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2712 | 2852 | }, |
| 2713 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2714 | | .clobbers = .{ .eflags = true }, |
| 2853 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2715 | 2854 | .each = .{ .once = &.{ |
| 2716 | | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 2717 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 2855 | .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ }, |
| 2718 | 2856 | } }, |
| 2719 | 2857 | }, .{ |
| 2720 | | .dst_constraints = .{.{ .elem_size_is = 2 }}, |
| 2858 | .required_features = .{ .sse, null, null, null }, |
| 2859 | .src_constraints = .{ |
| 2860 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 2861 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 2862 | .any, |
| 2863 | }, |
| 2721 | 2864 | .patterns = &.{ |
| 2722 | | .{ .src = .{ .to_gpr, .to_mut_gpr } }, |
| 2865 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 2866 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 2867 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 2723 | 2868 | }, |
| 2724 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2725 | | .clobbers = .{ .eflags = true }, |
| 2869 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2726 | 2870 | .each = .{ .once = &.{ |
| 2727 | | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 2728 | | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ }, |
| 2871 | .{ ._, ._ss, .add, .dst0x, .src1d, ._, ._ }, |
| 2729 | 2872 | } }, |
| 2730 | 2873 | }, .{ |
| 2731 | | .dst_constraints = .{.{ .elem_size_is = 2 + 1 }}, |
| 2874 | .required_features = .{ .avx, null, null, null }, |
| 2875 | .src_constraints = .{ |
| 2876 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 2877 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 2878 | .any, |
| 2879 | }, |
| 2732 | 2880 | .patterns = &.{ |
| 2733 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2881 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2882 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 2883 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2734 | 2884 | }, |
| 2735 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2736 | | .clobbers = .{ .eflags = true }, |
| 2885 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2737 | 2886 | .each = .{ .once = &.{ |
| 2738 | | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ }, |
| 2739 | | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, |
| 2740 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2887 | .{ ._, .v_ps, .add, .dst0x, .src0x, .src1x, ._ }, |
| 2741 | 2888 | } }, |
| 2742 | 2889 | }, .{ |
| 2743 | | .dst_constraints = .{.{ .elem_size_is = 4 }}, |
| 2890 | .required_features = .{ .sse, null, null, null }, |
| 2891 | .src_constraints = .{ |
| 2892 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 2893 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 2894 | .any, |
| 2895 | }, |
| 2744 | 2896 | .patterns = &.{ |
| 2745 | | .{ .src = .{ .to_gpr, .to_mut_gpr } }, |
| 2897 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 2898 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 2899 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 2746 | 2900 | }, |
| 2747 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2748 | | .clobbers = .{ .eflags = true }, |
| 2901 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2749 | 2902 | .each = .{ .once = &.{ |
| 2750 | | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 2751 | | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ }, |
| 2903 | .{ ._, ._ps, .add, .dst0x, .src1x, ._, ._ }, |
| 2752 | 2904 | } }, |
| 2753 | 2905 | }, .{ |
| 2754 | | .dst_constraints = .{.{ .elem_size_is = 4 + 1 }}, |
| 2906 | .required_features = .{ .avx, null, null, null }, |
| 2907 | .src_constraints = .{ |
| 2908 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 2909 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 2910 | .any, |
| 2911 | }, |
| 2755 | 2912 | .patterns = &.{ |
| 2756 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2913 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2914 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 2915 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2757 | 2916 | }, |
| 2758 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2759 | | .clobbers = .{ .eflags = true }, |
| 2917 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2760 | 2918 | .each = .{ .once = &.{ |
| 2761 | | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, |
| 2762 | | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, |
| 2763 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2919 | .{ ._, .v_ps, .add, .dst0y, .src0y, .src1y, ._ }, |
| 2764 | 2920 | } }, |
| 2765 | 2921 | }, .{ |
| 2766 | | .required_features = .{ .@"64bit", null, null, null }, |
| 2767 | | .dst_constraints = .{.{ .elem_size_is = 8 }}, |
| 2922 | .required_features = .{ .avx, null, null, null }, |
| 2923 | .src_constraints = .{ |
| 2924 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 2925 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 2926 | .any, |
| 2927 | }, |
| 2768 | 2928 | .patterns = &.{ |
| 2769 | | .{ .src = .{ .to_gpr, .to_mut_gpr } }, |
| 2929 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2770 | 2930 | }, |
| 2771 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2931 | .extra_temps = .{ |
| 2932 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2933 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 2934 | .unused, |
| 2935 | .unused, |
| 2936 | .unused, |
| 2937 | .unused, |
| 2938 | .unused, |
| 2939 | .unused, |
| 2940 | .unused, |
| 2941 | }, |
| 2942 | .dst_temps = .{.mem}, |
| 2772 | 2943 | .clobbers = .{ .eflags = true }, |
| 2773 | 2944 | .each = .{ .once = &.{ |
| 2774 | | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 2775 | | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ }, |
| 2945 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2946 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2947 | .{ ._, .v_ps, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 2948 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 2949 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 2950 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2776 | 2951 | } }, |
| 2777 | 2952 | }, .{ |
| 2778 | | .required_features = .{ .@"64bit", null, null, null }, |
| 2779 | | .dst_constraints = .{.{ .elem_size_is = 8 + 1 }}, |
| 2953 | .required_features = .{ .sse, null, null, null }, |
| 2954 | .src_constraints = .{ |
| 2955 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 2956 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 2957 | .any, |
| 2958 | }, |
| 2780 | 2959 | .patterns = &.{ |
| 2781 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 2960 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2782 | 2961 | }, |
| 2783 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2962 | .extra_temps = .{ |
| 2963 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2964 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 2965 | .unused, |
| 2966 | .unused, |
| 2967 | .unused, |
| 2968 | .unused, |
| 2969 | .unused, |
| 2970 | .unused, |
| 2971 | .unused, |
| 2972 | }, |
| 2973 | .dst_temps = .{.mem}, |
| 2784 | 2974 | .clobbers = .{ .eflags = true }, |
| 2785 | 2975 | .each = .{ .once = &.{ |
| 2786 | | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, |
| 2787 | | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, |
| 2788 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2976 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2977 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2978 | .{ ._, ._ps, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2979 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 2980 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 2981 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2789 | 2982 | } }, |
| 2790 | 2983 | }, .{ |
| 2791 | | .dst_constraints = .{.po2_elem_size}, |
| 2984 | .required_features = .{ .avx, null, null, null }, |
| 2985 | .src_constraints = .{ |
| 2986 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 2987 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 2988 | .any, |
| 2989 | }, |
| 2792 | 2990 | .patterns = &.{ |
| 2793 | | .{ .src = .{ .to_gpr, .to_mut_gpr } }, |
| 2991 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2992 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 2993 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2794 | 2994 | }, |
| 2795 | | .dst_temps = .{.{ .ref = .src1 }}, |
| 2796 | | .clobbers = .{ .eflags = true }, |
| 2995 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2797 | 2996 | .each = .{ .once = &.{ |
| 2798 | | .{ ._, ._l, .sa, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ }, |
| 2799 | | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 2800 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 2997 | .{ ._, .v_sd, .add, .dst0x, .src0x, .src1q, ._ }, |
| 2801 | 2998 | } }, |
| 2802 | 2999 | }, .{ |
| 2803 | | .patterns = &.{ |
| 2804 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 3000 | .required_features = .{ .sse2, null, null, null }, |
| 3001 | .src_constraints = .{ |
| 3002 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3003 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3004 | .any, |
| 2805 | 3005 | }, |
| 2806 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 2807 | | .clobbers = .{ .eflags = true }, |
| 2808 | | .each = .{ .once = &.{ |
| 2809 | | .{ ._, .i_, .mul, .dst0p, .src1p, .sa(.none, .sub_src0_elem_size), ._ }, |
| 2810 | | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 2811 | | } }, |
| 2812 | | } }) catch |err| switch (err) { |
| 2813 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 2814 | | @tagName(air_tag), |
| 2815 | | cg.typeOf(bin_op.lhs).fmt(pt), |
| 2816 | | ops[0].tracking(cg), |
| 2817 | | ops[1].tracking(cg), |
| 2818 | | }), |
| 2819 | | else => |e| return e, |
| 2820 | | } else { |
| 2821 | | // hack around Sema OPV bugs |
| 2822 | | res[0] = ops[0]; |
| 2823 | | } |
| 2824 | | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 2825 | | }, |
| 2826 | | .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { |
| 2827 | | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 2828 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2829 | | var res: [1]Temp = undefined; |
| 2830 | | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 2831 | | .required_features = .{ .cmov, null, null, null }, |
| 2832 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, |
| 2833 | 3006 | .patterns = &.{ |
| 2834 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3007 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3008 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 3009 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 2835 | 3010 | }, |
| 2836 | 3011 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2837 | | .clobbers = .{ .eflags = true }, |
| 2838 | 3012 | .each = .{ .once = &.{ |
| 2839 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 2840 | | .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ }, |
| 3013 | .{ ._, ._sd, .add, .dst0x, .src1q, ._, ._ }, |
| 2841 | 3014 | } }, |
| 2842 | 3015 | }, .{ |
| 2843 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, |
| 3016 | .required_features = .{ .x87, null, null, null }, |
| 3017 | .src_constraints = .{ |
| 3018 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3019 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3020 | .any, |
| 3021 | }, |
| 2844 | 3022 | .patterns = &.{ |
| 2845 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2846 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2847 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3023 | .{ .src = .{ .mem, .mem, .none } }, |
| 2848 | 3024 | }, |
| 2849 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2850 | | .clobbers = .{ .eflags = true }, |
| 3025 | .extra_temps = .{ |
| 3026 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 3027 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3028 | .unused, |
| 3029 | .unused, |
| 3030 | .unused, |
| 3031 | .unused, |
| 3032 | .unused, |
| 3033 | .unused, |
| 3034 | .unused, |
| 3035 | }, |
| 3036 | .dst_temps = .{.mem}, |
| 2851 | 3037 | .each = .{ .once = &.{ |
| 2852 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 2853 | | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 2854 | | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 3038 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 3039 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 3040 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| 3041 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 2855 | 3042 | } }, |
| 2856 | 3043 | }, .{ |
| 2857 | | .required_features = .{ .cmov, null, null, null }, |
| 2858 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, |
| 3044 | .required_features = .{ .avx, null, null, null }, |
| 3045 | .src_constraints = .{ |
| 3046 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3047 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3048 | .any, |
| 3049 | }, |
| 2859 | 3050 | .patterns = &.{ |
| 2860 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3051 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3052 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 3053 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2861 | 3054 | }, |
| 2862 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2863 | | .clobbers = .{ .eflags = true }, |
| 3055 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2864 | 3056 | .each = .{ .once = &.{ |
| 2865 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 2866 | | .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ }, |
| 3057 | .{ ._, .v_pd, .add, .dst0x, .src0x, .src1x, ._ }, |
| 2867 | 3058 | } }, |
| 2868 | 3059 | }, .{ |
| 2869 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, |
| 3060 | .required_features = .{ .sse2, null, null, null }, |
| 3061 | .src_constraints = .{ |
| 3062 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3063 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3064 | .any, |
| 3065 | }, |
| 2870 | 3066 | .patterns = &.{ |
| 2871 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2872 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2873 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3067 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3068 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 3069 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 2874 | 3070 | }, |
| 2875 | 3071 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2876 | | .clobbers = .{ .eflags = true }, |
| 2877 | 3072 | .each = .{ .once = &.{ |
| 2878 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 2879 | | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 2880 | | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 3073 | .{ ._, ._pd, .add, .dst0x, .src1x, ._, ._ }, |
| 2881 | 3074 | } }, |
| 2882 | 3075 | }, .{ |
| 2883 | | .required_features = .{ .cmov, null, null, null }, |
| 2884 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, |
| 3076 | .required_features = .{ .avx, null, null, null }, |
| 3077 | .src_constraints = .{ |
| 3078 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3079 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3080 | .any, |
| 3081 | }, |
| 2885 | 3082 | .patterns = &.{ |
| 2886 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2887 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2888 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3083 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3084 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 3085 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2889 | 3086 | }, |
| 2890 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2891 | | .clobbers = .{ .eflags = true }, |
| 3087 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2892 | 3088 | .each = .{ .once = &.{ |
| 2893 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 2894 | | .{ ._, ._l, .cmov, .dst0w, .src1w, ._, ._ }, |
| 3089 | .{ ._, .v_pd, .add, .dst0y, .src0y, .src1y, ._ }, |
| 2895 | 3090 | } }, |
| 2896 | 3091 | }, .{ |
| 2897 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, |
| 3092 | .required_features = .{ .avx, null, null, null }, |
| 3093 | .src_constraints = .{ |
| 3094 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3095 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3096 | .any, |
| 3097 | }, |
| 2898 | 3098 | .patterns = &.{ |
| 2899 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2900 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2901 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3099 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2902 | 3100 | }, |
| 2903 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3101 | .extra_temps = .{ |
| 3102 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3103 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 3104 | .unused, |
| 3105 | .unused, |
| 3106 | .unused, |
| 3107 | .unused, |
| 3108 | .unused, |
| 3109 | .unused, |
| 3110 | .unused, |
| 3111 | }, |
| 3112 | .dst_temps = .{.mem}, |
| 2904 | 3113 | .clobbers = .{ .eflags = true }, |
| 2905 | 3114 | .each = .{ .once = &.{ |
| 2906 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 2907 | | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 2908 | | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 2909 | | } }, |
| 2910 | | }, .{ |
| 2911 | | .required_features = .{ .cmov, null, null, null }, |
| 2912 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, |
| 2913 | | .patterns = &.{ |
| 2914 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2915 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2916 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2917 | | }, |
| 2918 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2919 | | .clobbers = .{ .eflags = true }, |
| 2920 | | .each = .{ .once = &.{ |
| 2921 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 2922 | | .{ ._, ._b, .cmov, .dst0w, .src1w, ._, ._ }, |
| 2923 | | } }, |
| 2924 | | }, .{ |
| 2925 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, |
| 2926 | | .patterns = &.{ |
| 2927 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2928 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2929 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2930 | | }, |
| 2931 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2932 | | .clobbers = .{ .eflags = true }, |
| 2933 | | .each = .{ .once = &.{ |
| 2934 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 2935 | | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 2936 | | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 2937 | | } }, |
| 2938 | | }, .{ |
| 2939 | | .required_features = .{ .cmov, null, null, null }, |
| 2940 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, |
| 2941 | | .patterns = &.{ |
| 2942 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2943 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2944 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 2945 | | }, |
| 2946 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2947 | | .clobbers = .{ .eflags = true }, |
| 2948 | | .each = .{ .once = &.{ |
| 2949 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 2950 | | .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ }, |
| 3115 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3116 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3117 | .{ ._, .v_pd, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 3118 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 3119 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3120 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2951 | 3121 | } }, |
| 2952 | 3122 | }, .{ |
| 2953 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, |
| 2954 | | .patterns = &.{ |
| 2955 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2956 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2957 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3123 | .required_features = .{ .sse2, null, null, null }, |
| 3124 | .src_constraints = .{ |
| 3125 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3126 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3127 | .any, |
| 2958 | 3128 | }, |
| 2959 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2960 | | .clobbers = .{ .eflags = true }, |
| 2961 | | .each = .{ .once = &.{ |
| 2962 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 2963 | | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 2964 | | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 2965 | | } }, |
| 2966 | | }, .{ |
| 2967 | | .required_features = .{ .cmov, null, null, null }, |
| 2968 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, |
| 2969 | 3129 | .patterns = &.{ |
| 2970 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2971 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2972 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3130 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2973 | 3131 | }, |
| 2974 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 2975 | | .clobbers = .{ .eflags = true }, |
| 2976 | | .each = .{ .once = &.{ |
| 2977 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 2978 | | .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ }, |
| 2979 | | } }, |
| 2980 | | }, .{ |
| 2981 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, |
| 2982 | | .patterns = &.{ |
| 2983 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2984 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 2985 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3132 | .extra_temps = .{ |
| 3133 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3134 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 3135 | .unused, |
| 3136 | .unused, |
| 3137 | .unused, |
| 3138 | .unused, |
| 3139 | .unused, |
| 3140 | .unused, |
| 3141 | .unused, |
| 2986 | 3142 | }, |
| 2987 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3143 | .dst_temps = .{.mem}, |
| 2988 | 3144 | .clobbers = .{ .eflags = true }, |
| 2989 | 3145 | .each = .{ .once = &.{ |
| 2990 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 2991 | | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 2992 | | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 3146 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3147 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3148 | .{ ._, ._pd, .add, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3149 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3150 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3151 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 2993 | 3152 | } }, |
| 2994 | 3153 | }, .{ |
| 2995 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 2996 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, |
| 2997 | | .patterns = &.{ |
| 2998 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 2999 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3000 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3154 | .required_features = .{ .x87, null, null, null }, |
| 3155 | .src_constraints = .{ |
| 3156 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3157 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3158 | .any, |
| 3001 | 3159 | }, |
| 3002 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3003 | | .clobbers = .{ .eflags = true }, |
| 3004 | | .each = .{ .once = &.{ |
| 3005 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 3006 | | .{ ._, ._l, .cmov, .dst0q, .src1q, ._, ._ }, |
| 3007 | | } }, |
| 3008 | | }, .{ |
| 3009 | | .required_features = .{ .@"64bit", null, null, null }, |
| 3010 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, |
| 3011 | 3160 | .patterns = &.{ |
| 3012 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3013 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3014 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3161 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3015 | 3162 | }, |
| 3016 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3017 | | .clobbers = .{ .eflags = true }, |
| 3018 | | .each = .{ .once = &.{ |
| 3019 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 3020 | | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 3021 | | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 3022 | | } }, |
| 3023 | | }, .{ |
| 3024 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 3025 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, |
| 3026 | | .patterns = &.{ |
| 3027 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3028 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3029 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3163 | .extra_temps = .{ |
| 3164 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3165 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 3166 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3167 | .unused, |
| 3168 | .unused, |
| 3169 | .unused, |
| 3170 | .unused, |
| 3171 | .unused, |
| 3172 | .unused, |
| 3030 | 3173 | }, |
| 3031 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3032 | | .clobbers = .{ .eflags = true }, |
| 3174 | .dst_temps = .{.mem}, |
| 3033 | 3175 | .each = .{ .once = &.{ |
| 3034 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 3035 | | .{ ._, ._b, .cmov, .dst0q, .src1q, ._, ._ }, |
| 3176 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3177 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3178 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3179 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| 3180 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3181 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 3182 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3036 | 3183 | } }, |
| 3037 | 3184 | }, .{ |
| 3038 | | .required_features = .{ .@"64bit", null, null, null }, |
| 3039 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, |
| 3040 | | .patterns = &.{ |
| 3041 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 3042 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 3043 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 3185 | .required_features = .{ .x87, null, null, null }, |
| 3186 | .src_constraints = .{ |
| 3187 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3188 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3189 | .any, |
| 3044 | 3190 | }, |
| 3045 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3046 | | .clobbers = .{ .eflags = true }, |
| 3047 | | .each = .{ .once = &.{ |
| 3048 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 3049 | | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 3050 | | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 3051 | | } }, |
| 3052 | | }, .{ |
| 3053 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 3054 | | .src_constraints = .{ .any_signed_int, .any_signed_int }, |
| 3055 | 3191 | .patterns = &.{ |
| 3056 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3192 | .{ .src = .{ .mem, .mem, .none } }, |
| 3057 | 3193 | }, |
| 3058 | 3194 | .extra_temps = .{ |
| 3059 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 3060 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 3061 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 3195 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 3196 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3197 | .unused, |
| 3062 | 3198 | .unused, |
| 3063 | 3199 | .unused, |
| 3064 | 3200 | .unused, |
| ... | ... | @@ -3066,34 +3202,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3066 | 3202 | .unused, |
| 3067 | 3203 | .unused, |
| 3068 | 3204 | }, |
| 3069 | | .dst_temps = .{.mem}, |
| 3070 | | .clobbers = .{ .eflags = true }, |
| 3205 | .dst_temps = .{.{ .rc = .x87 }}, |
| 3071 | 3206 | .each = .{ .once = &.{ |
| 3072 | | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 3073 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 3074 | | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 3075 | | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 3076 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3077 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3078 | | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 3079 | | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 3080 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 3081 | | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 3082 | | .{ ._, ._l, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 3083 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 3084 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 3085 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 3207 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 3208 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 3209 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| 3210 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 3086 | 3211 | } }, |
| 3087 | 3212 | }, .{ |
| 3088 | | .required_features = .{ .@"64bit", null, null, null }, |
| 3089 | | .src_constraints = .{ .any_signed_int, .any_signed_int }, |
| 3213 | .required_features = .{ .x87, null, null, null }, |
| 3214 | .src_constraints = .{ |
| 3215 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3216 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3217 | .any, |
| 3218 | }, |
| 3090 | 3219 | .patterns = &.{ |
| 3091 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3220 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 3221 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 3222 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 3092 | 3223 | }, |
| 3093 | 3224 | .extra_temps = .{ |
| 3094 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 3095 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 3096 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 3225 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3226 | .unused, |
| 3227 | .unused, |
| 3097 | 3228 | .unused, |
| 3098 | 3229 | .unused, |
| 3099 | 3230 | .unused, |
| ... | ... | @@ -3101,34 +3232,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3101 | 3232 | .unused, |
| 3102 | 3233 | .unused, |
| 3103 | 3234 | }, |
| 3104 | | .dst_temps = .{.mem}, |
| 3105 | | .clobbers = .{ .eflags = true }, |
| 3235 | .dst_temps = .{.{ .rc = .x87 }}, |
| 3106 | 3236 | .each = .{ .once = &.{ |
| 3107 | | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 3108 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 3109 | | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 3110 | | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 3111 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3112 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3113 | | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 3114 | | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 3115 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 3116 | | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 3117 | | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 3118 | | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 3119 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 3120 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 3237 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 3238 | .{ ._, .f_, .add, .tmp0t, .src1t, ._, ._ }, |
| 3239 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 3121 | 3240 | } }, |
| 3122 | 3241 | }, .{ |
| 3123 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 3124 | | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, |
| 3242 | .required_features = .{ .x87, null, null, null }, |
| 3243 | .src_constraints = .{ |
| 3244 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3245 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3246 | .any, |
| 3247 | }, |
| 3125 | 3248 | .patterns = &.{ |
| 3126 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3249 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3127 | 3250 | }, |
| 3128 | 3251 | .extra_temps = .{ |
| 3129 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 3130 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 3131 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 3252 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3253 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 3254 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3132 | 3255 | .unused, |
| 3133 | 3256 | .unused, |
| 3134 | 3257 | .unused, |
| ... | ... | @@ -3137,31 +3260,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3137 | 3260 | .unused, |
| 3138 | 3261 | }, |
| 3139 | 3262 | .dst_temps = .{.mem}, |
| 3140 | | .clobbers = .{ .eflags = true }, |
| 3141 | 3263 | .each = .{ .once = &.{ |
| 3142 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 3143 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 3144 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 3145 | | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 3146 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3147 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3148 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 3149 | | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 3150 | | .{ ._, ._b, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 3151 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 3152 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 3153 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 3264 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3265 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3266 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3267 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| 3268 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3269 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3270 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3154 | 3271 | } }, |
| 3155 | 3272 | }, .{ |
| 3156 | | .required_features = .{ .@"64bit", null, null, null }, |
| 3157 | | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, |
| 3273 | .required_features = .{ .sse, null, null, null }, |
| 3274 | .src_constraints = .{ |
| 3275 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3276 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3277 | .any, |
| 3278 | }, |
| 3158 | 3279 | .patterns = &.{ |
| 3159 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3280 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 3160 | 3281 | }, |
| 3282 | .call_frame = .{ .alignment = .@"16" }, |
| 3161 | 3283 | .extra_temps = .{ |
| 3162 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 3163 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 3164 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 3284 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } }, |
| 3285 | .unused, |
| 3286 | .unused, |
| 3165 | 3287 | .unused, |
| 3166 | 3288 | .unused, |
| 3167 | 3289 | .unused, |
| ... | ... | @@ -3169,100 +3291,93 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3169 | 3291 | .unused, |
| 3170 | 3292 | .unused, |
| 3171 | 3293 | }, |
| 3172 | | .dst_temps = .{.mem}, |
| 3173 | | .clobbers = .{ .eflags = true }, |
| 3294 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3295 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3174 | 3296 | .each = .{ .once = &.{ |
| 3175 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 3176 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 3177 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 3178 | | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 3179 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3180 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3181 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 3182 | | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 3183 | | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 3184 | | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 3185 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 3186 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 3297 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 3187 | 3298 | } }, |
| 3188 | 3299 | }, .{ |
| 3189 | 3300 | .required_features = .{ .avx, null, null, null }, |
| 3190 | 3301 | .src_constraints = .{ |
| 3191 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3192 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3302 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3303 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3304 | .any, |
| 3193 | 3305 | }, |
| 3194 | 3306 | .patterns = &.{ |
| 3195 | | .{ .src = .{ .to_sse, .mem } }, |
| 3196 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 3197 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 3198 | | }, |
| 3199 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3200 | | .each = .{ .once = &.{ |
| 3201 | | .{ ._, .vp_b, .maxs, .dst0x, .src0x, .src1x, ._ }, |
| 3202 | | } }, |
| 3203 | | }, .{ |
| 3204 | | .required_features = .{ .sse4_1, null, null, null }, |
| 3205 | | .src_constraints = .{ |
| 3206 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3207 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3307 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3208 | 3308 | }, |
| 3209 | | .patterns = &.{ |
| 3210 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 3211 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 3212 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 3309 | .call_frame = .{ .alignment = .@"16" }, |
| 3310 | .extra_temps = .{ |
| 3311 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3312 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 3313 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 3314 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } }, |
| 3315 | .unused, |
| 3316 | .unused, |
| 3317 | .unused, |
| 3318 | .unused, |
| 3319 | .unused, |
| 3213 | 3320 | }, |
| 3214 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3321 | .dst_temps = .{.mem}, |
| 3322 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3215 | 3323 | .each = .{ .once = &.{ |
| 3216 | | .{ ._, .p_b, .maxs, .dst0x, .src1x, ._, ._ }, |
| 3324 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3325 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3326 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3327 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3328 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3329 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3330 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3217 | 3331 | } }, |
| 3218 | 3332 | }, .{ |
| 3219 | 3333 | .required_features = .{ .sse2, null, null, null }, |
| 3220 | 3334 | .src_constraints = .{ |
| 3221 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3222 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3335 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3336 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3337 | .any, |
| 3223 | 3338 | }, |
| 3224 | 3339 | .patterns = &.{ |
| 3225 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 3226 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 3227 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 3228 | | }, |
| 3229 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3230 | | .each = .{ .once = &.{ |
| 3231 | | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| 3232 | | .{ ._, .p_b, .cmpgt, .dst0x, .src1x, ._, ._ }, |
| 3233 | | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 3234 | | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 3235 | | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 3236 | | } }, |
| 3237 | | }, .{ |
| 3238 | | .required_features = .{ .avx2, null, null, null }, |
| 3239 | | .src_constraints = .{ |
| 3240 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 3241 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 3340 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3242 | 3341 | }, |
| 3243 | | .patterns = &.{ |
| 3244 | | .{ .src = .{ .to_sse, .mem } }, |
| 3245 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 3246 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 3342 | .call_frame = .{ .alignment = .@"16" }, |
| 3343 | .extra_temps = .{ |
| 3344 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3345 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 3346 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 3347 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } }, |
| 3348 | .unused, |
| 3349 | .unused, |
| 3350 | .unused, |
| 3351 | .unused, |
| 3352 | .unused, |
| 3247 | 3353 | }, |
| 3248 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3354 | .dst_temps = .{.mem}, |
| 3355 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3249 | 3356 | .each = .{ .once = &.{ |
| 3250 | | .{ ._, .vp_b, .maxs, .dst0y, .src0y, .src1y, ._ }, |
| 3357 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3358 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3359 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3360 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3361 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3362 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3363 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3251 | 3364 | } }, |
| 3252 | 3365 | }, .{ |
| 3253 | | .required_features = .{ .avx2, null, null, null }, |
| 3366 | .required_features = .{ .sse, null, null, null }, |
| 3254 | 3367 | .src_constraints = .{ |
| 3255 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 3256 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 3368 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3369 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3370 | .any, |
| 3257 | 3371 | }, |
| 3258 | 3372 | .patterns = &.{ |
| 3259 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3373 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3260 | 3374 | }, |
| 3375 | .call_frame = .{ .alignment = .@"16" }, |
| 3261 | 3376 | .extra_temps = .{ |
| 3262 | 3377 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3263 | | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 3264 | | .unused, |
| 3265 | | .unused, |
| 3378 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 3379 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 3380 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } }, |
| 3266 | 3381 | .unused, |
| 3267 | 3382 | .unused, |
| 3268 | 3383 | .unused, |
| ... | ... | @@ -3270,27 +3385,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3270 | 3385 | .unused, |
| 3271 | 3386 | }, |
| 3272 | 3387 | .dst_temps = .{.mem}, |
| 3273 | | .clobbers = .{ .eflags = true }, |
| 3388 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3274 | 3389 | .each = .{ .once = &.{ |
| 3275 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3276 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3277 | | .{ ._, .vp_b, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3278 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 3279 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3390 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3391 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3392 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3393 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3394 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3395 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3280 | 3396 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3281 | 3397 | } }, |
| 3282 | | }, .{ |
| 3283 | | .required_features = .{ .avx, null, null, null }, |
| 3398 | } }) catch |err| switch (err) { |
| 3399 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 3400 | @tagName(air_tag), |
| 3401 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 3402 | ops[0].tracking(cg), |
| 3403 | ops[1].tracking(cg), |
| 3404 | }), |
| 3405 | else => |e| return e, |
| 3406 | }; |
| 3407 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 3408 | }, |
| 3409 | .sub, .sub_optimized => |air_tag| if (use_old) try cg.airBinOp(inst, .sub) else fallback: { |
| 3410 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 3411 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airBinOp(inst, air_tag); |
| 3412 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 3413 | var res: [1]Temp = undefined; |
| 3414 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 3415 | .required_features = .{ .f16c, null, null, null }, |
| 3284 | 3416 | .src_constraints = .{ |
| 3285 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3286 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3417 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 3418 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 3419 | .any, |
| 3287 | 3420 | }, |
| 3288 | 3421 | .patterns = &.{ |
| 3289 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3422 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3290 | 3423 | }, |
| 3291 | 3424 | .extra_temps = .{ |
| 3292 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3293 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 3425 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 3426 | .unused, |
| 3294 | 3427 | .unused, |
| 3295 | 3428 | .unused, |
| 3296 | 3429 | .unused, |
| ... | ... | @@ -3299,28 +3432,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3299 | 3432 | .unused, |
| 3300 | 3433 | .unused, |
| 3301 | 3434 | }, |
| 3302 | | .dst_temps = .{.mem}, |
| 3303 | | .clobbers = .{ .eflags = true }, |
| 3435 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3304 | 3436 | .each = .{ .once = &.{ |
| 3305 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3306 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3307 | | .{ ._, .vp_b, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3308 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 3309 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3310 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3437 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 3438 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 3439 | .{ ._, .v_ss, .sub, .dst0x, .dst0x, .tmp0d, ._ }, |
| 3440 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 3311 | 3441 | } }, |
| 3312 | 3442 | }, .{ |
| 3313 | | .required_features = .{ .sse4_1, null, null, null }, |
| 3443 | .required_features = .{ .sse, null, null, null }, |
| 3314 | 3444 | .src_constraints = .{ |
| 3315 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3316 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3445 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 3446 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 3447 | .any, |
| 3317 | 3448 | }, |
| 3318 | 3449 | .patterns = &.{ |
| 3319 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3450 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 3320 | 3451 | }, |
| 3452 | .call_frame = .{ .alignment = .@"16" }, |
| 3321 | 3453 | .extra_temps = .{ |
| 3322 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3323 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 3454 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3455 | .unused, |
| 3324 | 3456 | .unused, |
| 3325 | 3457 | .unused, |
| 3326 | 3458 | .unused, |
| ... | ... | @@ -3329,29 +3461,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3329 | 3461 | .unused, |
| 3330 | 3462 | .unused, |
| 3331 | 3463 | }, |
| 3332 | | .dst_temps = .{.mem}, |
| 3333 | | .clobbers = .{ .eflags = true }, |
| 3464 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3465 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3334 | 3466 | .each = .{ .once = &.{ |
| 3335 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3336 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3337 | | .{ ._, .p_b, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 3338 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 3339 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3340 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3467 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 3341 | 3468 | } }, |
| 3342 | 3469 | }, .{ |
| 3343 | | .required_features = .{ .sse2, null, null, null }, |
| 3470 | .required_features = .{ .f16c, null, null, null }, |
| 3344 | 3471 | .src_constraints = .{ |
| 3345 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3346 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 3472 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 3473 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 3474 | .any, |
| 3347 | 3475 | }, |
| 3348 | 3476 | .patterns = &.{ |
| 3349 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3477 | .{ .src = .{ .mem, .mem, .none } }, |
| 3478 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3479 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 3480 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3350 | 3481 | }, |
| 3351 | 3482 | .extra_temps = .{ |
| 3352 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3353 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 3354 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 3483 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 3484 | .unused, |
| 3485 | .unused, |
| 3355 | 3486 | .unused, |
| 3356 | 3487 | .unused, |
| 3357 | 3488 | .unused, |
| ... | ... | @@ -3359,33 +3490,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3359 | 3490 | .unused, |
| 3360 | 3491 | .unused, |
| 3361 | 3492 | }, |
| 3362 | | .dst_temps = .{.mem}, |
| 3363 | | .clobbers = .{ .eflags = true }, |
| 3493 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3364 | 3494 | .each = .{ .once = &.{ |
| 3365 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3366 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3367 | | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 3368 | | .{ ._, .p_b, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 3369 | | .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ }, |
| 3370 | | .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 3371 | | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, |
| 3372 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 3373 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3374 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3495 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 3496 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 3497 | .{ ._, .v_ps, .sub, .dst0x, .dst0x, .tmp0x, ._ }, |
| 3498 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 3375 | 3499 | } }, |
| 3376 | 3500 | }, .{ |
| 3377 | | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| 3501 | .required_features = .{ .f16c, null, null, null }, |
| 3378 | 3502 | .src_constraints = .{ |
| 3379 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3380 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3503 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 3504 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 3505 | .any, |
| 3381 | 3506 | }, |
| 3382 | 3507 | .patterns = &.{ |
| 3383 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3508 | .{ .src = .{ .mem, .mem, .none } }, |
| 3509 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3510 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 3511 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3384 | 3512 | }, |
| 3385 | 3513 | .extra_temps = .{ |
| 3386 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3387 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 3388 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 3514 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 3515 | .unused, |
| 3516 | .unused, |
| 3389 | 3517 | .unused, |
| 3390 | 3518 | .unused, |
| 3391 | 3519 | .unused, |
| ... | ... | @@ -3393,31 +3521,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3393 | 3521 | .unused, |
| 3394 | 3522 | .unused, |
| 3395 | 3523 | }, |
| 3396 | | .dst_temps = .{.mem}, |
| 3397 | | .clobbers = .{ .eflags = true }, |
| 3524 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3398 | 3525 | .each = .{ .once = &.{ |
| 3399 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3400 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3401 | | .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3402 | | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 3403 | | .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 3404 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3405 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 3406 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3526 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 3527 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 3528 | .{ ._, .v_ps, .sub, .dst0y, .dst0y, .tmp0y, ._ }, |
| 3529 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 3407 | 3530 | } }, |
| 3408 | 3531 | }, .{ |
| 3409 | | .required_features = .{ .cmov, null, null, null }, |
| 3532 | .required_features = .{ .f16c, null, null, null }, |
| 3410 | 3533 | .src_constraints = .{ |
| 3411 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3412 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3534 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 3535 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 3536 | .any, |
| 3413 | 3537 | }, |
| 3414 | 3538 | .patterns = &.{ |
| 3415 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3539 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3416 | 3540 | }, |
| 3417 | 3541 | .extra_temps = .{ |
| 3418 | 3542 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3419 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 3420 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 3543 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 3544 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 3421 | 3545 | .unused, |
| 3422 | 3546 | .unused, |
| 3423 | 3547 | .unused, |
| ... | ... | @@ -3428,29 +3552,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3428 | 3552 | .dst_temps = .{.mem}, |
| 3429 | 3553 | .clobbers = .{ .eflags = true }, |
| 3430 | 3554 | .each = .{ .once = &.{ |
| 3431 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3432 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3433 | | .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3434 | | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 3435 | | .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 3436 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3437 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3438 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3555 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3556 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3557 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3558 | .{ ._, .v_ps, .sub, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 3559 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 3560 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3561 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3439 | 3562 | } }, |
| 3440 | 3563 | }, .{ |
| 3441 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 3564 | .required_features = .{ .avx, null, null, null }, |
| 3442 | 3565 | .src_constraints = .{ |
| 3443 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3444 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3566 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3567 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3568 | .any, |
| 3445 | 3569 | }, |
| 3446 | 3570 | .patterns = &.{ |
| 3447 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3571 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3448 | 3572 | }, |
| 3573 | .call_frame = .{ .alignment = .@"16" }, |
| 3449 | 3574 | .extra_temps = .{ |
| 3450 | 3575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3451 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 3452 | | .unused, |
| 3453 | | .unused, |
| 3576 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 3577 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 3578 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3454 | 3579 | .unused, |
| 3455 | 3580 | .unused, |
| 3456 | 3581 | .unused, |
| ... | ... | @@ -3458,180 +3583,215 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3458 | 3583 | .unused, |
| 3459 | 3584 | }, |
| 3460 | 3585 | .dst_temps = .{.mem}, |
| 3461 | | .clobbers = .{ .eflags = true }, |
| 3586 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3462 | 3587 | .each = .{ .once = &.{ |
| 3463 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3464 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3465 | | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3466 | | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 3467 | | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3468 | | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3469 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 3588 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3589 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 3590 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 3591 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 3592 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3593 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 3594 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3470 | 3595 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3471 | 3596 | } }, |
| 3472 | 3597 | }, .{ |
| 3598 | .required_features = .{ .sse4_1, null, null, null }, |
| 3473 | 3599 | .src_constraints = .{ |
| 3474 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3475 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 3600 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3601 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3602 | .any, |
| 3476 | 3603 | }, |
| 3477 | 3604 | .patterns = &.{ |
| 3478 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3605 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3479 | 3606 | }, |
| 3607 | .call_frame = .{ .alignment = .@"16" }, |
| 3480 | 3608 | .extra_temps = .{ |
| 3481 | 3609 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3482 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 3610 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 3611 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 3612 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3483 | 3613 | .unused, |
| 3484 | 3614 | .unused, |
| 3485 | 3615 | .unused, |
| 3486 | 3616 | .unused, |
| 3487 | 3617 | .unused, |
| 3618 | }, |
| 3619 | .dst_temps = .{.mem}, |
| 3620 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3621 | .each = .{ .once = &.{ |
| 3622 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3623 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 3624 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 3625 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 3626 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 3627 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3628 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 3629 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3630 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3631 | } }, |
| 3632 | }, .{ |
| 3633 | .required_features = .{ .sse2, null, null, null }, |
| 3634 | .src_constraints = .{ |
| 3635 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3636 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3637 | .any, |
| 3638 | }, |
| 3639 | .patterns = &.{ |
| 3640 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3641 | }, |
| 3642 | .call_frame = .{ .alignment = .@"16" }, |
| 3643 | .extra_temps = .{ |
| 3644 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3645 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 3646 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 3647 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3648 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 3649 | .unused, |
| 3650 | .unused, |
| 3488 | 3651 | .unused, |
| 3489 | 3652 | .unused, |
| 3490 | 3653 | }, |
| 3491 | 3654 | .dst_temps = .{.mem}, |
| 3492 | | .clobbers = .{ .eflags = true }, |
| 3655 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3493 | 3656 | .each = .{ .once = &.{ |
| 3494 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3495 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3496 | | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3497 | | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 3498 | | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3499 | | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3500 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3501 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3657 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3658 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 3659 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 3660 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 3661 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 3662 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3663 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 3664 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 3665 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3666 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3502 | 3667 | } }, |
| 3503 | 3668 | }, .{ |
| 3504 | | .required_features = .{ .sse, .mmx, null, null }, |
| 3669 | .required_features = .{ .sse, null, null, null }, |
| 3505 | 3670 | .src_constraints = .{ |
| 3506 | | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 3507 | | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 3671 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3672 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3673 | .any, |
| 3508 | 3674 | }, |
| 3509 | 3675 | .patterns = &.{ |
| 3510 | | .{ .src = .{ .to_mut_mmx, .mem } }, |
| 3511 | | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, |
| 3512 | | .{ .src = .{ .to_mut_mmx, .to_mmx } }, |
| 3676 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3513 | 3677 | }, |
| 3514 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3678 | .call_frame = .{ .alignment = .@"16" }, |
| 3679 | .extra_temps = .{ |
| 3680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3681 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 3682 | .{ .type = .f32, .kind = .mem }, |
| 3683 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 3684 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 3685 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3686 | .unused, |
| 3687 | .unused, |
| 3688 | .unused, |
| 3689 | }, |
| 3690 | .dst_temps = .{.mem}, |
| 3691 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3515 | 3692 | .each = .{ .once = &.{ |
| 3516 | | .{ ._, .p_b, .maxu, .dst0q, .src1q, ._, ._ }, |
| 3693 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3694 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3695 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 3696 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 3697 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3698 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 3699 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 3700 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 3701 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 3702 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 3703 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 3704 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3705 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3517 | 3706 | } }, |
| 3518 | 3707 | }, .{ |
| 3519 | 3708 | .required_features = .{ .avx, null, null, null }, |
| 3520 | 3709 | .src_constraints = .{ |
| 3521 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3522 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3710 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 3711 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 3712 | .any, |
| 3523 | 3713 | }, |
| 3524 | 3714 | .patterns = &.{ |
| 3525 | | .{ .src = .{ .to_sse, .mem } }, |
| 3526 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 3527 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 3715 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3716 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3528 | 3717 | }, |
| 3529 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3718 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3530 | 3719 | .each = .{ .once = &.{ |
| 3531 | | .{ ._, .vp_b, .maxu, .dst0x, .src0x, .src1x, ._ }, |
| 3720 | .{ ._, .v_ss, .sub, .dst0x, .src0x, .src1d, ._ }, |
| 3532 | 3721 | } }, |
| 3533 | 3722 | }, .{ |
| 3534 | | .required_features = .{ .sse2, null, null, null }, |
| 3723 | .required_features = .{ .sse, null, null, null }, |
| 3535 | 3724 | .src_constraints = .{ |
| 3536 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3537 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3725 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 3726 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 3727 | .any, |
| 3538 | 3728 | }, |
| 3539 | 3729 | .patterns = &.{ |
| 3540 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 3541 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 3542 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 3730 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3731 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 3543 | 3732 | }, |
| 3544 | 3733 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3545 | 3734 | .each = .{ .once = &.{ |
| 3546 | | .{ ._, .p_b, .maxu, .dst0x, .src1x, ._, ._ }, |
| 3735 | .{ ._, ._ss, .sub, .dst0x, .src1d, ._, ._ }, |
| 3547 | 3736 | } }, |
| 3548 | 3737 | }, .{ |
| 3549 | | .required_features = .{ .avx2, null, null, null }, |
| 3738 | .required_features = .{ .avx, null, null, null }, |
| 3550 | 3739 | .src_constraints = .{ |
| 3551 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 3552 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 3740 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3741 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3742 | .any, |
| 3553 | 3743 | }, |
| 3554 | 3744 | .patterns = &.{ |
| 3555 | | .{ .src = .{ .to_sse, .mem } }, |
| 3556 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 3557 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 3745 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3746 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3558 | 3747 | }, |
| 3559 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3748 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3560 | 3749 | .each = .{ .once = &.{ |
| 3561 | | .{ ._, .vp_b, .maxu, .dst0y, .src0y, .src1y, ._ }, |
| 3750 | .{ ._, .v_ps, .sub, .dst0x, .src0x, .src1x, ._ }, |
| 3562 | 3751 | } }, |
| 3563 | 3752 | }, .{ |
| 3564 | | .required_features = .{ .avx2, null, null, null }, |
| 3753 | .required_features = .{ .sse, null, null, null }, |
| 3565 | 3754 | .src_constraints = .{ |
| 3566 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 3567 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 3755 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3756 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3757 | .any, |
| 3568 | 3758 | }, |
| 3569 | 3759 | .patterns = &.{ |
| 3570 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3571 | | }, |
| 3572 | | .extra_temps = .{ |
| 3573 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3574 | | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 3575 | | .unused, |
| 3576 | | .unused, |
| 3577 | | .unused, |
| 3578 | | .unused, |
| 3579 | | .unused, |
| 3580 | | .unused, |
| 3581 | | .unused, |
| 3760 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3761 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 3582 | 3762 | }, |
| 3583 | | .dst_temps = .{.mem}, |
| 3584 | | .clobbers = .{ .eflags = true }, |
| 3763 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3585 | 3764 | .each = .{ .once = &.{ |
| 3586 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3587 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3588 | | .{ ._, .vp_b, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3589 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 3590 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3591 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3765 | .{ ._, ._ps, .sub, .dst0x, .src1x, ._, ._ }, |
| 3592 | 3766 | } }, |
| 3593 | 3767 | }, .{ |
| 3594 | 3768 | .required_features = .{ .avx, null, null, null }, |
| 3595 | 3769 | .src_constraints = .{ |
| 3596 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3597 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3770 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 3771 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 3772 | .any, |
| 3598 | 3773 | }, |
| 3599 | 3774 | .patterns = &.{ |
| 3600 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3601 | | }, |
| 3602 | | .extra_temps = .{ |
| 3603 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3604 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 3605 | | .unused, |
| 3606 | | .unused, |
| 3607 | | .unused, |
| 3608 | | .unused, |
| 3609 | | .unused, |
| 3610 | | .unused, |
| 3611 | | .unused, |
| 3775 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3776 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3612 | 3777 | }, |
| 3613 | | .dst_temps = .{.mem}, |
| 3614 | | .clobbers = .{ .eflags = true }, |
| 3778 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3615 | 3779 | .each = .{ .once = &.{ |
| 3616 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3617 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3618 | | .{ ._, .vp_b, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3619 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 3620 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3621 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3780 | .{ ._, .v_ps, .sub, .dst0y, .src0y, .src1y, ._ }, |
| 3622 | 3781 | } }, |
| 3623 | 3782 | }, .{ |
| 3624 | | .required_features = .{ .sse2, null, null, null }, |
| 3783 | .required_features = .{ .avx, null, null, null }, |
| 3625 | 3784 | .src_constraints = .{ |
| 3626 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3627 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 3785 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 3786 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 3787 | .any, |
| 3628 | 3788 | }, |
| 3629 | 3789 | .patterns = &.{ |
| 3630 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3790 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3631 | 3791 | }, |
| 3632 | 3792 | .extra_temps = .{ |
| 3633 | 3793 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3634 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 3794 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 3635 | 3795 | .unused, |
| 3636 | 3796 | .unused, |
| 3637 | 3797 | .unused, |
| ... | ... | @@ -3643,26 +3803,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3643 | 3803 | .dst_temps = .{.mem}, |
| 3644 | 3804 | .clobbers = .{ .eflags = true }, |
| 3645 | 3805 | .each = .{ .once = &.{ |
| 3646 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3647 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3648 | | .{ ._, .p_b, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 3649 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 3650 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3806 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3807 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3808 | .{ ._, .v_ps, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 3809 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 3810 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3651 | 3811 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3652 | 3812 | } }, |
| 3653 | 3813 | }, .{ |
| 3654 | | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| 3814 | .required_features = .{ .sse, null, null, null }, |
| 3655 | 3815 | .src_constraints = .{ |
| 3656 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3657 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3816 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3817 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3818 | .any, |
| 3658 | 3819 | }, |
| 3659 | 3820 | .patterns = &.{ |
| 3660 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3821 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3661 | 3822 | }, |
| 3662 | 3823 | .extra_temps = .{ |
| 3663 | 3824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3664 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3665 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3825 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 3826 | .unused, |
| 3666 | 3827 | .unused, |
| 3667 | 3828 | .unused, |
| 3668 | 3829 | .unused, |
| ... | ... | @@ -3673,90 +3834,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3673 | 3834 | .dst_temps = .{.mem}, |
| 3674 | 3835 | .clobbers = .{ .eflags = true }, |
| 3675 | 3836 | .each = .{ .once = &.{ |
| 3676 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3677 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3678 | | .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3679 | | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 3680 | | .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 3681 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3682 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 3837 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3838 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3839 | .{ ._, ._ps, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3840 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3683 | 3842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3684 | 3843 | } }, |
| 3685 | 3844 | }, .{ |
| 3686 | | .required_features = .{ .cmov, null, null, null }, |
| 3845 | .required_features = .{ .avx, null, null, null }, |
| 3687 | 3846 | .src_constraints = .{ |
| 3688 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3689 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3847 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3848 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3849 | .any, |
| 3690 | 3850 | }, |
| 3691 | 3851 | .patterns = &.{ |
| 3692 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3693 | | }, |
| 3694 | | .extra_temps = .{ |
| 3695 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3696 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3697 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3698 | | .unused, |
| 3699 | | .unused, |
| 3700 | | .unused, |
| 3701 | | .unused, |
| 3702 | | .unused, |
| 3703 | | .unused, |
| 3852 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3853 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3704 | 3854 | }, |
| 3705 | | .dst_temps = .{.mem}, |
| 3706 | | .clobbers = .{ .eflags = true }, |
| 3855 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3707 | 3856 | .each = .{ .once = &.{ |
| 3708 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3709 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3710 | | .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3711 | | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 3712 | | .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 3713 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3714 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3715 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3857 | .{ ._, .v_sd, .sub, .dst0x, .src0x, .src1q, ._ }, |
| 3716 | 3858 | } }, |
| 3717 | 3859 | }, .{ |
| 3718 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 3860 | .required_features = .{ .sse2, null, null, null }, |
| 3719 | 3861 | .src_constraints = .{ |
| 3720 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3721 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3862 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3863 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3864 | .any, |
| 3722 | 3865 | }, |
| 3723 | 3866 | .patterns = &.{ |
| 3724 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3867 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3868 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 3725 | 3869 | }, |
| 3726 | | .extra_temps = .{ |
| 3727 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3728 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3729 | | .unused, |
| 3730 | | .unused, |
| 3731 | | .unused, |
| 3732 | | .unused, |
| 3733 | | .unused, |
| 3734 | | .unused, |
| 3735 | | .unused, |
| 3736 | | }, |
| 3737 | | .dst_temps = .{.mem}, |
| 3738 | | .clobbers = .{ .eflags = true }, |
| 3870 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3739 | 3871 | .each = .{ .once = &.{ |
| 3740 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3741 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3742 | | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3743 | | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 3744 | | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3745 | | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3746 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 3747 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3872 | .{ ._, ._sd, .sub, .dst0x, .src1q, ._, ._ }, |
| 3748 | 3873 | } }, |
| 3749 | 3874 | }, .{ |
| 3875 | .required_features = .{ .x87, null, null, null }, |
| 3750 | 3876 | .src_constraints = .{ |
| 3751 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3752 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 3877 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3878 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3879 | .any, |
| 3753 | 3880 | }, |
| 3754 | 3881 | .patterns = &.{ |
| 3755 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3882 | .{ .src = .{ .mem, .mem, .none } }, |
| 3756 | 3883 | }, |
| 3757 | 3884 | .extra_temps = .{ |
| 3758 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3759 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 3885 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 3886 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3760 | 3887 | .unused, |
| 3761 | 3888 | .unused, |
| 3762 | 3889 | .unused, |
| ... | ... | @@ -3766,89 +3893,70 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3766 | 3893 | .unused, |
| 3767 | 3894 | }, |
| 3768 | 3895 | .dst_temps = .{.mem}, |
| 3769 | | .clobbers = .{ .eflags = true }, |
| 3770 | | .each = .{ .once = &.{ |
| 3771 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3772 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 3773 | | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3774 | | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 3775 | | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 3776 | | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 3777 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 3778 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 3779 | | } }, |
| 3780 | | }, .{ |
| 3781 | | .required_features = .{ .sse, .mmx, null, null }, |
| 3782 | | .src_constraints = .{ |
| 3783 | | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 3784 | | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 3785 | | }, |
| 3786 | | .patterns = &.{ |
| 3787 | | .{ .src = .{ .to_mut_mmx, .mem } }, |
| 3788 | | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, |
| 3789 | | .{ .src = .{ .to_mut_mmx, .to_mmx } }, |
| 3790 | | }, |
| 3791 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 3792 | 3896 | .each = .{ .once = &.{ |
| 3793 | | .{ ._, .p_w, .maxs, .dst0q, .src1q, ._, ._ }, |
| 3897 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 3898 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 3899 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 3900 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 3794 | 3901 | } }, |
| 3795 | 3902 | }, .{ |
| 3796 | 3903 | .required_features = .{ .avx, null, null, null }, |
| 3797 | 3904 | .src_constraints = .{ |
| 3798 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3799 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3905 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3906 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3907 | .any, |
| 3800 | 3908 | }, |
| 3801 | 3909 | .patterns = &.{ |
| 3802 | | .{ .src = .{ .to_sse, .mem } }, |
| 3803 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 3804 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 3910 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3911 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3805 | 3912 | }, |
| 3806 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3913 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3807 | 3914 | .each = .{ .once = &.{ |
| 3808 | | .{ ._, .vp_w, .maxs, .dst0x, .src0x, .src1x, ._ }, |
| 3915 | .{ ._, .v_pd, .sub, .dst0x, .src0x, .src1x, ._ }, |
| 3809 | 3916 | } }, |
| 3810 | 3917 | }, .{ |
| 3811 | 3918 | .required_features = .{ .sse2, null, null, null }, |
| 3812 | 3919 | .src_constraints = .{ |
| 3813 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3814 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3920 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3921 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3922 | .any, |
| 3815 | 3923 | }, |
| 3816 | 3924 | .patterns = &.{ |
| 3817 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 3818 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 3819 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 3925 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3926 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 3820 | 3927 | }, |
| 3821 | 3928 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3822 | 3929 | .each = .{ .once = &.{ |
| 3823 | | .{ ._, .p_w, .maxs, .dst0x, .src1x, ._, ._ }, |
| 3930 | .{ ._, ._pd, .sub, .dst0x, .src1x, ._, ._ }, |
| 3824 | 3931 | } }, |
| 3825 | 3932 | }, .{ |
| 3826 | | .required_features = .{ .avx2, null, null, null }, |
| 3933 | .required_features = .{ .avx, null, null, null }, |
| 3827 | 3934 | .src_constraints = .{ |
| 3828 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 3829 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 3935 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3936 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3937 | .any, |
| 3830 | 3938 | }, |
| 3831 | 3939 | .patterns = &.{ |
| 3832 | | .{ .src = .{ .to_sse, .mem } }, |
| 3833 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 3834 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 3940 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3941 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3835 | 3942 | }, |
| 3836 | | .dst_temps = .{.{ .rc = .sse }}, |
| 3943 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3837 | 3944 | .each = .{ .once = &.{ |
| 3838 | | .{ ._, .vp_w, .maxs, .dst0y, .src0y, .src1y, ._ }, |
| 3945 | .{ ._, .v_pd, .sub, .dst0y, .src0y, .src1y, ._ }, |
| 3839 | 3946 | } }, |
| 3840 | 3947 | }, .{ |
| 3841 | | .required_features = .{ .avx2, null, null, null }, |
| 3948 | .required_features = .{ .avx, null, null, null }, |
| 3842 | 3949 | .src_constraints = .{ |
| 3843 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 3844 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 3950 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3951 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3952 | .any, |
| 3845 | 3953 | }, |
| 3846 | 3954 | .patterns = &.{ |
| 3847 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3955 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3848 | 3956 | }, |
| 3849 | 3957 | .extra_temps = .{ |
| 3850 | 3958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3851 | | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 3959 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 3852 | 3960 | .unused, |
| 3853 | 3961 | .unused, |
| 3854 | 3962 | .unused, |
| ... | ... | @@ -3860,25 +3968,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3860 | 3968 | .dst_temps = .{.mem}, |
| 3861 | 3969 | .clobbers = .{ .eflags = true }, |
| 3862 | 3970 | .each = .{ .once = &.{ |
| 3863 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3864 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 3865 | | .{ ._, .vp_w, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 3866 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 3971 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3972 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3973 | .{ ._, .v_pd, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 3974 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 3867 | 3975 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3868 | 3976 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3869 | 3977 | } }, |
| 3870 | 3978 | }, .{ |
| 3871 | | .required_features = .{ .avx, null, null, null }, |
| 3979 | .required_features = .{ .sse2, null, null, null }, |
| 3872 | 3980 | .src_constraints = .{ |
| 3873 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3874 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3981 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3982 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3983 | .any, |
| 3875 | 3984 | }, |
| 3876 | 3985 | .patterns = &.{ |
| 3877 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 3986 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3878 | 3987 | }, |
| 3879 | 3988 | .extra_temps = .{ |
| 3880 | 3989 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3881 | | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 3990 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 3882 | 3991 | .unused, |
| 3883 | 3992 | .unused, |
| 3884 | 3993 | .unused, |
| ... | ... | @@ -3890,26 +3999,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3890 | 3999 | .dst_temps = .{.mem}, |
| 3891 | 4000 | .clobbers = .{ .eflags = true }, |
| 3892 | 4001 | .each = .{ .once = &.{ |
| 3893 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3894 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3895 | | .{ ._, .vp_w, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 3896 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4002 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4003 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4004 | .{ ._, ._pd, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4005 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3897 | 4006 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3898 | 4007 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3899 | 4008 | } }, |
| 3900 | 4009 | }, .{ |
| 3901 | | .required_features = .{ .sse2, null, null, null }, |
| 4010 | .required_features = .{ .x87, null, null, null }, |
| 3902 | 4011 | .src_constraints = .{ |
| 3903 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 3904 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 4012 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4013 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4014 | .any, |
| 3905 | 4015 | }, |
| 3906 | 4016 | .patterns = &.{ |
| 3907 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4017 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3908 | 4018 | }, |
| 3909 | 4019 | .extra_temps = .{ |
| 3910 | 4020 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3911 | | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 3912 | | .unused, |
| 4021 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 4022 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3913 | 4023 | .unused, |
| 3914 | 4024 | .unused, |
| 3915 | 4025 | .unused, |
| ... | ... | @@ -3918,27 +4028,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3918 | 4028 | .unused, |
| 3919 | 4029 | }, |
| 3920 | 4030 | .dst_temps = .{.mem}, |
| 3921 | | .clobbers = .{ .eflags = true }, |
| 3922 | 4031 | .each = .{ .once = &.{ |
| 3923 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3924 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 3925 | | .{ ._, .p_w, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 3926 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 3927 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4033 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4034 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4035 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 4036 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4037 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 3928 | 4038 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3929 | 4039 | } }, |
| 3930 | 4040 | }, .{ |
| 3931 | | .required_features = .{ .cmov, null, null, null }, |
| 4041 | .required_features = .{ .x87, null, null, null }, |
| 3932 | 4042 | .src_constraints = .{ |
| 3933 | | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 3934 | | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 4043 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4044 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4045 | .any, |
| 3935 | 4046 | }, |
| 3936 | 4047 | .patterns = &.{ |
| 3937 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4048 | .{ .src = .{ .mem, .mem, .none } }, |
| 3938 | 4049 | }, |
| 3939 | 4050 | .extra_temps = .{ |
| 3940 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3941 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4051 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 4052 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3942 | 4053 | .unused, |
| 3943 | 4054 | .unused, |
| 3944 | 4055 | .unused, |
| ... | ... | @@ -3947,28 +4058,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3947 | 4058 | .unused, |
| 3948 | 4059 | .unused, |
| 3949 | 4060 | }, |
| 3950 | | .dst_temps = .{.mem}, |
| 3951 | | .clobbers = .{ .eflags = true }, |
| 4061 | .dst_temps = .{.{ .rc = .x87 }}, |
| 3952 | 4062 | .each = .{ .once = &.{ |
| 3953 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3954 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 3955 | | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 3956 | | .{ ._, ._l, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 3957 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 3958 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3959 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4063 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4064 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 4065 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 4066 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 3960 | 4067 | } }, |
| 3961 | 4068 | }, .{ |
| 4069 | .required_features = .{ .x87, null, null, null }, |
| 3962 | 4070 | .src_constraints = .{ |
| 3963 | | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 3964 | | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 4071 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4072 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4073 | .any, |
| 3965 | 4074 | }, |
| 3966 | 4075 | .patterns = &.{ |
| 3967 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4076 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 3968 | 4077 | }, |
| 3969 | 4078 | .extra_temps = .{ |
| 3970 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3971 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4079 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4080 | .unused, |
| 3972 | 4081 | .unused, |
| 3973 | 4082 | .unused, |
| 3974 | 4083 | .unused, |
| ... | ... | @@ -3977,92 +4086,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3977 | 4086 | .unused, |
| 3978 | 4087 | .unused, |
| 3979 | 4088 | }, |
| 3980 | | .dst_temps = .{.mem}, |
| 3981 | | .clobbers = .{ .eflags = true }, |
| 3982 | | .each = .{ .once = &.{ |
| 3983 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 3984 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 3985 | | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 3986 | | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 3987 | | .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 3988 | | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 3989 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3990 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3991 | | } }, |
| 3992 | | }, .{ |
| 3993 | | .required_features = .{ .avx, null, null, null }, |
| 3994 | | .src_constraints = .{ |
| 3995 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 3996 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 3997 | | }, |
| 3998 | | .patterns = &.{ |
| 3999 | | .{ .src = .{ .to_sse, .mem } }, |
| 4000 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4001 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4002 | | }, |
| 4003 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4004 | | .each = .{ .once = &.{ |
| 4005 | | .{ ._, .vp_w, .maxu, .dst0x, .src0x, .src1x, ._ }, |
| 4006 | | } }, |
| 4007 | | }, .{ |
| 4008 | | .required_features = .{ .sse4_1, null, null, null }, |
| 4009 | | .src_constraints = .{ |
| 4010 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4011 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4012 | | }, |
| 4013 | | .patterns = &.{ |
| 4014 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4015 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4016 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4017 | | }, |
| 4018 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 4089 | .dst_temps = .{.{ .rc = .x87 }}, |
| 4019 | 4090 | .each = .{ .once = &.{ |
| 4020 | | .{ ._, .p_w, .maxu, .dst0x, .src1x, ._, ._ }, |
| 4091 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4092 | .{ ._, .f_, .subr, .tmp0t, .src1t, ._, ._ }, |
| 4093 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 4021 | 4094 | } }, |
| 4022 | 4095 | }, .{ |
| 4023 | | .required_features = .{ .sse2, null, null, null }, |
| 4096 | .required_features = .{ .x87, null, null, null }, |
| 4024 | 4097 | .src_constraints = .{ |
| 4025 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4026 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4098 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4099 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4100 | .any, |
| 4027 | 4101 | }, |
| 4028 | 4102 | .patterns = &.{ |
| 4029 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4030 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4031 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4103 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 4104 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 4032 | 4105 | }, |
| 4033 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 4034 | | .each = .{ .once = &.{ |
| 4035 | | .{ ._, .p_w, .subus, .dst0x, .src1x, ._, ._ }, |
| 4036 | | .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ }, |
| 4037 | | } }, |
| 4038 | | }, .{ |
| 4039 | | .required_features = .{ .avx2, null, null, null }, |
| 4040 | | .src_constraints = .{ |
| 4041 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 4042 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 4043 | | }, |
| 4044 | | .patterns = &.{ |
| 4045 | | .{ .src = .{ .to_sse, .mem } }, |
| 4046 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4047 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4106 | .extra_temps = .{ |
| 4107 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4108 | .unused, |
| 4109 | .unused, |
| 4110 | .unused, |
| 4111 | .unused, |
| 4112 | .unused, |
| 4113 | .unused, |
| 4114 | .unused, |
| 4115 | .unused, |
| 4048 | 4116 | }, |
| 4049 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4117 | .dst_temps = .{.{ .rc = .x87 }}, |
| 4050 | 4118 | .each = .{ .once = &.{ |
| 4051 | | .{ ._, .vp_w, .maxu, .dst0y, .src0y, .src1y, ._ }, |
| 4119 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4120 | .{ ._, .f_, .sub, .tmp0t, .src1t, ._, ._ }, |
| 4121 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 4052 | 4122 | } }, |
| 4053 | 4123 | }, .{ |
| 4054 | | .required_features = .{ .avx2, null, null, null }, |
| 4124 | .required_features = .{ .x87, null, null, null }, |
| 4055 | 4125 | .src_constraints = .{ |
| 4056 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 4057 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 4126 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4127 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4128 | .any, |
| 4058 | 4129 | }, |
| 4059 | 4130 | .patterns = &.{ |
| 4060 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4131 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4061 | 4132 | }, |
| 4062 | 4133 | .extra_temps = .{ |
| 4063 | 4134 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4064 | | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 4065 | | .unused, |
| 4135 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 4136 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4066 | 4137 | .unused, |
| 4067 | 4138 | .unused, |
| 4068 | 4139 | .unused, |
| ... | ... | @@ -4071,27 +4142,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4071 | 4142 | .unused, |
| 4072 | 4143 | }, |
| 4073 | 4144 | .dst_temps = .{.mem}, |
| 4074 | | .clobbers = .{ .eflags = true }, |
| 4075 | 4145 | .each = .{ .once = &.{ |
| 4076 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4077 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 4078 | | .{ ._, .vp_w, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 4079 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 4080 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 4146 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4147 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4148 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4149 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 4150 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4151 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4081 | 4152 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4082 | 4153 | } }, |
| 4083 | 4154 | }, .{ |
| 4084 | | .required_features = .{ .avx, null, null, null }, |
| 4155 | .required_features = .{ .sse, null, null, null }, |
| 4085 | 4156 | .src_constraints = .{ |
| 4086 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4087 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4157 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4158 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4159 | .any, |
| 4088 | 4160 | }, |
| 4089 | 4161 | .patterns = &.{ |
| 4090 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4162 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 4091 | 4163 | }, |
| 4164 | .call_frame = .{ .alignment = .@"16" }, |
| 4092 | 4165 | .extra_temps = .{ |
| 4093 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4094 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 4166 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4167 | .unused, |
| 4095 | 4168 | .unused, |
| 4096 | 4169 | .unused, |
| 4097 | 4170 | .unused, |
| ... | ... | @@ -4100,30 +4173,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4100 | 4173 | .unused, |
| 4101 | 4174 | .unused, |
| 4102 | 4175 | }, |
| 4103 | | .dst_temps = .{.mem}, |
| 4104 | | .clobbers = .{ .eflags = true }, |
| 4176 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4177 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4105 | 4178 | .each = .{ .once = &.{ |
| 4106 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4107 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4108 | | .{ ._, .vp_w, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4109 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4110 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4111 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4179 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 4112 | 4180 | } }, |
| 4113 | 4181 | }, .{ |
| 4114 | | .required_features = .{ .sse4_1, null, null, null }, |
| 4182 | .required_features = .{ .avx, null, null, null }, |
| 4115 | 4183 | .src_constraints = .{ |
| 4116 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4117 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4184 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4185 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4186 | .any, |
| 4118 | 4187 | }, |
| 4119 | 4188 | .patterns = &.{ |
| 4120 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4189 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4121 | 4190 | }, |
| 4191 | .call_frame = .{ .alignment = .@"16" }, |
| 4122 | 4192 | .extra_temps = .{ |
| 4123 | 4193 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4124 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 4125 | | .unused, |
| 4126 | | .unused, |
| 4194 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4195 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4196 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4127 | 4197 | .unused, |
| 4128 | 4198 | .unused, |
| 4129 | 4199 | .unused, |
| ... | ... | @@ -4131,29 +4201,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4131 | 4201 | .unused, |
| 4132 | 4202 | }, |
| 4133 | 4203 | .dst_temps = .{.mem}, |
| 4134 | | .clobbers = .{ .eflags = true }, |
| 4204 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4135 | 4205 | .each = .{ .once = &.{ |
| 4136 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4137 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4138 | | .{ ._, .p_w, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4139 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4206 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4207 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4208 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4209 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4210 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4140 | 4211 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4141 | 4212 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4142 | 4213 | } }, |
| 4143 | 4214 | }, .{ |
| 4144 | 4215 | .required_features = .{ .sse2, null, null, null }, |
| 4145 | 4216 | .src_constraints = .{ |
| 4146 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4147 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 4217 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4218 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4219 | .any, |
| 4148 | 4220 | }, |
| 4149 | 4221 | .patterns = &.{ |
| 4150 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4222 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4151 | 4223 | }, |
| 4224 | .call_frame = .{ .alignment = .@"16" }, |
| 4152 | 4225 | .extra_temps = .{ |
| 4153 | 4226 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4154 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 4155 | | .unused, |
| 4156 | | .unused, |
| 4227 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4228 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4229 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4157 | 4230 | .unused, |
| 4158 | 4231 | .unused, |
| 4159 | 4232 | .unused, |
| ... | ... | @@ -4161,30 +4234,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4161 | 4234 | .unused, |
| 4162 | 4235 | }, |
| 4163 | 4236 | .dst_temps = .{.mem}, |
| 4164 | | .clobbers = .{ .eflags = true }, |
| 4237 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4165 | 4238 | .each = .{ .once = &.{ |
| 4166 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4167 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4168 | | .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4169 | | .{ ._, .p_w, .add, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4170 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4239 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4240 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4241 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4242 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4243 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4171 | 4244 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4172 | 4245 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4173 | 4246 | } }, |
| 4174 | 4247 | }, .{ |
| 4175 | | .required_features = .{ .cmov, null, null, null }, |
| 4248 | .required_features = .{ .sse, null, null, null }, |
| 4176 | 4249 | .src_constraints = .{ |
| 4177 | | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 4178 | | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 4250 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4251 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4252 | .any, |
| 4179 | 4253 | }, |
| 4180 | 4254 | .patterns = &.{ |
| 4181 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4255 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4182 | 4256 | }, |
| 4257 | .call_frame = .{ .alignment = .@"16" }, |
| 4183 | 4258 | .extra_temps = .{ |
| 4184 | 4259 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4185 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 4186 | | .unused, |
| 4187 | | .unused, |
| 4260 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4261 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4262 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4188 | 4263 | .unused, |
| 4189 | 4264 | .unused, |
| 4190 | 4265 | .unused, |
| ... | ... | @@ -4192,27 +4267,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4192 | 4267 | .unused, |
| 4193 | 4268 | }, |
| 4194 | 4269 | .dst_temps = .{.mem}, |
| 4195 | | .clobbers = .{ .eflags = true }, |
| 4270 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4196 | 4271 | .each = .{ .once = &.{ |
| 4197 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4198 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 4199 | | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4200 | | .{ ._, ._b, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4201 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 4202 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4272 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4273 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4274 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4275 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4276 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4277 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4203 | 4278 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4204 | 4279 | } }, |
| 4205 | | }, .{ |
| 4280 | } }) catch |err| switch (err) { |
| 4281 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 4282 | @tagName(air_tag), |
| 4283 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 4284 | ops[0].tracking(cg), |
| 4285 | ops[1].tracking(cg), |
| 4286 | }), |
| 4287 | else => |e| return e, |
| 4288 | }; |
| 4289 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 4290 | }, |
| 4291 | .mul, .mul_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .mul) else fallback: { |
| 4292 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 4293 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, .mul); |
| 4294 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 4295 | var res: [1]Temp = undefined; |
| 4296 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 4297 | .required_features = .{ .f16c, null, null, null }, |
| 4206 | 4298 | .src_constraints = .{ |
| 4207 | | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 4208 | | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 4299 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4300 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4301 | .any, |
| 4209 | 4302 | }, |
| 4210 | 4303 | .patterns = &.{ |
| 4211 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4304 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4212 | 4305 | }, |
| 4213 | 4306 | .extra_temps = .{ |
| 4214 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4215 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 4307 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4308 | .unused, |
| 4216 | 4309 | .unused, |
| 4217 | 4310 | .unused, |
| 4218 | 4311 | .unused, |
| ... | ... | @@ -4221,94 +4314,87 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4221 | 4314 | .unused, |
| 4222 | 4315 | .unused, |
| 4223 | 4316 | }, |
| 4224 | | .dst_temps = .{.mem}, |
| 4225 | | .clobbers = .{ .eflags = true }, |
| 4317 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4226 | 4318 | .each = .{ .once = &.{ |
| 4227 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4228 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 4229 | | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4230 | | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 4231 | | .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 4232 | | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 4233 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4234 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4319 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 4320 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 4321 | .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0d, ._ }, |
| 4322 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 4235 | 4323 | } }, |
| 4236 | 4324 | }, .{ |
| 4237 | | .required_features = .{ .avx, null, null, null }, |
| 4325 | .required_features = .{ .sse, null, null, null }, |
| 4238 | 4326 | .src_constraints = .{ |
| 4239 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4240 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4327 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4328 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4329 | .any, |
| 4241 | 4330 | }, |
| 4242 | 4331 | .patterns = &.{ |
| 4243 | | .{ .src = .{ .to_sse, .mem } }, |
| 4244 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4245 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4246 | | }, |
| 4247 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4248 | | .each = .{ .once = &.{ |
| 4249 | | .{ ._, .vp_d, .maxs, .dst0x, .src0x, .src1x, ._ }, |
| 4250 | | } }, |
| 4251 | | }, .{ |
| 4252 | | .required_features = .{ .sse4_1, null, null, null }, |
| 4253 | | .src_constraints = .{ |
| 4254 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4255 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4332 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 4256 | 4333 | }, |
| 4257 | | .patterns = &.{ |
| 4258 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4259 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4260 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4334 | .call_frame = .{ .alignment = .@"16" }, |
| 4335 | .extra_temps = .{ |
| 4336 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4337 | .unused, |
| 4338 | .unused, |
| 4339 | .unused, |
| 4340 | .unused, |
| 4341 | .unused, |
| 4342 | .unused, |
| 4343 | .unused, |
| 4344 | .unused, |
| 4261 | 4345 | }, |
| 4262 | 4346 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4347 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4263 | 4348 | .each = .{ .once = &.{ |
| 4264 | | .{ ._, .p_d, .maxs, .dst0x, .src1x, ._, ._ }, |
| 4349 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 4265 | 4350 | } }, |
| 4266 | 4351 | }, .{ |
| 4267 | | .required_features = .{ .sse2, null, null, null }, |
| 4352 | .required_features = .{ .f16c, null, null, null }, |
| 4268 | 4353 | .src_constraints = .{ |
| 4269 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4270 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4354 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 4355 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 4356 | .any, |
| 4271 | 4357 | }, |
| 4272 | 4358 | .patterns = &.{ |
| 4273 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4274 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4275 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4276 | | }, |
| 4277 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4278 | | .each = .{ .once = &.{ |
| 4279 | | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| 4280 | | .{ ._, .p_d, .cmpgt, .dst0x, .src1x, ._, ._ }, |
| 4281 | | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 4282 | | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 4283 | | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 4284 | | } }, |
| 4285 | | }, .{ |
| 4286 | | .required_features = .{ .avx2, null, null, null }, |
| 4287 | | .src_constraints = .{ |
| 4288 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 4289 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 4359 | .{ .src = .{ .mem, .mem, .none } }, |
| 4360 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4361 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 4362 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4290 | 4363 | }, |
| 4291 | | .patterns = &.{ |
| 4292 | | .{ .src = .{ .to_sse, .mem } }, |
| 4293 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4294 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4364 | .extra_temps = .{ |
| 4365 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4366 | .unused, |
| 4367 | .unused, |
| 4368 | .unused, |
| 4369 | .unused, |
| 4370 | .unused, |
| 4371 | .unused, |
| 4372 | .unused, |
| 4373 | .unused, |
| 4295 | 4374 | }, |
| 4296 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4375 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4297 | 4376 | .each = .{ .once = &.{ |
| 4298 | | .{ ._, .vp_d, .maxs, .dst0y, .src0y, .src1y, ._ }, |
| 4377 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 4378 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 4379 | .{ ._, .v_ps, .mul, .dst0x, .dst0x, .tmp0x, ._ }, |
| 4380 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 4299 | 4381 | } }, |
| 4300 | 4382 | }, .{ |
| 4301 | | .required_features = .{ .avx2, null, null, null }, |
| 4383 | .required_features = .{ .f16c, null, null, null }, |
| 4302 | 4384 | .src_constraints = .{ |
| 4303 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 4304 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 4385 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 4386 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 4387 | .any, |
| 4305 | 4388 | }, |
| 4306 | 4389 | .patterns = &.{ |
| 4307 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4390 | .{ .src = .{ .mem, .mem, .none } }, |
| 4391 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4392 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 4393 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4308 | 4394 | }, |
| 4309 | 4395 | .extra_temps = .{ |
| 4310 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4311 | | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 4396 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4397 | .unused, |
| 4312 | 4398 | .unused, |
| 4313 | 4399 | .unused, |
| 4314 | 4400 | .unused, |
| ... | ... | @@ -4317,29 +4403,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4317 | 4403 | .unused, |
| 4318 | 4404 | .unused, |
| 4319 | 4405 | }, |
| 4320 | | .dst_temps = .{.mem}, |
| 4321 | | .clobbers = .{ .eflags = true }, |
| 4406 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4322 | 4407 | .each = .{ .once = &.{ |
| 4323 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4324 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 4325 | | .{ ._, .vp_d, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 4326 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 4327 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 4328 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4408 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 4409 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 4410 | .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp0y, ._ }, |
| 4411 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 4329 | 4412 | } }, |
| 4330 | 4413 | }, .{ |
| 4331 | | .required_features = .{ .avx, null, null, null }, |
| 4414 | .required_features = .{ .f16c, null, null, null }, |
| 4332 | 4415 | .src_constraints = .{ |
| 4333 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4334 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4416 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 4417 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 4418 | .any, |
| 4335 | 4419 | }, |
| 4336 | 4420 | .patterns = &.{ |
| 4337 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4421 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4338 | 4422 | }, |
| 4339 | 4423 | .extra_temps = .{ |
| 4340 | 4424 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4341 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 4342 | | .unused, |
| 4425 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 4426 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 4343 | 4427 | .unused, |
| 4344 | 4428 | .unused, |
| 4345 | 4429 | .unused, |
| ... | ... | @@ -4350,27 +4434,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4350 | 4434 | .dst_temps = .{.mem}, |
| 4351 | 4435 | .clobbers = .{ .eflags = true }, |
| 4352 | 4436 | .each = .{ .once = &.{ |
| 4353 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4354 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4355 | | .{ ._, .vp_d, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4356 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4437 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4438 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4439 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4440 | .{ ._, .v_ps, .mul, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 4441 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 4357 | 4442 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4358 | 4443 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4359 | 4444 | } }, |
| 4360 | 4445 | }, .{ |
| 4361 | | .required_features = .{ .sse4_1, null, null, null }, |
| 4446 | .required_features = .{ .avx, null, null, null }, |
| 4362 | 4447 | .src_constraints = .{ |
| 4363 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4364 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4448 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4449 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4450 | .any, |
| 4365 | 4451 | }, |
| 4366 | 4452 | .patterns = &.{ |
| 4367 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4453 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4368 | 4454 | }, |
| 4455 | .call_frame = .{ .alignment = .@"16" }, |
| 4369 | 4456 | .extra_temps = .{ |
| 4370 | 4457 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4371 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 4372 | | .unused, |
| 4373 | | .unused, |
| 4458 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4459 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4460 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4374 | 4461 | .unused, |
| 4375 | 4462 | .unused, |
| 4376 | 4463 | .unused, |
| ... | ... | @@ -4378,29 +4465,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4378 | 4465 | .unused, |
| 4379 | 4466 | }, |
| 4380 | 4467 | .dst_temps = .{.mem}, |
| 4381 | | .clobbers = .{ .eflags = true }, |
| 4468 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4382 | 4469 | .each = .{ .once = &.{ |
| 4383 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4384 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4385 | | .{ ._, .p_d, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4386 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4387 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4470 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4471 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 4472 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 4473 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 4474 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4475 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 4476 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4388 | 4477 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4389 | 4478 | } }, |
| 4390 | 4479 | }, .{ |
| 4391 | | .required_features = .{ .sse2, null, null, null }, |
| 4480 | .required_features = .{ .sse4_1, null, null, null }, |
| 4392 | 4481 | .src_constraints = .{ |
| 4393 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4394 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 4482 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4483 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4484 | .any, |
| 4395 | 4485 | }, |
| 4396 | 4486 | .patterns = &.{ |
| 4397 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4487 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4398 | 4488 | }, |
| 4489 | .call_frame = .{ .alignment = .@"16" }, |
| 4399 | 4490 | .extra_temps = .{ |
| 4400 | 4491 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4401 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 4402 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 4403 | | .unused, |
| 4492 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4493 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4494 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4404 | 4495 | .unused, |
| 4405 | 4496 | .unused, |
| 4406 | 4497 | .unused, |
| ... | ... | @@ -4408,172 +4499,186 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4408 | 4499 | .unused, |
| 4409 | 4500 | }, |
| 4410 | 4501 | .dst_temps = .{.mem}, |
| 4411 | | .clobbers = .{ .eflags = true }, |
| 4502 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4412 | 4503 | .each = .{ .once = &.{ |
| 4413 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4414 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4415 | | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 4416 | | .{ ._, .p_d, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4417 | | .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ }, |
| 4418 | | .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4419 | | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, |
| 4420 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4421 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4504 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4505 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 4506 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 4507 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4508 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4509 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4510 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 4511 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4422 | 4512 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4423 | 4513 | } }, |
| 4424 | 4514 | }, .{ |
| 4425 | | .required_features = .{ .cmov, null, null, null }, |
| 4515 | .required_features = .{ .sse2, null, null, null }, |
| 4426 | 4516 | .src_constraints = .{ |
| 4427 | | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 4428 | | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 4517 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4518 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4519 | .any, |
| 4429 | 4520 | }, |
| 4430 | 4521 | .patterns = &.{ |
| 4431 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4522 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4432 | 4523 | }, |
| 4524 | .call_frame = .{ .alignment = .@"16" }, |
| 4433 | 4525 | .extra_temps = .{ |
| 4434 | 4526 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4435 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 4436 | | .unused, |
| 4437 | | .unused, |
| 4438 | | .unused, |
| 4527 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4528 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4529 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4530 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 4439 | 4531 | .unused, |
| 4440 | 4532 | .unused, |
| 4441 | 4533 | .unused, |
| 4442 | 4534 | .unused, |
| 4443 | 4535 | }, |
| 4444 | 4536 | .dst_temps = .{.mem}, |
| 4445 | | .clobbers = .{ .eflags = true }, |
| 4537 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4446 | 4538 | .each = .{ .once = &.{ |
| 4447 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4448 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4449 | | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4450 | | .{ ._, ._l, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4451 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 4452 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4539 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4540 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 4541 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 4542 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4543 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4544 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4545 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 4546 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 4547 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4453 | 4548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4454 | 4549 | } }, |
| 4455 | 4550 | }, .{ |
| 4551 | .required_features = .{ .sse, null, null, null }, |
| 4456 | 4552 | .src_constraints = .{ |
| 4457 | | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 4458 | | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 4553 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4554 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4555 | .any, |
| 4459 | 4556 | }, |
| 4460 | 4557 | .patterns = &.{ |
| 4461 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4558 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4462 | 4559 | }, |
| 4560 | .call_frame = .{ .alignment = .@"16" }, |
| 4463 | 4561 | .extra_temps = .{ |
| 4464 | 4562 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4465 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 4466 | | .unused, |
| 4467 | | .unused, |
| 4468 | | .unused, |
| 4469 | | .unused, |
| 4563 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 4564 | .{ .type = .f32, .kind = .mem }, |
| 4565 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4566 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4567 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4470 | 4568 | .unused, |
| 4471 | 4569 | .unused, |
| 4472 | 4570 | .unused, |
| 4473 | 4571 | }, |
| 4474 | 4572 | .dst_temps = .{.mem}, |
| 4475 | | .clobbers = .{ .eflags = true }, |
| 4573 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4476 | 4574 | .each = .{ .once = &.{ |
| 4477 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4478 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4479 | | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4480 | | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 4481 | | .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4482 | | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 4483 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4575 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4576 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4577 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 4578 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 4579 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4580 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 4581 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 4582 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 4583 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 4584 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 4585 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 4586 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4484 | 4587 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4485 | 4588 | } }, |
| 4486 | 4589 | }, .{ |
| 4487 | 4590 | .required_features = .{ .avx, null, null, null }, |
| 4488 | 4591 | .src_constraints = .{ |
| 4489 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4490 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4592 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 4593 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 4594 | .any, |
| 4491 | 4595 | }, |
| 4492 | 4596 | .patterns = &.{ |
| 4493 | | .{ .src = .{ .to_sse, .mem } }, |
| 4494 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4495 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4597 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4598 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4599 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4496 | 4600 | }, |
| 4497 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4601 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4498 | 4602 | .each = .{ .once = &.{ |
| 4499 | | .{ ._, .vp_d, .maxu, .dst0x, .src0x, .src1x, ._ }, |
| 4603 | .{ ._, .v_ss, .mul, .dst0x, .src0x, .src1d, ._ }, |
| 4500 | 4604 | } }, |
| 4501 | 4605 | }, .{ |
| 4502 | | .required_features = .{ .sse4_1, null, null, null }, |
| 4606 | .required_features = .{ .sse, null, null, null }, |
| 4503 | 4607 | .src_constraints = .{ |
| 4504 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4505 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4608 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 4609 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 4610 | .any, |
| 4506 | 4611 | }, |
| 4507 | 4612 | .patterns = &.{ |
| 4508 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4509 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4510 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4613 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 4614 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 4615 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 4511 | 4616 | }, |
| 4512 | 4617 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4513 | 4618 | .each = .{ .once = &.{ |
| 4514 | | .{ ._, .p_d, .maxu, .dst0x, .src1x, ._, ._ }, |
| 4619 | .{ ._, ._ss, .mul, .dst0x, .src1d, ._, ._ }, |
| 4515 | 4620 | } }, |
| 4516 | 4621 | }, .{ |
| 4517 | | .required_features = .{ .sse2, null, null, null }, |
| 4622 | .required_features = .{ .avx, null, null, null }, |
| 4518 | 4623 | .src_constraints = .{ |
| 4519 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4520 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4624 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4625 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4626 | .any, |
| 4521 | 4627 | }, |
| 4522 | 4628 | .patterns = &.{ |
| 4523 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4524 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4525 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4629 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4630 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4631 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4526 | 4632 | }, |
| 4527 | | .extra_temps = .{ |
| 4528 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4529 | | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 4530 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4531 | | .unused, |
| 4532 | | .unused, |
| 4533 | | .unused, |
| 4534 | | .unused, |
| 4535 | | .unused, |
| 4536 | | .unused, |
| 4633 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4634 | .each = .{ .once = &.{ |
| 4635 | .{ ._, .v_ps, .mul, .dst0x, .src0x, .src1x, ._ }, |
| 4636 | } }, |
| 4637 | }, .{ |
| 4638 | .required_features = .{ .sse, null, null, null }, |
| 4639 | .src_constraints = .{ |
| 4640 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4641 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4642 | .any, |
| 4537 | 4643 | }, |
| 4538 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4644 | .patterns = &.{ |
| 4645 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 4646 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 4647 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 4648 | }, |
| 4649 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4539 | 4650 | .each = .{ .once = &.{ |
| 4540 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 4541 | | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 4542 | | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| 4543 | | .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ }, |
| 4544 | | .{ ._, .p_, .xor, .tmp2x, .src1x, ._, ._ }, |
| 4545 | | .{ ._, .p_d, .cmpgt, .dst0x, .tmp2x, ._, ._ }, |
| 4546 | | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 4547 | | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 4548 | | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 4651 | .{ ._, ._ps, .mul, .dst0x, .src1x, ._, ._ }, |
| 4549 | 4652 | } }, |
| 4550 | 4653 | }, .{ |
| 4551 | | .required_features = .{ .avx2, null, null, null }, |
| 4654 | .required_features = .{ .avx, null, null, null }, |
| 4552 | 4655 | .src_constraints = .{ |
| 4553 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 4554 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 4656 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 4657 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 4658 | .any, |
| 4555 | 4659 | }, |
| 4556 | 4660 | .patterns = &.{ |
| 4557 | | .{ .src = .{ .to_sse, .mem } }, |
| 4558 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4559 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4661 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4662 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4663 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4560 | 4664 | }, |
| 4561 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4665 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4562 | 4666 | .each = .{ .once = &.{ |
| 4563 | | .{ ._, .vp_d, .maxu, .dst0y, .src0y, .src1y, ._ }, |
| 4667 | .{ ._, .v_ps, .mul, .dst0y, .src0y, .src1y, ._ }, |
| 4564 | 4668 | } }, |
| 4565 | 4669 | }, .{ |
| 4566 | | .required_features = .{ .avx2, null, null, null }, |
| 4670 | .required_features = .{ .avx, null, null, null }, |
| 4567 | 4671 | .src_constraints = .{ |
| 4568 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 4569 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 4672 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 4673 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 4674 | .any, |
| 4570 | 4675 | }, |
| 4571 | 4676 | .patterns = &.{ |
| 4572 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4677 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4573 | 4678 | }, |
| 4574 | 4679 | .extra_temps = .{ |
| 4575 | 4680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4576 | | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 4681 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 4577 | 4682 | .unused, |
| 4578 | 4683 | .unused, |
| 4579 | 4684 | .unused, |
| ... | ... | @@ -4585,25 +4690,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4585 | 4690 | .dst_temps = .{.mem}, |
| 4586 | 4691 | .clobbers = .{ .eflags = true }, |
| 4587 | 4692 | .each = .{ .once = &.{ |
| 4588 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4589 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 4590 | | .{ ._, .vp_d, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 4591 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 4693 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4694 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4695 | .{ ._, .v_ps, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 4696 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 4592 | 4697 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 4593 | 4698 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4594 | 4699 | } }, |
| 4595 | 4700 | }, .{ |
| 4596 | | .required_features = .{ .avx, null, null, null }, |
| 4701 | .required_features = .{ .sse, null, null, null }, |
| 4597 | 4702 | .src_constraints = .{ |
| 4598 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4599 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4703 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4704 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4705 | .any, |
| 4600 | 4706 | }, |
| 4601 | 4707 | .patterns = &.{ |
| 4602 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4708 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4603 | 4709 | }, |
| 4604 | 4710 | .extra_temps = .{ |
| 4605 | 4711 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4606 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4712 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 4607 | 4713 | .unused, |
| 4608 | 4714 | .unused, |
| 4609 | 4715 | .unused, |
| ... | ... | @@ -4615,25 +4721,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4615 | 4721 | .dst_temps = .{.mem}, |
| 4616 | 4722 | .clobbers = .{ .eflags = true }, |
| 4617 | 4723 | .each = .{ .once = &.{ |
| 4618 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4619 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4620 | | .{ ._, .vp_d, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 4621 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4724 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4725 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4726 | .{ ._, ._ps, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4727 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4622 | 4728 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4623 | 4729 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4624 | 4730 | } }, |
| 4625 | 4731 | }, .{ |
| 4626 | | .required_features = .{ .sse4_1, null, null, null }, |
| 4732 | .required_features = .{ .avx, null, null, null }, |
| 4627 | 4733 | .src_constraints = .{ |
| 4628 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4629 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4734 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4735 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4736 | .any, |
| 4737 | }, |
| 4738 | .patterns = &.{ |
| 4739 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4740 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4741 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4742 | }, |
| 4743 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4744 | .each = .{ .once = &.{ |
| 4745 | .{ ._, .v_sd, .mul, .dst0x, .src0x, .src1q, ._ }, |
| 4746 | } }, |
| 4747 | }, .{ |
| 4748 | .required_features = .{ .sse2, null, null, null }, |
| 4749 | .src_constraints = .{ |
| 4750 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4751 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4752 | .any, |
| 4753 | }, |
| 4754 | .patterns = &.{ |
| 4755 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 4756 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 4757 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 4758 | }, |
| 4759 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4760 | .each = .{ .once = &.{ |
| 4761 | .{ ._, ._sd, .mul, .dst0x, .src1q, ._, ._ }, |
| 4762 | } }, |
| 4763 | }, .{ |
| 4764 | .required_features = .{ .x87, null, null, null }, |
| 4765 | .src_constraints = .{ |
| 4766 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4767 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4768 | .any, |
| 4630 | 4769 | }, |
| 4631 | 4770 | .patterns = &.{ |
| 4632 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4771 | .{ .src = .{ .mem, .mem, .none } }, |
| 4633 | 4772 | }, |
| 4634 | 4773 | .extra_temps = .{ |
| 4635 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4636 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4774 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 4775 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 4637 | 4776 | .unused, |
| 4638 | 4777 | .unused, |
| 4639 | 4778 | .unused, |
| ... | ... | @@ -4643,67 +4782,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4643 | 4782 | .unused, |
| 4644 | 4783 | }, |
| 4645 | 4784 | .dst_temps = .{.mem}, |
| 4646 | | .clobbers = .{ .eflags = true }, |
| 4647 | 4785 | .each = .{ .once = &.{ |
| 4648 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4649 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4650 | | .{ ._, .p_d, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4651 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4652 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4653 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4786 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 4787 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 4788 | .{ ._, .f_p, .mul, ._, ._, ._, ._ }, |
| 4789 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 4790 | } }, |
| 4791 | }, .{ |
| 4792 | .required_features = .{ .avx, null, null, null }, |
| 4793 | .src_constraints = .{ |
| 4794 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4795 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4796 | .any, |
| 4797 | }, |
| 4798 | .patterns = &.{ |
| 4799 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4800 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4801 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4802 | }, |
| 4803 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4804 | .each = .{ .once = &.{ |
| 4805 | .{ ._, .v_pd, .mul, .dst0x, .src0x, .src1x, ._ }, |
| 4654 | 4806 | } }, |
| 4655 | 4807 | }, .{ |
| 4656 | 4808 | .required_features = .{ .sse2, null, null, null }, |
| 4657 | 4809 | .src_constraints = .{ |
| 4658 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4659 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 4810 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4811 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4812 | .any, |
| 4660 | 4813 | }, |
| 4661 | 4814 | .patterns = &.{ |
| 4662 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4815 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 4816 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 4817 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 4663 | 4818 | }, |
| 4664 | | .extra_temps = .{ |
| 4665 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4666 | | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 4667 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4668 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4669 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4670 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4671 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 4672 | | .unused, |
| 4673 | | .unused, |
| 4819 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4820 | .each = .{ .once = &.{ |
| 4821 | .{ ._, ._pd, .mul, .dst0x, .src1x, ._, ._ }, |
| 4822 | } }, |
| 4823 | }, .{ |
| 4824 | .required_features = .{ .avx, null, null, null }, |
| 4825 | .src_constraints = .{ |
| 4826 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4827 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4828 | .any, |
| 4674 | 4829 | }, |
| 4675 | | .dst_temps = .{.mem}, |
| 4676 | | .clobbers = .{ .eflags = true }, |
| 4830 | .patterns = &.{ |
| 4831 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4832 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4833 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4834 | }, |
| 4835 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4677 | 4836 | .each = .{ .once = &.{ |
| 4678 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 4679 | | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 4680 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4681 | | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4682 | | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4683 | | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| 4684 | | .{ ._, ._dqa, .mov, .tmp6x, .tmp4x, ._, ._ }, |
| 4685 | | .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ }, |
| 4686 | | .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ }, |
| 4687 | | .{ ._, .p_d, .cmpgt, .tmp5x, .tmp6x, ._, ._ }, |
| 4688 | | .{ ._, .p_, .@"and", .tmp3x, .tmp5x, ._, ._ }, |
| 4689 | | .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ }, |
| 4690 | | .{ ._, .p_, .@"or", .tmp3x, .tmp5x, ._, ._ }, |
| 4691 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 4692 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4693 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4837 | .{ ._, .v_pd, .mul, .dst0y, .src0y, .src1y, ._ }, |
| 4694 | 4838 | } }, |
| 4695 | 4839 | }, .{ |
| 4696 | | .required_features = .{ .cmov, null, null, null }, |
| 4840 | .required_features = .{ .avx, null, null, null }, |
| 4697 | 4841 | .src_constraints = .{ |
| 4698 | | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 4699 | | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 4842 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4843 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4844 | .any, |
| 4700 | 4845 | }, |
| 4701 | 4846 | .patterns = &.{ |
| 4702 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4847 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4703 | 4848 | }, |
| 4704 | 4849 | .extra_temps = .{ |
| 4705 | 4850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4706 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4851 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 4707 | 4852 | .unused, |
| 4708 | 4853 | .unused, |
| 4709 | 4854 | .unused, |
| ... | ... | @@ -4715,25 +4860,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4715 | 4860 | .dst_temps = .{.mem}, |
| 4716 | 4861 | .clobbers = .{ .eflags = true }, |
| 4717 | 4862 | .each = .{ .once = &.{ |
| 4718 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4719 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4720 | | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4721 | | .{ ._, ._b, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4722 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 4723 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4863 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4864 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4865 | .{ ._, .v_pd, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 4866 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 4867 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 4724 | 4868 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4725 | 4869 | } }, |
| 4726 | 4870 | }, .{ |
| 4871 | .required_features = .{ .sse2, null, null, null }, |
| 4727 | 4872 | .src_constraints = .{ |
| 4728 | | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 4729 | | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 4873 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4874 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4875 | .any, |
| 4730 | 4876 | }, |
| 4731 | 4877 | .patterns = &.{ |
| 4732 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4878 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4733 | 4879 | }, |
| 4734 | 4880 | .extra_temps = .{ |
| 4735 | 4881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4736 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 4882 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 4737 | 4883 | .unused, |
| 4738 | 4884 | .unused, |
| 4739 | 4885 | .unused, |
| ... | ... | @@ -4745,43 +4891,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4745 | 4891 | .dst_temps = .{.mem}, |
| 4746 | 4892 | .clobbers = .{ .eflags = true }, |
| 4747 | 4893 | .each = .{ .once = &.{ |
| 4748 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4749 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 4750 | | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4751 | | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 4752 | | .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 4753 | | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 4754 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 4894 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4895 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4896 | .{ ._, ._pd, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4897 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4898 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4755 | 4899 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4756 | 4900 | } }, |
| 4757 | 4901 | }, .{ |
| 4758 | | .required_features = .{ .avx, null, null, null }, |
| 4902 | .required_features = .{ .x87, null, null, null }, |
| 4759 | 4903 | .src_constraints = .{ |
| 4760 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 4761 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 4904 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4905 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4906 | .any, |
| 4762 | 4907 | }, |
| 4763 | 4908 | .patterns = &.{ |
| 4764 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4909 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4765 | 4910 | }, |
| 4766 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4911 | .extra_temps = .{ |
| 4912 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4913 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 4914 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 4915 | .unused, |
| 4916 | .unused, |
| 4917 | .unused, |
| 4918 | .unused, |
| 4919 | .unused, |
| 4920 | .unused, |
| 4921 | }, |
| 4922 | .dst_temps = .{.mem}, |
| 4767 | 4923 | .each = .{ .once = &.{ |
| 4768 | | .{ ._, .vp_q, .cmpgt, .dst0x, .src1x, .src0x, ._ }, |
| 4769 | | .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x }, |
| 4924 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4925 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4926 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4927 | .{ ._, .f_p, .mul, ._, ._, ._, ._ }, |
| 4928 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4929 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 4930 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4770 | 4931 | } }, |
| 4771 | 4932 | }, .{ |
| 4772 | | .required_features = .{ .sse4_2, null, null, null }, |
| 4933 | .required_features = .{ .x87, null, null, null }, |
| 4773 | 4934 | .src_constraints = .{ |
| 4774 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 4775 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 4935 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4936 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4937 | .any, |
| 4776 | 4938 | }, |
| 4777 | 4939 | .patterns = &.{ |
| 4778 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 4779 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 4780 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 4940 | .{ .src = .{ .mem, .mem, .none } }, |
| 4781 | 4941 | }, |
| 4782 | 4942 | .extra_temps = .{ |
| 4783 | | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| 4784 | | .unused, |
| 4943 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 4944 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4785 | 4945 | .unused, |
| 4786 | 4946 | .unused, |
| 4787 | 4947 | .unused, |
| ... | ... | @@ -4790,40 +4950,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4790 | 4950 | .unused, |
| 4791 | 4951 | .unused, |
| 4792 | 4952 | }, |
| 4793 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 4953 | .dst_temps = .{.{ .rc = .x87 }}, |
| 4794 | 4954 | .each = .{ .once = &.{ |
| 4795 | | .{ ._, ._dqa, .mov, .tmp0x, .src1x, ._, ._ }, |
| 4796 | | .{ ._, .p_q, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 4797 | | .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp0x, ._ }, |
| 4955 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4956 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 4957 | .{ ._, .f_p, .mul, ._, ._, ._, ._ }, |
| 4958 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 4798 | 4959 | } }, |
| 4799 | 4960 | }, .{ |
| 4800 | | .required_features = .{ .avx2, null, null, null }, |
| 4961 | .required_features = .{ .x87, null, null, null }, |
| 4801 | 4962 | .src_constraints = .{ |
| 4802 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 4803 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 4963 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4964 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4965 | .any, |
| 4804 | 4966 | }, |
| 4805 | 4967 | .patterns = &.{ |
| 4806 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 4968 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 4969 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 4970 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 4807 | 4971 | }, |
| 4808 | | .dst_temps = .{.{ .rc = .sse }}, |
| 4972 | .extra_temps = .{ |
| 4973 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4974 | .unused, |
| 4975 | .unused, |
| 4976 | .unused, |
| 4977 | .unused, |
| 4978 | .unused, |
| 4979 | .unused, |
| 4980 | .unused, |
| 4981 | .unused, |
| 4982 | }, |
| 4983 | .dst_temps = .{.{ .rc = .x87 }}, |
| 4809 | 4984 | .each = .{ .once = &.{ |
| 4810 | | .{ ._, .vp_q, .cmpgt, .dst0y, .src1y, .src0y, ._ }, |
| 4811 | | .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y }, |
| 4985 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4986 | .{ ._, .f_, .mul, .tmp0t, .src1t, ._, ._ }, |
| 4987 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 4812 | 4988 | } }, |
| 4813 | 4989 | }, .{ |
| 4814 | | .required_features = .{ .avx2, null, null, null }, |
| 4990 | .required_features = .{ .x87, null, null, null }, |
| 4815 | 4991 | .src_constraints = .{ |
| 4816 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 4817 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 4992 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4993 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4994 | .any, |
| 4818 | 4995 | }, |
| 4819 | 4996 | .patterns = &.{ |
| 4820 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 4997 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4821 | 4998 | }, |
| 4822 | 4999 | .extra_temps = .{ |
| 4823 | 5000 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4824 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 4825 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 4826 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 5001 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 5002 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5003 | .unused, |
| 4827 | 5004 | .unused, |
| 4828 | 5005 | .unused, |
| 4829 | 5006 | .unused, |
| ... | ... | @@ -4831,63 +5008,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4831 | 5008 | .unused, |
| 4832 | 5009 | }, |
| 4833 | 5010 | .dst_temps = .{.mem}, |
| 4834 | | .clobbers = .{ .eflags = true }, |
| 4835 | 5011 | .each = .{ .once = &.{ |
| 4836 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4837 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 4838 | | .{ ._, .v_dqa, .mov, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 4839 | | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .tmp1y, ._ }, |
| 4840 | | .{ ._, .vp_b, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 4841 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 4842 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5012 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5013 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5014 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5015 | .{ ._, .f_p, .mul, ._, ._, ._, ._ }, |
| 5016 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5017 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4843 | 5018 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4844 | 5019 | } }, |
| 4845 | 5020 | }, .{ |
| 4846 | | .required_features = .{ .avx, null, null, null }, |
| 5021 | .required_features = .{ .sse, null, null, null }, |
| 4847 | 5022 | .src_constraints = .{ |
| 4848 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 4849 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 5023 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5024 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5025 | .any, |
| 4850 | 5026 | }, |
| 4851 | 5027 | .patterns = &.{ |
| 4852 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5028 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 4853 | 5029 | }, |
| 5030 | .call_frame = .{ .alignment = .@"16" }, |
| 4854 | 5031 | .extra_temps = .{ |
| 4855 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4856 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 4857 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 4858 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 5032 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 5033 | .unused, |
| 5034 | .unused, |
| 5035 | .unused, |
| 4859 | 5036 | .unused, |
| 4860 | 5037 | .unused, |
| 4861 | 5038 | .unused, |
| 4862 | 5039 | .unused, |
| 4863 | 5040 | .unused, |
| 4864 | 5041 | }, |
| 4865 | | .dst_temps = .{.mem}, |
| 4866 | | .clobbers = .{ .eflags = true }, |
| 5042 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5043 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4867 | 5044 | .each = .{ .once = &.{ |
| 4868 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4869 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4870 | | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4871 | | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 4872 | | .{ ._, .vp_b, .blendv, .tmp1x, .tmp1x, .tmp2x, .tmp3x }, |
| 4873 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 4874 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4875 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5045 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 4876 | 5046 | } }, |
| 4877 | 5047 | }, .{ |
| 4878 | | .required_features = .{ .sse4_2, null, null, null }, |
| 5048 | .required_features = .{ .avx, null, null, null }, |
| 4879 | 5049 | .src_constraints = .{ |
| 4880 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 4881 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 5050 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5051 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5052 | .any, |
| 4882 | 5053 | }, |
| 4883 | 5054 | .patterns = &.{ |
| 4884 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5055 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4885 | 5056 | }, |
| 5057 | .call_frame = .{ .alignment = .@"16" }, |
| 4886 | 5058 | .extra_temps = .{ |
| 4887 | 5059 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4888 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 4889 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 4890 | | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| 5060 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5061 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5062 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4891 | 5063 | .unused, |
| 4892 | 5064 | .unused, |
| 4893 | 5065 | .unused, |
| ... | ... | @@ -4895,32 +5067,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4895 | 5067 | .unused, |
| 4896 | 5068 | }, |
| 4897 | 5069 | .dst_temps = .{.mem}, |
| 4898 | | .clobbers = .{ .eflags = true }, |
| 5070 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4899 | 5071 | .each = .{ .once = &.{ |
| 4900 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4901 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 4902 | | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 4903 | | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 4904 | | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp1x, ._, ._ }, |
| 4905 | | .{ ._, .p_b, .blendv, .tmp1x, .tmp2x, .tmp3x, ._ }, |
| 4906 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 5072 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5073 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5074 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5075 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5076 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4907 | 5077 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4908 | 5078 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4909 | 5079 | } }, |
| 4910 | 5080 | }, .{ |
| 4911 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5081 | .required_features = .{ .sse2, null, null, null }, |
| 4912 | 5082 | .src_constraints = .{ |
| 4913 | | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 4914 | | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 5083 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5084 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5085 | .any, |
| 4915 | 5086 | }, |
| 4916 | 5087 | .patterns = &.{ |
| 4917 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5088 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4918 | 5089 | }, |
| 5090 | .call_frame = .{ .alignment = .@"16" }, |
| 4919 | 5091 | .extra_temps = .{ |
| 4920 | 5092 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4921 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 4922 | | .unused, |
| 4923 | | .unused, |
| 5093 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5094 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5095 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4924 | 5096 | .unused, |
| 4925 | 5097 | .unused, |
| 4926 | 5098 | .unused, |
| ... | ... | @@ -4928,30 +5100,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4928 | 5100 | .unused, |
| 4929 | 5101 | }, |
| 4930 | 5102 | .dst_temps = .{.mem}, |
| 4931 | | .clobbers = .{ .eflags = true }, |
| 5103 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4932 | 5104 | .each = .{ .once = &.{ |
| 4933 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4934 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4935 | | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4936 | | .{ ._, ._l, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4937 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 4938 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5105 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5106 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5107 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5108 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5109 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5110 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4939 | 5111 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4940 | 5112 | } }, |
| 4941 | 5113 | }, .{ |
| 4942 | | .required_features = .{ .@"64bit", null, null, null }, |
| 5114 | .required_features = .{ .sse, null, null, null }, |
| 4943 | 5115 | .src_constraints = .{ |
| 4944 | | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 4945 | | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 5116 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5117 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5118 | .any, |
| 4946 | 5119 | }, |
| 4947 | 5120 | .patterns = &.{ |
| 4948 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5121 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4949 | 5122 | }, |
| 5123 | .call_frame = .{ .alignment = .@"16" }, |
| 4950 | 5124 | .extra_temps = .{ |
| 4951 | 5125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4952 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 4953 | | .unused, |
| 4954 | | .unused, |
| 5126 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5127 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5128 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4955 | 5129 | .unused, |
| 4956 | 5130 | .unused, |
| 4957 | 5131 | .unused, |
| ... | ... | @@ -4959,32 +5133,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4959 | 5133 | .unused, |
| 4960 | 5134 | }, |
| 4961 | 5135 | .dst_temps = .{.mem}, |
| 4962 | | .clobbers = .{ .eflags = true }, |
| 5136 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4963 | 5137 | .each = .{ .once = &.{ |
| 4964 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 4965 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 4966 | | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4967 | | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 4968 | | .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 4969 | | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 4970 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5139 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5140 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5141 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5142 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5143 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4971 | 5144 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4972 | 5145 | } }, |
| 4973 | | }, .{ |
| 4974 | | .required_features = .{ .avx, null, null, null }, |
| 5146 | } }) catch |err| switch (err) { |
| 5147 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 5148 | @tagName(air_tag), |
| 5149 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 5150 | ops[0].tracking(cg), |
| 5151 | ops[1].tracking(cg), |
| 5152 | }), |
| 5153 | else => |e| return e, |
| 5154 | }; |
| 5155 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 5156 | }, |
| 5157 | .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) { |
| 5158 | else => unreachable, |
| 5159 | .div_float, .div_float_optimized => .div_float, |
| 5160 | .div_exact, .div_exact_optimized => .div_exact, |
| 5161 | }) else fallback: { |
| 5162 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 5163 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, .div_exact); |
| 5164 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 5165 | var res: [1]Temp = undefined; |
| 5166 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 5167 | .required_features = .{ .f16c, null, null, null }, |
| 4975 | 5168 | .src_constraints = .{ |
| 4976 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 4977 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5169 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5170 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5171 | .any, |
| 4978 | 5172 | }, |
| 4979 | 5173 | .patterns = &.{ |
| 4980 | | .{ .src = .{ .to_sse, .mem } }, |
| 4981 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 4982 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5174 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4983 | 5175 | }, |
| 4984 | 5176 | .extra_temps = .{ |
| 4985 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 4986 | | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 4987 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5177 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5178 | .unused, |
| 5179 | .unused, |
| 4988 | 5180 | .unused, |
| 4989 | 5181 | .unused, |
| 4990 | 5182 | .unused, |
| ... | ... | @@ -4992,31 +5184,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4992 | 5184 | .unused, |
| 4993 | 5185 | .unused, |
| 4994 | 5186 | }, |
| 4995 | | .dst_temps = .{.{ .rc = .sse }}, |
| 5187 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4996 | 5188 | .each = .{ .once = &.{ |
| 4997 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 4998 | | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 4999 | | .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ }, |
| 5000 | | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .src1x, ._ }, |
| 5001 | | .{ ._, .vp_q, .cmpgt, .dst0x, .tmp2x, .dst0x, ._ }, |
| 5002 | | .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x }, |
| 5189 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5190 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5191 | .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ }, |
| 5192 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5003 | 5193 | } }, |
| 5004 | 5194 | }, .{ |
| 5005 | | .required_features = .{ .sse4_2, null, null, null }, |
| 5195 | .required_features = .{ .sse, null, null, null }, |
| 5006 | 5196 | .src_constraints = .{ |
| 5007 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5008 | | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5197 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5198 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5199 | .any, |
| 5009 | 5200 | }, |
| 5010 | 5201 | .patterns = &.{ |
| 5011 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 5012 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 5013 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 5202 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 5014 | 5203 | }, |
| 5204 | .call_frame = .{ .alignment = .@"16" }, |
| 5015 | 5205 | .extra_temps = .{ |
| 5016 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 5017 | | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5018 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5019 | | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 5206 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5207 | .unused, |
| 5208 | .unused, |
| 5209 | .unused, |
| 5020 | 5210 | .unused, |
| 5021 | 5211 | .unused, |
| 5022 | 5212 | .unused, |
| ... | ... | @@ -5024,30 +5214,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5024 | 5214 | .unused, |
| 5025 | 5215 | }, |
| 5026 | 5216 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5217 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5027 | 5218 | .each = .{ .once = &.{ |
| 5028 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5029 | | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 5030 | | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 5031 | | .{ ._, .p_, .xor, .tmp2x, .src0x, ._, ._ }, |
| 5032 | | .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ }, |
| 5033 | | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| 5034 | | .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp3x, ._ }, |
| 5219 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5035 | 5220 | } }, |
| 5036 | 5221 | }, .{ |
| 5037 | | .required_features = .{ .avx2, null, null, null }, |
| 5222 | .required_features = .{ .f16c, null, null, null }, |
| 5038 | 5223 | .src_constraints = .{ |
| 5039 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 5040 | | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 5224 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5225 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5226 | .any, |
| 5041 | 5227 | }, |
| 5042 | 5228 | .patterns = &.{ |
| 5043 | | .{ .src = .{ .to_sse, .mem } }, |
| 5044 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 5045 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5229 | .{ .src = .{ .mem, .mem, .none } }, |
| 5230 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5231 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 5232 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5046 | 5233 | }, |
| 5047 | 5234 | .extra_temps = .{ |
| 5048 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 5049 | | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5050 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5235 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5236 | .unused, |
| 5237 | .unused, |
| 5051 | 5238 | .unused, |
| 5052 | 5239 | .unused, |
| 5053 | 5240 | .unused, |
| ... | ... | @@ -5055,139 +5242,126 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5055 | 5242 | .unused, |
| 5056 | 5243 | .unused, |
| 5057 | 5244 | }, |
| 5058 | | .dst_temps = .{.{ .rc = .sse }}, |
| 5245 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5059 | 5246 | .each = .{ .once = &.{ |
| 5060 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5061 | | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| 5062 | | .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ }, |
| 5063 | | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .src1y, ._ }, |
| 5064 | | .{ ._, .vp_q, .cmpgt, .dst0y, .tmp2y, .dst0y, ._ }, |
| 5065 | | .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y }, |
| 5247 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5248 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5249 | .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ }, |
| 5250 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5066 | 5251 | } }, |
| 5067 | 5252 | }, .{ |
| 5068 | | .required_features = .{ .avx2, null, null, null }, |
| 5253 | .required_features = .{ .f16c, null, null, null }, |
| 5069 | 5254 | .src_constraints = .{ |
| 5070 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 5071 | | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 5255 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5256 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5257 | .any, |
| 5072 | 5258 | }, |
| 5073 | 5259 | .patterns = &.{ |
| 5074 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5260 | .{ .src = .{ .mem, .mem, .none } }, |
| 5261 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5262 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 5263 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5075 | 5264 | }, |
| 5076 | 5265 | .extra_temps = .{ |
| 5077 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5078 | | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5079 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5080 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5081 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5082 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5083 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5266 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5267 | .unused, |
| 5268 | .unused, |
| 5269 | .unused, |
| 5270 | .unused, |
| 5271 | .unused, |
| 5272 | .unused, |
| 5084 | 5273 | .unused, |
| 5085 | 5274 | .unused, |
| 5086 | 5275 | }, |
| 5087 | | .dst_temps = .{.mem}, |
| 5088 | | .clobbers = .{ .eflags = true }, |
| 5276 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5089 | 5277 | .each = .{ .once = &.{ |
| 5090 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5091 | | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| 5092 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5093 | | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 5094 | | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 5095 | | .{ ._, .vp_, .xor, .tmp5y, .tmp3y, .tmp2y, ._ }, |
| 5096 | | .{ ._, .vp_, .xor, .tmp6y, .tmp4y, .tmp2y, ._ }, |
| 5097 | | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp6y, .tmp5y, ._ }, |
| 5098 | | .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp4y, .tmp5y }, |
| 5099 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 5100 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5101 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5278 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 5279 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 5280 | .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ }, |
| 5281 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 5102 | 5282 | } }, |
| 5103 | 5283 | }, .{ |
| 5104 | | .required_features = .{ .avx, null, null, null }, |
| 5284 | .required_features = .{ .f16c, null, null, null }, |
| 5105 | 5285 | .src_constraints = .{ |
| 5106 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5107 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5286 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5287 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5288 | .any, |
| 5108 | 5289 | }, |
| 5109 | 5290 | .patterns = &.{ |
| 5110 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5291 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5111 | 5292 | }, |
| 5112 | 5293 | .extra_temps = .{ |
| 5113 | 5294 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5114 | | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5115 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5116 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5117 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5118 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5119 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5295 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5296 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5297 | .unused, |
| 5298 | .unused, |
| 5299 | .unused, |
| 5300 | .unused, |
| 5120 | 5301 | .unused, |
| 5121 | 5302 | .unused, |
| 5122 | 5303 | }, |
| 5123 | 5304 | .dst_temps = .{.mem}, |
| 5124 | 5305 | .clobbers = .{ .eflags = true }, |
| 5125 | 5306 | .each = .{ .once = &.{ |
| 5126 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5127 | | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 5128 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5129 | | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5130 | | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5131 | | .{ ._, .vp_, .xor, .tmp5x, .tmp3x, .tmp2x, ._ }, |
| 5132 | | .{ ._, .vp_, .xor, .tmp6x, .tmp4x, .tmp2x, ._ }, |
| 5133 | | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp6x, .tmp5x, ._ }, |
| 5134 | | .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp4x, .tmp5x }, |
| 5135 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 5307 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5308 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5309 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5310 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 5311 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 5136 | 5312 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5137 | 5313 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5138 | 5314 | } }, |
| 5139 | 5315 | }, .{ |
| 5140 | | .required_features = .{ .sse4_2, null, null, null }, |
| 5316 | .required_features = .{ .avx, null, null, null }, |
| 5141 | 5317 | .src_constraints = .{ |
| 5142 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5143 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5318 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5319 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5320 | .any, |
| 5144 | 5321 | }, |
| 5145 | 5322 | .patterns = &.{ |
| 5146 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5323 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5147 | 5324 | }, |
| 5325 | .call_frame = .{ .alignment = .@"16" }, |
| 5148 | 5326 | .extra_temps = .{ |
| 5149 | 5327 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5150 | | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5151 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5152 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5153 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5154 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5155 | | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 5328 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5329 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5330 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5331 | .unused, |
| 5332 | .unused, |
| 5333 | .unused, |
| 5156 | 5334 | .unused, |
| 5157 | 5335 | .unused, |
| 5158 | 5336 | }, |
| 5159 | 5337 | .dst_temps = .{.mem}, |
| 5160 | | .clobbers = .{ .eflags = true }, |
| 5338 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5161 | 5339 | .each = .{ .once = &.{ |
| 5162 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5163 | | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 5164 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5165 | | .{ .@"0:", ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ }, |
| 5166 | | .{ ._, ._dqa, .mov, .tmp6x, .tmp2x, ._, ._ }, |
| 5167 | | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5168 | | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5169 | | .{ ._, .p_, .xor, .tmp5x, .tmp3x, ._, ._ }, |
| 5170 | | .{ ._, .p_, .xor, .tmp6x, .tmp4x, ._, ._ }, |
| 5171 | | .{ ._, .p_q, .cmpgt, .tmp6x, .tmp5x, ._, ._ }, |
| 5172 | | .{ ._, .p_b, .blendv, .tmp3x, .tmp4x, .tmp6x, ._ }, |
| 5173 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 5174 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5340 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5341 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 5342 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 5343 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 5344 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5345 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 5346 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5175 | 5347 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5176 | 5348 | } }, |
| 5177 | 5349 | }, .{ |
| 5178 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5350 | .required_features = .{ .sse4_1, null, null, null }, |
| 5179 | 5351 | .src_constraints = .{ |
| 5180 | | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 5181 | | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 5352 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5353 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5354 | .any, |
| 5182 | 5355 | }, |
| 5183 | 5356 | .patterns = &.{ |
| 5184 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5357 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5185 | 5358 | }, |
| 5359 | .call_frame = .{ .alignment = .@"16" }, |
| 5186 | 5360 | .extra_temps = .{ |
| 5187 | 5361 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5188 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5189 | | .unused, |
| 5190 | | .unused, |
| 5362 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5363 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5364 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5191 | 5365 | .unused, |
| 5192 | 5366 | .unused, |
| 5193 | 5367 | .unused, |
| ... | ... | @@ -5195,212 +5369,181 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5195 | 5369 | .unused, |
| 5196 | 5370 | }, |
| 5197 | 5371 | .dst_temps = .{.mem}, |
| 5198 | | .clobbers = .{ .eflags = true }, |
| 5372 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5199 | 5373 | .each = .{ .once = &.{ |
| 5200 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5201 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5202 | | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5203 | | .{ ._, ._b, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5204 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 5205 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5374 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5375 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5376 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5377 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5378 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5379 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5380 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 5381 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5206 | 5382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5207 | 5383 | } }, |
| 5208 | 5384 | }, .{ |
| 5209 | | .required_features = .{ .@"64bit", null, null, null }, |
| 5385 | .required_features = .{ .sse2, null, null, null }, |
| 5210 | 5386 | .src_constraints = .{ |
| 5211 | | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 5212 | | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 5387 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5388 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5389 | .any, |
| 5213 | 5390 | }, |
| 5214 | 5391 | .patterns = &.{ |
| 5215 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5392 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5216 | 5393 | }, |
| 5394 | .call_frame = .{ .alignment = .@"16" }, |
| 5217 | 5395 | .extra_temps = .{ |
| 5218 | 5396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5219 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5220 | | .unused, |
| 5221 | | .unused, |
| 5222 | | .unused, |
| 5397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5398 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5399 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5400 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5223 | 5401 | .unused, |
| 5224 | 5402 | .unused, |
| 5225 | 5403 | .unused, |
| 5226 | 5404 | .unused, |
| 5227 | 5405 | }, |
| 5228 | 5406 | .dst_temps = .{.mem}, |
| 5229 | | .clobbers = .{ .eflags = true }, |
| 5407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5230 | 5408 | .each = .{ .once = &.{ |
| 5231 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5232 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5233 | | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5234 | | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 5235 | | .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5236 | | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 5237 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5409 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5410 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5411 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5412 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5413 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5414 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5415 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 5416 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 5417 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5238 | 5418 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5239 | 5419 | } }, |
| 5240 | 5420 | }, .{ |
| 5241 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5242 | | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int }, |
| 5421 | .required_features = .{ .sse, null, null, null }, |
| 5422 | .src_constraints = .{ |
| 5423 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5424 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5425 | .any, |
| 5426 | }, |
| 5243 | 5427 | .patterns = &.{ |
| 5244 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5428 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5245 | 5429 | }, |
| 5430 | .call_frame = .{ .alignment = .@"16" }, |
| 5246 | 5431 | .extra_temps = .{ |
| 5247 | 5432 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5248 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 5249 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 5250 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5251 | | .unused, |
| 5252 | | .unused, |
| 5433 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5434 | .{ .type = .f32, .kind = .mem }, |
| 5435 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5436 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5437 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5253 | 5438 | .unused, |
| 5254 | 5439 | .unused, |
| 5255 | 5440 | .unused, |
| 5256 | 5441 | }, |
| 5257 | 5442 | .dst_temps = .{.mem}, |
| 5258 | | .clobbers = .{ .eflags = true }, |
| 5443 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5259 | 5444 | .each = .{ .once = &.{ |
| 5260 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5261 | | .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5262 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5263 | | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5264 | | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5265 | | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 5266 | | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 5267 | | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 5268 | | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5269 | | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5270 | | .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 5271 | | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 5272 | | .{ ._, ._l, .cmov, .tmp1p, .tmp2p, ._, ._ }, |
| 5273 | | .{ ._, ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 5274 | | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5275 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 5276 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5445 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5446 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5447 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5448 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 5449 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5450 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5451 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 5452 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 5453 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 5454 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 5455 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 5456 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5277 | 5457 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5278 | 5458 | } }, |
| 5279 | 5459 | }, .{ |
| 5280 | | .required_features = .{ .@"64bit", null, null, null }, |
| 5281 | | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int }, |
| 5282 | | .patterns = &.{ |
| 5283 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5460 | .required_features = .{ .avx, null, null, null }, |
| 5461 | .src_constraints = .{ |
| 5462 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5463 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5464 | .any, |
| 5284 | 5465 | }, |
| 5285 | | .extra_temps = .{ |
| 5286 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5287 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 5288 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 5289 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5290 | | .unused, |
| 5291 | | .unused, |
| 5292 | | .unused, |
| 5293 | | .unused, |
| 5294 | | .unused, |
| 5466 | .patterns = &.{ |
| 5467 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5468 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5295 | 5469 | }, |
| 5296 | | .dst_temps = .{.mem}, |
| 5297 | | .clobbers = .{ .eflags = true }, |
| 5470 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5298 | 5471 | .each = .{ .once = &.{ |
| 5299 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5300 | | .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5301 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5302 | | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5303 | | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5304 | | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 5305 | | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 5306 | | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 5307 | | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5308 | | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5309 | | .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 5310 | | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 5311 | | .{ ._, ._, .lea, .tmp1p, .memiad(.src1, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 5312 | | .{ .@"1:", ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 5313 | | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5314 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 5315 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5316 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5472 | .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ }, |
| 5317 | 5473 | } }, |
| 5318 | 5474 | }, .{ |
| 5319 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5320 | | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int }, |
| 5475 | .required_features = .{ .sse, null, null, null }, |
| 5476 | .src_constraints = .{ |
| 5477 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5478 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5479 | .any, |
| 5480 | }, |
| 5321 | 5481 | .patterns = &.{ |
| 5322 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5482 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 5483 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 5323 | 5484 | }, |
| 5324 | | .extra_temps = .{ |
| 5325 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5326 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 5327 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 5328 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5329 | | .unused, |
| 5330 | | .unused, |
| 5331 | | .unused, |
| 5332 | | .unused, |
| 5333 | | .unused, |
| 5485 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5486 | .each = .{ .once = &.{ |
| 5487 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 5488 | } }, |
| 5489 | }, .{ |
| 5490 | .required_features = .{ .avx, null, null, null }, |
| 5491 | .src_constraints = .{ |
| 5492 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5493 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5494 | .any, |
| 5334 | 5495 | }, |
| 5335 | | .dst_temps = .{.mem}, |
| 5336 | | .clobbers = .{ .eflags = true }, |
| 5496 | .patterns = &.{ |
| 5497 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5498 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5499 | }, |
| 5500 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5337 | 5501 | .each = .{ .once = &.{ |
| 5338 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5339 | | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5340 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5341 | | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5342 | | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5343 | | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 5344 | | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 5345 | | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 5346 | | .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 5347 | | .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 5348 | | .{ ._, ._b, .cmov, .tmp1p, .tmp2p, ._, ._ }, |
| 5349 | | .{ ._, ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 5350 | | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5351 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 5352 | | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, |
| 5353 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 5502 | .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ }, |
| 5354 | 5503 | } }, |
| 5355 | 5504 | }, .{ |
| 5356 | | .required_features = .{ .@"64bit", null, null, null }, |
| 5357 | | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int }, |
| 5505 | .required_features = .{ .sse, null, null, null }, |
| 5506 | .src_constraints = .{ |
| 5507 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5508 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5509 | .any, |
| 5510 | }, |
| 5358 | 5511 | .patterns = &.{ |
| 5359 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5512 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 5513 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 5360 | 5514 | }, |
| 5361 | | .extra_temps = .{ |
| 5362 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5363 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 5364 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 5365 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5366 | | .unused, |
| 5367 | | .unused, |
| 5368 | | .unused, |
| 5369 | | .unused, |
| 5370 | | .unused, |
| 5515 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5516 | .each = .{ .once = &.{ |
| 5517 | .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ }, |
| 5518 | } }, |
| 5519 | }, .{ |
| 5520 | .required_features = .{ .avx, null, null, null }, |
| 5521 | .src_constraints = .{ |
| 5522 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5523 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5524 | .any, |
| 5371 | 5525 | }, |
| 5372 | | .dst_temps = .{.mem}, |
| 5373 | | .clobbers = .{ .eflags = true }, |
| 5526 | .patterns = &.{ |
| 5527 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5528 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5529 | }, |
| 5530 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5374 | 5531 | .each = .{ .once = &.{ |
| 5375 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5376 | | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5377 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5378 | | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 5379 | | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 5380 | | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 5381 | | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 5382 | | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 5383 | | .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 5384 | | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 5385 | | .{ ._, ._, .lea, .tmp1p, .memia(.src1, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 5386 | | .{ .@"1:", ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 5387 | | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 5388 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 5389 | | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, |
| 5390 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 5532 | .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ }, |
| 5391 | 5533 | } }, |
| 5392 | 5534 | }, .{ |
| 5393 | | .required_features = .{ .f16c, null, null, null }, |
| 5535 | .required_features = .{ .avx, null, null, null }, |
| 5394 | 5536 | .src_constraints = .{ |
| 5395 | | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5396 | | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5537 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5538 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5539 | .any, |
| 5397 | 5540 | }, |
| 5398 | 5541 | .patterns = &.{ |
| 5399 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5542 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5400 | 5543 | }, |
| 5401 | 5544 | .extra_temps = .{ |
| 5402 | | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5403 | | .{ .type = .f16, .kind = .{ .rc = .sse } }, |
| 5545 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5546 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5404 | 5547 | .unused, |
| 5405 | 5548 | .unused, |
| 5406 | 5549 | .unused, |
| ... | ... | @@ -5409,28 +5552,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5409 | 5552 | .unused, |
| 5410 | 5553 | .unused, |
| 5411 | 5554 | }, |
| 5412 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5555 | .dst_temps = .{.mem}, |
| 5556 | .clobbers = .{ .eflags = true }, |
| 5413 | 5557 | .each = .{ .once = &.{ |
| 5414 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5415 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5416 | | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 5417 | | .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| 5418 | | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 5419 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5558 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5559 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5560 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 5561 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 5562 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5563 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5420 | 5564 | } }, |
| 5421 | 5565 | }, .{ |
| 5422 | 5566 | .required_features = .{ .sse, null, null, null }, |
| 5423 | 5567 | .src_constraints = .{ |
| 5424 | | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5425 | | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5568 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5569 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5570 | .any, |
| 5426 | 5571 | }, |
| 5427 | 5572 | .patterns = &.{ |
| 5428 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 5573 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5429 | 5574 | }, |
| 5430 | | .call_frame = .{ .alignment = .@"16" }, |
| 5431 | 5575 | .extra_temps = .{ |
| 5432 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5433 | | .unused, |
| 5576 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5577 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5434 | 5578 | .unused, |
| 5435 | 5579 | .unused, |
| 5436 | 5580 | .unused, |
| ... | ... | @@ -5439,58 +5583,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5439 | 5583 | .unused, |
| 5440 | 5584 | .unused, |
| 5441 | 5585 | }, |
| 5442 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 5443 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5586 | .dst_temps = .{.mem}, |
| 5587 | .clobbers = .{ .eflags = true }, |
| 5444 | 5588 | .each = .{ .once = &.{ |
| 5445 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5589 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5590 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5591 | .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5592 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5593 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5594 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5446 | 5595 | } }, |
| 5447 | 5596 | }, .{ |
| 5448 | | .required_features = .{ .f16c, null, null, null }, |
| 5597 | .required_features = .{ .avx, null, null, null }, |
| 5449 | 5598 | .src_constraints = .{ |
| 5450 | | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5451 | | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5599 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5600 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5601 | .any, |
| 5452 | 5602 | }, |
| 5453 | 5603 | .patterns = &.{ |
| 5454 | | .{ .src = .{ .mem, .mem } }, |
| 5455 | | .{ .src = .{ .to_sse, .mem } }, |
| 5456 | | .{ .src = .{ .mem, .to_sse } }, |
| 5457 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5458 | | }, |
| 5459 | | .extra_temps = .{ |
| 5460 | | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5461 | | .{ .type = .vector_4_f16, .kind = .{ .rc = .sse } }, |
| 5462 | | .unused, |
| 5463 | | .unused, |
| 5464 | | .unused, |
| 5465 | | .unused, |
| 5466 | | .unused, |
| 5467 | | .unused, |
| 5468 | | .unused, |
| 5604 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5605 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5469 | 5606 | }, |
| 5470 | 5607 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5471 | 5608 | .each = .{ .once = &.{ |
| 5472 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5473 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5474 | | .{ ._, .v_ps, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 5475 | | .{ ._, .v_ps, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| 5476 | | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 5477 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5609 | .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ }, |
| 5478 | 5610 | } }, |
| 5479 | 5611 | }, .{ |
| 5480 | | .required_features = .{ .f16c, null, null, null }, |
| 5612 | .required_features = .{ .sse2, null, null, null }, |
| 5481 | 5613 | .src_constraints = .{ |
| 5482 | | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5483 | | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5614 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5615 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5616 | .any, |
| 5617 | }, |
| 5618 | .patterns = &.{ |
| 5619 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 5620 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 5621 | }, |
| 5622 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5623 | .each = .{ .once = &.{ |
| 5624 | .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ }, |
| 5625 | } }, |
| 5626 | }, .{ |
| 5627 | .required_features = .{ .x87, null, null, null }, |
| 5628 | .src_constraints = .{ |
| 5629 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5630 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5631 | .any, |
| 5484 | 5632 | }, |
| 5485 | 5633 | .patterns = &.{ |
| 5486 | | .{ .src = .{ .mem, .mem } }, |
| 5487 | | .{ .src = .{ .to_sse, .mem } }, |
| 5488 | | .{ .src = .{ .mem, .to_sse } }, |
| 5489 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5634 | .{ .src = .{ .mem, .mem, .none } }, |
| 5490 | 5635 | }, |
| 5491 | 5636 | .extra_temps = .{ |
| 5492 | | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5493 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5637 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 5638 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 5494 | 5639 | .unused, |
| 5495 | 5640 | .unused, |
| 5496 | 5641 | .unused, |
| ... | ... | @@ -5499,96 +5644,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5499 | 5644 | .unused, |
| 5500 | 5645 | .unused, |
| 5501 | 5646 | }, |
| 5502 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5647 | .dst_temps = .{.mem}, |
| 5503 | 5648 | .each = .{ .once = &.{ |
| 5504 | | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 5505 | | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 5506 | | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, |
| 5507 | | .{ ._, .v_ps, .max, .dst0y, .tmp0y, .dst0y, ._ }, |
| 5508 | | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, |
| 5509 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0y, .rm(.{}), ._ }, |
| 5649 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 5650 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 5651 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5652 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 5510 | 5653 | } }, |
| 5511 | 5654 | }, .{ |
| 5512 | | .required_features = .{ .f16c, null, null, null }, |
| 5655 | .required_features = .{ .avx, null, null, null }, |
| 5513 | 5656 | .src_constraints = .{ |
| 5514 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5515 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5657 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5658 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5659 | .any, |
| 5516 | 5660 | }, |
| 5517 | 5661 | .patterns = &.{ |
| 5518 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5662 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5663 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5519 | 5664 | }, |
| 5520 | | .extra_temps = .{ |
| 5521 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5522 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5523 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5524 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 5525 | | .unused, |
| 5526 | | .unused, |
| 5527 | | .unused, |
| 5528 | | .unused, |
| 5529 | | .unused, |
| 5665 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5666 | .each = .{ .once = &.{ |
| 5667 | .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ }, |
| 5668 | } }, |
| 5669 | }, .{ |
| 5670 | .required_features = .{ .sse2, null, null, null }, |
| 5671 | .src_constraints = .{ |
| 5672 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5673 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5674 | .any, |
| 5530 | 5675 | }, |
| 5531 | | .dst_temps = .{.mem}, |
| 5532 | | .clobbers = .{ .eflags = true }, |
| 5676 | .patterns = &.{ |
| 5677 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 5678 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 5679 | }, |
| 5680 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5533 | 5681 | .each = .{ .once = &.{ |
| 5534 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5535 | | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5536 | | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5537 | | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 5538 | | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 5539 | | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 5540 | | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_size), .tmp1y, .rm(.{}), ._ }, |
| 5541 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5542 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5682 | .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ }, |
| 5543 | 5683 | } }, |
| 5544 | 5684 | }, .{ |
| 5545 | 5685 | .required_features = .{ .avx, null, null, null }, |
| 5546 | 5686 | .src_constraints = .{ |
| 5547 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5548 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5687 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 5688 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 5689 | .any, |
| 5549 | 5690 | }, |
| 5550 | 5691 | .patterns = &.{ |
| 5551 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5552 | | }, |
| 5553 | | .call_frame = .{ .alignment = .@"16" }, |
| 5554 | | .extra_temps = .{ |
| 5555 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5556 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5557 | | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5558 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5559 | | .unused, |
| 5560 | | .unused, |
| 5561 | | .unused, |
| 5562 | | .unused, |
| 5563 | | .unused, |
| 5692 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5693 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5564 | 5694 | }, |
| 5565 | | .dst_temps = .{.mem}, |
| 5566 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5695 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5567 | 5696 | .each = .{ .once = &.{ |
| 5568 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5569 | | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 5570 | | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_size), .ui(0) }, |
| 5571 | | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0) }, |
| 5572 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5573 | | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 5574 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5575 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5697 | .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ }, |
| 5576 | 5698 | } }, |
| 5577 | 5699 | }, .{ |
| 5578 | | .required_features = .{ .sse4_1, null, null, null }, |
| 5700 | .required_features = .{ .avx, null, null, null }, |
| 5579 | 5701 | .src_constraints = .{ |
| 5580 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5581 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5702 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 5703 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 5704 | .any, |
| 5582 | 5705 | }, |
| 5583 | 5706 | .patterns = &.{ |
| 5584 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5707 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5585 | 5708 | }, |
| 5586 | | .call_frame = .{ .alignment = .@"16" }, |
| 5587 | 5709 | .extra_temps = .{ |
| 5588 | 5710 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5589 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5590 | | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5591 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5711 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 5712 | .unused, |
| 5713 | .unused, |
| 5592 | 5714 | .unused, |
| 5593 | 5715 | .unused, |
| 5594 | 5716 | .unused, |
| ... | ... | @@ -5596,103 +5718,90 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5596 | 5718 | .unused, |
| 5597 | 5719 | }, |
| 5598 | 5720 | .dst_temps = .{.mem}, |
| 5599 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5721 | .clobbers = .{ .eflags = true }, |
| 5600 | 5722 | .each = .{ .once = &.{ |
| 5601 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5602 | | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5603 | | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5604 | | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 5605 | | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 5606 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5607 | | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 5608 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5723 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5724 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5725 | .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 5726 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 5727 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5609 | 5728 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5610 | 5729 | } }, |
| 5611 | 5730 | }, .{ |
| 5612 | 5731 | .required_features = .{ .sse2, null, null, null }, |
| 5613 | 5732 | .src_constraints = .{ |
| 5614 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5615 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5733 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5734 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5735 | .any, |
| 5616 | 5736 | }, |
| 5617 | 5737 | .patterns = &.{ |
| 5618 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5738 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5619 | 5739 | }, |
| 5620 | | .call_frame = .{ .alignment = .@"16" }, |
| 5621 | 5740 | .extra_temps = .{ |
| 5622 | 5741 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5623 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5624 | | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5625 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5626 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5742 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 5743 | .unused, |
| 5744 | .unused, |
| 5745 | .unused, |
| 5627 | 5746 | .unused, |
| 5628 | 5747 | .unused, |
| 5629 | 5748 | .unused, |
| 5630 | 5749 | .unused, |
| 5631 | 5750 | }, |
| 5632 | 5751 | .dst_temps = .{.mem}, |
| 5633 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5752 | .clobbers = .{ .eflags = true }, |
| 5634 | 5753 | .each = .{ .once = &.{ |
| 5635 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5636 | | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5637 | | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5638 | | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 5639 | | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 5640 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5641 | | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 5642 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ }, |
| 5643 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5754 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5755 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5756 | .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5757 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5758 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5644 | 5759 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5645 | 5760 | } }, |
| 5646 | 5761 | }, .{ |
| 5647 | | .required_features = .{ .sse, null, null, null }, |
| 5762 | .required_features = .{ .x87, null, null, null }, |
| 5648 | 5763 | .src_constraints = .{ |
| 5649 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5650 | | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5764 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5765 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5766 | .any, |
| 5651 | 5767 | }, |
| 5652 | 5768 | .patterns = &.{ |
| 5653 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5769 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5654 | 5770 | }, |
| 5655 | | .call_frame = .{ .alignment = .@"16" }, |
| 5656 | 5771 | .extra_temps = .{ |
| 5657 | 5772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5658 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5659 | | .{ .type = .f32, .kind = .mem }, |
| 5660 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5661 | | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5662 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 5773 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 5774 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 5775 | .unused, |
| 5776 | .unused, |
| 5777 | .unused, |
| 5663 | 5778 | .unused, |
| 5664 | 5779 | .unused, |
| 5665 | 5780 | .unused, |
| 5666 | 5781 | }, |
| 5667 | 5782 | .dst_temps = .{.mem}, |
| 5668 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5669 | 5783 | .each = .{ .once = &.{ |
| 5670 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5671 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 5672 | | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5673 | | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 5674 | | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 5675 | | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5676 | | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 5677 | | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 5678 | | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 5679 | | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 5680 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 5681 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5784 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5785 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5786 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5787 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5788 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5789 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 5682 | 5790 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5683 | 5791 | } }, |
| 5684 | 5792 | }, .{ |
| 5685 | | .required_features = .{ .avx, null, null, null }, |
| 5793 | .required_features = .{ .x87, null, null, null }, |
| 5686 | 5794 | .src_constraints = .{ |
| 5687 | | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5688 | | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5795 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5796 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5797 | .any, |
| 5689 | 5798 | }, |
| 5690 | 5799 | .patterns = &.{ |
| 5691 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5800 | .{ .src = .{ .mem, .mem, .none } }, |
| 5692 | 5801 | }, |
| 5693 | 5802 | .extra_temps = .{ |
| 5694 | | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 5695 | | .unused, |
| 5803 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 5804 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5696 | 5805 | .unused, |
| 5697 | 5806 | .unused, |
| 5698 | 5807 | .unused, |
| ... | ... | @@ -5701,39 +5810,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5701 | 5810 | .unused, |
| 5702 | 5811 | .unused, |
| 5703 | 5812 | }, |
| 5704 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5705 | | .each = .{ .once = &.{ |
| 5706 | | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 5707 | | .{ ._, .v_ss, .max, .dst0x, .src1x, .src0x, ._ }, |
| 5708 | | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 5709 | | } }, |
| 5710 | | }, .{ |
| 5711 | | .required_features = .{ .sse4_1, null, null, null }, |
| 5712 | | .src_constraints = .{ |
| 5713 | | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5714 | | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5715 | | }, |
| 5716 | | .patterns = &.{ |
| 5717 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 5718 | | }, |
| 5719 | | .dst_temps = .{.{ .rc = .sse }}, |
| 5813 | .dst_temps = .{.{ .rc = .x87 }}, |
| 5720 | 5814 | .each = .{ .once = &.{ |
| 5721 | | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 5722 | | .{ ._, ._ss, .max, .dst0x, .src0x, ._, ._ }, |
| 5723 | | .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 5724 | | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 5815 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 5816 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 5817 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5818 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5725 | 5819 | } }, |
| 5726 | 5820 | }, .{ |
| 5727 | | .required_features = .{ .sse, null, null, null }, |
| 5821 | .required_features = .{ .x87, null, null, null }, |
| 5728 | 5822 | .src_constraints = .{ |
| 5729 | | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5730 | | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5823 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5824 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5825 | .any, |
| 5731 | 5826 | }, |
| 5732 | 5827 | .patterns = &.{ |
| 5733 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 5828 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 5734 | 5829 | }, |
| 5735 | 5830 | .extra_temps = .{ |
| 5736 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5831 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5737 | 5832 | .unused, |
| 5738 | 5833 | .unused, |
| 5739 | 5834 | .unused, |
| ... | ... | @@ -5743,26 +5838,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5743 | 5838 | .unused, |
| 5744 | 5839 | .unused, |
| 5745 | 5840 | }, |
| 5746 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 5841 | .dst_temps = .{.{ .rc = .x87 }}, |
| 5747 | 5842 | .each = .{ .once = &.{ |
| 5748 | | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 5749 | | .{ ._, ._ss, .max, .tmp0x, .src0x, ._, ._ }, |
| 5750 | | .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 5751 | | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 5752 | | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 5753 | | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 5843 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 5844 | .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ }, |
| 5845 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5754 | 5846 | } }, |
| 5755 | 5847 | }, .{ |
| 5756 | | .required_features = .{ .avx, null, null, null }, |
| 5848 | .required_features = .{ .x87, null, null, null }, |
| 5757 | 5849 | .src_constraints = .{ |
| 5758 | | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5759 | | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5850 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5851 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5852 | .any, |
| 5760 | 5853 | }, |
| 5761 | 5854 | .patterns = &.{ |
| 5762 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5855 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 5856 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 5763 | 5857 | }, |
| 5764 | 5858 | .extra_temps = .{ |
| 5765 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5859 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5766 | 5860 | .unused, |
| 5767 | 5861 | .unused, |
| 5768 | 5862 | .unused, |
| ... | ... | @@ -5772,45 +5866,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5772 | 5866 | .unused, |
| 5773 | 5867 | .unused, |
| 5774 | 5868 | }, |
| 5775 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5776 | | .each = .{ .once = &.{ |
| 5777 | | .{ ._, .v_ps, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 5778 | | .{ ._, .v_ps, .max, .dst0x, .src1x, .src0x, ._ }, |
| 5779 | | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 5780 | | } }, |
| 5781 | | }, .{ |
| 5782 | | .required_features = .{ .sse4_1, null, null, null }, |
| 5783 | | .src_constraints = .{ |
| 5784 | | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5785 | | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5786 | | }, |
| 5787 | | .patterns = &.{ |
| 5788 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 5789 | | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 5790 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 5791 | | }, |
| 5792 | | .dst_temps = .{.{ .rc = .sse }}, |
| 5869 | .dst_temps = .{.{ .rc = .x87 }}, |
| 5793 | 5870 | .each = .{ .once = &.{ |
| 5794 | | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 5795 | | .{ ._, ._ps, .max, .dst0x, .src0x, ._, ._ }, |
| 5796 | | .{ ._, ._ps, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 5797 | | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 5871 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 5872 | .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ }, |
| 5873 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5798 | 5874 | } }, |
| 5799 | 5875 | }, .{ |
| 5800 | | .required_features = .{ .sse, null, null, null }, |
| 5876 | .required_features = .{ .x87, null, null, null }, |
| 5801 | 5877 | .src_constraints = .{ |
| 5802 | | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5803 | | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5878 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5879 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5880 | .any, |
| 5804 | 5881 | }, |
| 5805 | 5882 | .patterns = &.{ |
| 5806 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 5807 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 5808 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 5883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5809 | 5884 | }, |
| 5810 | 5885 | .extra_temps = .{ |
| 5811 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5812 | | .unused, |
| 5813 | | .unused, |
| 5886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5887 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 5888 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5814 | 5889 | .unused, |
| 5815 | 5890 | .unused, |
| 5816 | 5891 | .unused, |
| ... | ... | @@ -5818,26 +5893,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5818 | 5893 | .unused, |
| 5819 | 5894 | .unused, |
| 5820 | 5895 | }, |
| 5821 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 5896 | .dst_temps = .{.mem}, |
| 5822 | 5897 | .each = .{ .once = &.{ |
| 5823 | | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 5824 | | .{ ._, ._ps, .max, .tmp0x, .src0x, ._, ._ }, |
| 5825 | | .{ ._, ._ps, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 5826 | | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 5827 | | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 5828 | | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 5898 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5899 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5900 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5901 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5902 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5903 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5904 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5829 | 5905 | } }, |
| 5830 | 5906 | }, .{ |
| 5831 | | .required_features = .{ .avx, null, null, null }, |
| 5907 | .required_features = .{ .sse, null, null, null }, |
| 5832 | 5908 | .src_constraints = .{ |
| 5833 | | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5834 | | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5909 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5910 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5911 | .any, |
| 5835 | 5912 | }, |
| 5836 | 5913 | .patterns = &.{ |
| 5837 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5914 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 5838 | 5915 | }, |
| 5916 | .call_frame = .{ .alignment = .@"16" }, |
| 5839 | 5917 | .extra_temps = .{ |
| 5840 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5918 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5841 | 5919 | .unused, |
| 5842 | 5920 | .unused, |
| 5843 | 5921 | .unused, |
| ... | ... | @@ -5847,26 +5925,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5847 | 5925 | .unused, |
| 5848 | 5926 | .unused, |
| 5849 | 5927 | }, |
| 5850 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5928 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5929 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5851 | 5930 | .each = .{ .once = &.{ |
| 5852 | | .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 5853 | | .{ ._, .v_ps, .max, .dst0y, .src1y, .src0y, ._ }, |
| 5854 | | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 5931 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5855 | 5932 | } }, |
| 5856 | 5933 | }, .{ |
| 5857 | 5934 | .required_features = .{ .avx, null, null, null }, |
| 5858 | 5935 | .src_constraints = .{ |
| 5859 | | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5860 | | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5936 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5937 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5938 | .any, |
| 5861 | 5939 | }, |
| 5862 | 5940 | .patterns = &.{ |
| 5863 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5941 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5864 | 5942 | }, |
| 5943 | .call_frame = .{ .alignment = .@"16" }, |
| 5865 | 5944 | .extra_temps = .{ |
| 5866 | 5945 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5867 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5868 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5869 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5946 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5947 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5948 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5870 | 5949 | .unused, |
| 5871 | 5950 | .unused, |
| 5872 | 5951 | .unused, |
| ... | ... | @@ -5874,32 +5953,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5874 | 5953 | .unused, |
| 5875 | 5954 | }, |
| 5876 | 5955 | .dst_temps = .{.mem}, |
| 5877 | | .clobbers = .{ .eflags = true }, |
| 5956 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5878 | 5957 | .each = .{ .once = &.{ |
| 5879 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5880 | | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 5881 | | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 5882 | | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 5883 | | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 5884 | | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 5885 | | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 5886 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5958 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5959 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5960 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5961 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5962 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5963 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5887 | 5964 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5888 | 5965 | } }, |
| 5889 | 5966 | }, .{ |
| 5890 | | .required_features = .{ .sse4_1, null, null, null }, |
| 5967 | .required_features = .{ .sse2, null, null, null }, |
| 5891 | 5968 | .src_constraints = .{ |
| 5892 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5893 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5969 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5970 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5971 | .any, |
| 5894 | 5972 | }, |
| 5895 | 5973 | .patterns = &.{ |
| 5896 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 5974 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5897 | 5975 | }, |
| 5976 | .call_frame = .{ .alignment = .@"16" }, |
| 5898 | 5977 | .extra_temps = .{ |
| 5899 | 5978 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5900 | | .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } }, |
| 5901 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5902 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5979 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5980 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5981 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5903 | 5982 | .unused, |
| 5904 | 5983 | .unused, |
| 5905 | 5984 | .unused, |
| ... | ... | @@ -5907,33 +5986,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5907 | 5986 | .unused, |
| 5908 | 5987 | }, |
| 5909 | 5988 | .dst_temps = .{.mem}, |
| 5910 | | .clobbers = .{ .eflags = true }, |
| 5989 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5911 | 5990 | .each = .{ .once = &.{ |
| 5912 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5913 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5914 | | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5915 | | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 5916 | | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 5917 | | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 5918 | | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 5919 | | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 5991 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5992 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5993 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5994 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5995 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5920 | 5996 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5921 | 5997 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5922 | 5998 | } }, |
| 5923 | 5999 | }, .{ |
| 5924 | 6000 | .required_features = .{ .sse, null, null, null }, |
| 5925 | 6001 | .src_constraints = .{ |
| 5926 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5927 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6002 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6003 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6004 | .any, |
| 5928 | 6005 | }, |
| 5929 | 6006 | .patterns = &.{ |
| 5930 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6007 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5931 | 6008 | }, |
| 6009 | .call_frame = .{ .alignment = .@"16" }, |
| 5932 | 6010 | .extra_temps = .{ |
| 5933 | 6011 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5934 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5935 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5936 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 6012 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6013 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6014 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5937 | 6015 | .unused, |
| 5938 | 6016 | .unused, |
| 5939 | 6017 | .unused, |
| ... | ... | @@ -5941,712 +6019,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5941 | 6019 | .unused, |
| 5942 | 6020 | }, |
| 5943 | 6021 | .dst_temps = .{.mem}, |
| 5944 | | .clobbers = .{ .eflags = true }, |
| 6022 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5945 | 6023 | .each = .{ .once = &.{ |
| 5946 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 5947 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 5948 | | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 5949 | | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 5950 | | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 5951 | | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 5952 | | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 5953 | | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 5954 | | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 5955 | | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 5956 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5957 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5958 | | } }, |
| 5959 | | }, .{ |
| 5960 | | .required_features = .{ .avx, null, null, null }, |
| 5961 | | .src_constraints = .{ |
| 5962 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5963 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5964 | | }, |
| 5965 | | .patterns = &.{ |
| 5966 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 5967 | | }, |
| 5968 | | .extra_temps = .{ |
| 5969 | | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 5970 | | .unused, |
| 5971 | | .unused, |
| 5972 | | .unused, |
| 5973 | | .unused, |
| 5974 | | .unused, |
| 5975 | | .unused, |
| 5976 | | .unused, |
| 5977 | | .unused, |
| 5978 | | }, |
| 5979 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5980 | | .each = .{ .once = &.{ |
| 5981 | | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 5982 | | .{ ._, .v_sd, .max, .dst0x, .src1x, .src0x, ._ }, |
| 5983 | | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 5984 | | } }, |
| 5985 | | }, .{ |
| 5986 | | .required_features = .{ .sse4_1, null, null, null }, |
| 5987 | | .src_constraints = .{ |
| 5988 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5989 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5990 | | }, |
| 5991 | | .patterns = &.{ |
| 5992 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 5993 | | }, |
| 5994 | | .dst_temps = .{.{ .rc = .sse }}, |
| 5995 | | .each = .{ .once = &.{ |
| 5996 | | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 5997 | | .{ ._, ._sd, .max, .dst0x, .src0x, ._, ._ }, |
| 5998 | | .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 5999 | | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 6000 | | } }, |
| 6001 | | }, .{ |
| 6002 | | .required_features = .{ .sse2, null, null, null }, |
| 6003 | | .src_constraints = .{ |
| 6004 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6005 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6006 | | }, |
| 6007 | | .patterns = &.{ |
| 6008 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 6009 | | }, |
| 6010 | | .extra_temps = .{ |
| 6011 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6012 | | .unused, |
| 6013 | | .unused, |
| 6014 | | .unused, |
| 6015 | | .unused, |
| 6016 | | .unused, |
| 6017 | | .unused, |
| 6018 | | .unused, |
| 6019 | | .unused, |
| 6020 | | }, |
| 6021 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6022 | | .each = .{ .once = &.{ |
| 6023 | | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 6024 | | .{ ._, ._sd, .max, .tmp0x, .src0x, ._, ._ }, |
| 6025 | | .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 6026 | | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 6027 | | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 6028 | | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 6029 | | } }, |
| 6030 | | }, .{ |
| 6031 | | .required_features = .{ .sse, null, null, null }, |
| 6032 | | .src_constraints = .{ |
| 6033 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6034 | | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6035 | | }, |
| 6036 | | .patterns = &.{ |
| 6037 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 6038 | | }, |
| 6039 | | .call_frame = .{ .alignment = .@"16" }, |
| 6040 | | .extra_temps = .{ |
| 6041 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, |
| 6042 | | .unused, |
| 6043 | | .unused, |
| 6044 | | .unused, |
| 6045 | | .unused, |
| 6046 | | .unused, |
| 6047 | | .unused, |
| 6048 | | .unused, |
| 6049 | | .unused, |
| 6050 | | }, |
| 6051 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6052 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6053 | | .each = .{ .once = &.{ |
| 6054 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6055 | | } }, |
| 6056 | | }, .{ |
| 6057 | | .required_features = .{ .avx, null, null, null }, |
| 6058 | | .src_constraints = .{ |
| 6059 | | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6060 | | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6061 | | }, |
| 6062 | | .patterns = &.{ |
| 6063 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 6064 | | }, |
| 6065 | | .extra_temps = .{ |
| 6066 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6067 | | .unused, |
| 6068 | | .unused, |
| 6069 | | .unused, |
| 6070 | | .unused, |
| 6071 | | .unused, |
| 6072 | | .unused, |
| 6073 | | .unused, |
| 6074 | | .unused, |
| 6075 | | }, |
| 6076 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6077 | | .each = .{ .once = &.{ |
| 6078 | | .{ ._, .v_pd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 6079 | | .{ ._, .v_pd, .max, .dst0x, .src1x, .src0x, ._ }, |
| 6080 | | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 6081 | | } }, |
| 6082 | | }, .{ |
| 6083 | | .required_features = .{ .sse4_1, null, null, null }, |
| 6084 | | .src_constraints = .{ |
| 6085 | | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6086 | | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6087 | | }, |
| 6088 | | .patterns = &.{ |
| 6089 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 6090 | | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 6091 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 6092 | | }, |
| 6093 | | .dst_temps = .{.{ .rc = .sse }}, |
| 6094 | | .each = .{ .once = &.{ |
| 6095 | | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 6096 | | .{ ._, ._pd, .max, .dst0x, .src0x, ._, ._ }, |
| 6097 | | .{ ._, ._pd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 6098 | | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 6099 | | } }, |
| 6100 | | }, .{ |
| 6101 | | .required_features = .{ .sse2, null, null, null }, |
| 6102 | | .src_constraints = .{ |
| 6103 | | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6104 | | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6105 | | }, |
| 6106 | | .patterns = &.{ |
| 6107 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 6108 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 6109 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 6110 | | }, |
| 6111 | | .extra_temps = .{ |
| 6112 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6113 | | .unused, |
| 6114 | | .unused, |
| 6115 | | .unused, |
| 6116 | | .unused, |
| 6117 | | .unused, |
| 6118 | | .unused, |
| 6119 | | .unused, |
| 6120 | | .unused, |
| 6121 | | }, |
| 6122 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6123 | | .each = .{ .once = &.{ |
| 6124 | | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 6125 | | .{ ._, ._pd, .max, .tmp0x, .src0x, ._, ._ }, |
| 6126 | | .{ ._, ._pd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 6127 | | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 6128 | | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 6129 | | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 6130 | | } }, |
| 6131 | | }, .{ |
| 6132 | | .required_features = .{ .avx, null, null, null }, |
| 6133 | | .src_constraints = .{ |
| 6134 | | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6135 | | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6136 | | }, |
| 6137 | | .patterns = &.{ |
| 6138 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 6139 | | }, |
| 6140 | | .extra_temps = .{ |
| 6141 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6142 | | .unused, |
| 6143 | | .unused, |
| 6144 | | .unused, |
| 6145 | | .unused, |
| 6146 | | .unused, |
| 6147 | | .unused, |
| 6148 | | .unused, |
| 6149 | | .unused, |
| 6150 | | }, |
| 6151 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6152 | | .each = .{ .once = &.{ |
| 6153 | | .{ ._, .v_pd, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 6154 | | .{ ._, .v_pd, .max, .dst0y, .src1y, .src0y, ._ }, |
| 6155 | | .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 6156 | | } }, |
| 6157 | | }, .{ |
| 6158 | | .required_features = .{ .avx, null, null, null }, |
| 6159 | | .src_constraints = .{ |
| 6160 | | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6161 | | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6162 | | }, |
| 6163 | | .patterns = &.{ |
| 6164 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6165 | | }, |
| 6166 | | .extra_temps = .{ |
| 6167 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6168 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6169 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6170 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6171 | | .unused, |
| 6172 | | .unused, |
| 6173 | | .unused, |
| 6174 | | .unused, |
| 6175 | | .unused, |
| 6176 | | }, |
| 6177 | | .dst_temps = .{.mem}, |
| 6178 | | .clobbers = .{ .eflags = true }, |
| 6179 | | .each = .{ .once = &.{ |
| 6180 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6181 | | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 6182 | | .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 6183 | | .{ ._, .v_pd, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 6184 | | .{ ._, .v_pd, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 6185 | | .{ ._, .v_pd, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 6186 | | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 6187 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 6188 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6189 | | } }, |
| 6190 | | }, .{ |
| 6191 | | .required_features = .{ .sse4_1, null, null, null }, |
| 6192 | | .src_constraints = .{ |
| 6193 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6194 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6195 | | }, |
| 6196 | | .patterns = &.{ |
| 6197 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6198 | | }, |
| 6199 | | .extra_temps = .{ |
| 6200 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6201 | | .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } }, |
| 6202 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6203 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6204 | | .unused, |
| 6205 | | .unused, |
| 6206 | | .unused, |
| 6207 | | .unused, |
| 6208 | | .unused, |
| 6209 | | }, |
| 6210 | | .dst_temps = .{.mem}, |
| 6211 | | .clobbers = .{ .eflags = true }, |
| 6212 | | .each = .{ .once = &.{ |
| 6213 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6214 | | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6215 | | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6216 | | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 6217 | | .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 6218 | | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 6219 | | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 6220 | | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 6221 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6222 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6223 | | } }, |
| 6224 | | }, .{ |
| 6225 | | .required_features = .{ .sse2, null, null, null }, |
| 6226 | | .src_constraints = .{ |
| 6227 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6228 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6229 | | }, |
| 6230 | | .patterns = &.{ |
| 6231 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6232 | | }, |
| 6233 | | .extra_temps = .{ |
| 6234 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6235 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6236 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6237 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6238 | | .unused, |
| 6239 | | .unused, |
| 6240 | | .unused, |
| 6241 | | .unused, |
| 6242 | | .unused, |
| 6243 | | }, |
| 6244 | | .dst_temps = .{.mem}, |
| 6245 | | .clobbers = .{ .eflags = true }, |
| 6246 | | .each = .{ .once = &.{ |
| 6247 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6248 | | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6249 | | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6250 | | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 6251 | | .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 6252 | | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 6253 | | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 6254 | | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 6255 | | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 6256 | | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6257 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6258 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6259 | | } }, |
| 6260 | | }, .{ |
| 6261 | | .required_features = .{ .sse, null, null, null }, |
| 6262 | | .src_constraints = .{ |
| 6263 | | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6264 | | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6265 | | }, |
| 6266 | | .patterns = &.{ |
| 6267 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6268 | | }, |
| 6269 | | .call_frame = .{ .alignment = .@"16" }, |
| 6270 | | .extra_temps = .{ |
| 6271 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6272 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 6273 | | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 6274 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, |
| 6275 | | .unused, |
| 6276 | | .unused, |
| 6277 | | .unused, |
| 6278 | | .unused, |
| 6279 | | .unused, |
| 6280 | | }, |
| 6281 | | .dst_temps = .{.mem}, |
| 6282 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6283 | | .each = .{ .once = &.{ |
| 6284 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6285 | | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6286 | | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6287 | | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 6288 | | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 6024 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6025 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6026 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6289 | 6027 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6290 | | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 6291 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 6292 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6293 | | } }, |
| 6294 | | }, .{ |
| 6295 | | .required_features = .{ .x87, .cmov, null, null }, |
| 6296 | | .src_constraints = .{ |
| 6297 | | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6298 | | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6299 | | }, |
| 6300 | | .patterns = &.{ |
| 6301 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 6302 | | .{ .src = .{ .mem, .to_x87 } }, |
| 6303 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 6304 | | }, |
| 6305 | | .extra_temps = .{ |
| 6306 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6307 | | .unused, |
| 6308 | | .unused, |
| 6309 | | .unused, |
| 6310 | | .unused, |
| 6311 | | .unused, |
| 6312 | | .unused, |
| 6313 | | .unused, |
| 6314 | | .unused, |
| 6315 | | }, |
| 6316 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| 6317 | | .clobbers = .{ .eflags = true }, |
| 6318 | | .each = .{ .once = &.{ |
| 6319 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 6320 | | .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ }, |
| 6321 | | .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ }, |
| 6322 | | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 6323 | | .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ }, |
| 6324 | | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 6325 | | .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ }, |
| 6326 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 6327 | | } }, |
| 6328 | | }, .{ |
| 6329 | | .required_features = .{ .sahf, .x87, null, null }, |
| 6330 | | .src_constraints = .{ |
| 6331 | | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6332 | | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6333 | | }, |
| 6334 | | .patterns = &.{ |
| 6335 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 6336 | | .{ .src = .{ .mem, .to_x87 } }, |
| 6337 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 6338 | | }, |
| 6339 | | .extra_temps = .{ |
| 6340 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6341 | | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6342 | | .unused, |
| 6343 | | .unused, |
| 6344 | | .unused, |
| 6345 | | .unused, |
| 6346 | | .unused, |
| 6347 | | .unused, |
| 6348 | | .unused, |
| 6349 | | }, |
| 6350 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| 6351 | | .clobbers = .{ .eflags = true }, |
| 6352 | | .each = .{ .once = &.{ |
| 6353 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 6354 | | .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, |
| 6355 | | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 6356 | | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6357 | | .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, |
| 6358 | | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 6359 | | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| 6360 | | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 6361 | | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 6362 | | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6363 | | .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, |
| 6364 | | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| 6365 | | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 6366 | | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| 6367 | | } }, |
| 6368 | | }, .{ |
| 6369 | | .required_features = .{ .x87, null, null, null }, |
| 6370 | | .src_constraints = .{ |
| 6371 | | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6372 | | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6373 | | }, |
| 6374 | | .patterns = &.{ |
| 6375 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 6376 | | .{ .src = .{ .mem, .to_x87 } }, |
| 6377 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 6378 | | }, |
| 6379 | | .extra_temps = .{ |
| 6380 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6381 | | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6382 | | .unused, |
| 6383 | | .unused, |
| 6384 | | .unused, |
| 6385 | | .unused, |
| 6386 | | .unused, |
| 6387 | | .unused, |
| 6388 | | .unused, |
| 6389 | | }, |
| 6390 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| 6391 | | .clobbers = .{ .eflags = true }, |
| 6392 | | .each = .{ .once = &.{ |
| 6393 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 6394 | | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| 6395 | | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 6396 | | .{ ._, ._, .@"test", .tmp1b, .si(0b1_000_100), ._, ._ }, |
| 6397 | | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 6398 | | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 6399 | | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| 6400 | | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 6401 | | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 6402 | | .{ ._, ._, .@"test", .tmp1b, .si(0b0_000_001), ._, ._ }, |
| 6403 | | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 6404 | | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| 6405 | | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 6406 | | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| 6407 | | } }, |
| 6408 | | }, .{ |
| 6409 | | .required_features = .{ .x87, .cmov, null, null }, |
| 6410 | | .src_constraints = .{ |
| 6411 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6412 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6413 | | }, |
| 6414 | | .patterns = &.{ |
| 6415 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6416 | | }, |
| 6417 | | .extra_temps = .{ |
| 6418 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6419 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6420 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6421 | | .unused, |
| 6422 | | .unused, |
| 6423 | | .unused, |
| 6424 | | .unused, |
| 6425 | | .unused, |
| 6426 | | .unused, |
| 6427 | | }, |
| 6428 | | .dst_temps = .{.mem}, |
| 6429 | | .clobbers = .{ .eflags = true }, |
| 6430 | | .each = .{ .once = &.{ |
| 6431 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6432 | | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6433 | | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6434 | | .{ ._, .f_, .ucomi, .tmp1t, .tmp1t, ._, ._ }, |
| 6435 | | .{ ._, .f_u, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 6436 | | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6437 | | .{ ._, .f_, .ucomi, .tmp1t, .tmp2t, ._, ._ }, |
| 6438 | | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6439 | | .{ ._, .f_nb, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 6440 | | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6441 | | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6442 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6443 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6444 | | } }, |
| 6445 | | }, .{ |
| 6446 | | .required_features = .{ .sahf, .x87, null, null }, |
| 6447 | | .src_constraints = .{ |
| 6448 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6449 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6450 | | }, |
| 6451 | | .patterns = &.{ |
| 6452 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6453 | | }, |
| 6454 | | .extra_temps = .{ |
| 6455 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6456 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6457 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6458 | | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6459 | | .unused, |
| 6460 | | .unused, |
| 6461 | | .unused, |
| 6462 | | .unused, |
| 6463 | | .unused, |
| 6464 | | }, |
| 6465 | | .dst_temps = .{.mem}, |
| 6466 | | .clobbers = .{ .eflags = true }, |
| 6467 | | .each = .{ .once = &.{ |
| 6468 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6469 | | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6470 | | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6471 | | .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ }, |
| 6472 | | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6473 | | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6474 | | .{ ._, ._p, .j, .@"1f", ._, ._, ._ }, |
| 6475 | | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6476 | | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 6477 | | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6478 | | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6479 | | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 6480 | | .{ ._, ._b, .j, .@"2f", ._, ._, ._ }, |
| 6481 | | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 6482 | | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 6483 | | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6484 | | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6485 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6486 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6487 | | } }, |
| 6488 | | }, .{ |
| 6489 | | .required_features = .{ .x87, null, null, null }, |
| 6490 | | .src_constraints = .{ |
| 6491 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6492 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6493 | | }, |
| 6494 | | .patterns = &.{ |
| 6495 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6496 | | }, |
| 6497 | | .extra_temps = .{ |
| 6498 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6499 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6500 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6501 | | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 6502 | | .unused, |
| 6503 | | .unused, |
| 6504 | | .unused, |
| 6505 | | .unused, |
| 6506 | | .unused, |
| 6507 | | }, |
| 6508 | | .dst_temps = .{.mem}, |
| 6509 | | .clobbers = .{ .eflags = true }, |
| 6510 | | .each = .{ .once = &.{ |
| 6511 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6512 | | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 6513 | | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6514 | | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| 6515 | | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6516 | | .{ ._, ._, .@"test", .tmp3b, .si(0b1_000_100), ._, ._ }, |
| 6517 | | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| 6518 | | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6519 | | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 6520 | | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 6521 | | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 6522 | | .{ ._, ._, .@"test", .tmp3b, .si(0b0_000_001), ._, ._ }, |
| 6523 | | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| 6524 | | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 6525 | | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 6526 | | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 6527 | | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 6528 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6529 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6530 | | } }, |
| 6531 | | }, .{ |
| 6532 | | .required_features = .{ .sse, null, null, null }, |
| 6533 | | .src_constraints = .{ |
| 6534 | | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6535 | | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6536 | | }, |
| 6537 | | .patterns = &.{ |
| 6538 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 6539 | | }, |
| 6540 | | .call_frame = .{ .alignment = .@"16" }, |
| 6541 | | .extra_temps = .{ |
| 6542 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6543 | | .unused, |
| 6544 | | .unused, |
| 6545 | | .unused, |
| 6546 | | .unused, |
| 6547 | | .unused, |
| 6548 | | .unused, |
| 6549 | | .unused, |
| 6550 | | .unused, |
| 6551 | | }, |
| 6552 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6553 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6554 | | .each = .{ .once = &.{ |
| 6555 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6556 | | } }, |
| 6557 | | }, .{ |
| 6558 | | .required_features = .{ .avx, null, null, null }, |
| 6559 | | .src_constraints = .{ |
| 6560 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6561 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6562 | | }, |
| 6563 | | .patterns = &.{ |
| 6564 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6565 | | }, |
| 6566 | | .call_frame = .{ .alignment = .@"16" }, |
| 6567 | | .extra_temps = .{ |
| 6568 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6569 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6570 | | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6571 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6572 | | .unused, |
| 6573 | | .unused, |
| 6574 | | .unused, |
| 6575 | | .unused, |
| 6576 | | .unused, |
| 6577 | | }, |
| 6578 | | .dst_temps = .{.mem}, |
| 6579 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6580 | | .each = .{ .once = &.{ |
| 6581 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6582 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6583 | | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6584 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6585 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6586 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6587 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6588 | | } }, |
| 6589 | | }, .{ |
| 6590 | | .required_features = .{ .sse2, null, null, null }, |
| 6591 | | .src_constraints = .{ |
| 6592 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6593 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6594 | | }, |
| 6595 | | .patterns = &.{ |
| 6596 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6597 | | }, |
| 6598 | | .call_frame = .{ .alignment = .@"16" }, |
| 6599 | | .extra_temps = .{ |
| 6600 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6601 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6602 | | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6603 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6604 | | .unused, |
| 6605 | | .unused, |
| 6606 | | .unused, |
| 6607 | | .unused, |
| 6608 | | .unused, |
| 6609 | | }, |
| 6610 | | .dst_temps = .{.mem}, |
| 6611 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6612 | | .each = .{ .once = &.{ |
| 6613 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6614 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6615 | | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6616 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6617 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6618 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6619 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6620 | | } }, |
| 6621 | | }, .{ |
| 6622 | | .required_features = .{ .sse, null, null, null }, |
| 6623 | | .src_constraints = .{ |
| 6624 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6625 | | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 6626 | | }, |
| 6627 | | .patterns = &.{ |
| 6628 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6629 | | }, |
| 6630 | | .call_frame = .{ .alignment = .@"16" }, |
| 6631 | | .extra_temps = .{ |
| 6632 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6633 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 6634 | | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 6635 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 6636 | | .unused, |
| 6637 | | .unused, |
| 6638 | | .unused, |
| 6639 | | .unused, |
| 6640 | | .unused, |
| 6641 | | }, |
| 6642 | | .dst_temps = .{.mem}, |
| 6643 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6644 | | .each = .{ .once = &.{ |
| 6645 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 6646 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 6647 | | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 6648 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6649 | | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 6028 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 6650 | 6029 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6651 | 6030 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6652 | 6031 | } }, |
| ... | ... | @@ -6661,455 +6040,7677 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6661 | 6040 | }; |
| 6662 | 6041 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 6663 | 6042 | }, |
| 6664 | | .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { |
| 6043 | .div_trunc, .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: { |
| 6665 | 6044 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 6045 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag); |
| 6666 | 6046 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 6667 | 6047 | var res: [1]Temp = undefined; |
| 6668 | | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 6669 | | .required_features = .{ .cmov, null, null, null }, |
| 6670 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, |
| 6671 | | .patterns = &.{ |
| 6672 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6673 | | }, |
| 6674 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6675 | | .clobbers = .{ .eflags = true }, |
| 6676 | | .each = .{ .once = &.{ |
| 6677 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 6678 | | .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ }, |
| 6679 | | } }, |
| 6680 | | }, .{ |
| 6681 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, |
| 6682 | | .patterns = &.{ |
| 6683 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6684 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6685 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6686 | | }, |
| 6687 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6688 | | .clobbers = .{ .eflags = true }, |
| 6689 | | .each = .{ .once = &.{ |
| 6690 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 6691 | | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 6692 | | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 6693 | | } }, |
| 6694 | | }, .{ |
| 6695 | | .required_features = .{ .cmov, null, null, null }, |
| 6696 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, |
| 6697 | | .patterns = &.{ |
| 6698 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6699 | | }, |
| 6700 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6701 | | .clobbers = .{ .eflags = true }, |
| 6702 | | .each = .{ .once = &.{ |
| 6703 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 6704 | | .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ }, |
| 6705 | | } }, |
| 6706 | | }, .{ |
| 6707 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, |
| 6708 | | .patterns = &.{ |
| 6709 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6710 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6711 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6712 | | }, |
| 6713 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6714 | | .clobbers = .{ .eflags = true }, |
| 6715 | | .each = .{ .once = &.{ |
| 6716 | | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 6717 | | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 6718 | | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 6719 | | } }, |
| 6720 | | }, .{ |
| 6721 | | .required_features = .{ .cmov, null, null, null }, |
| 6722 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, |
| 6723 | | .patterns = &.{ |
| 6724 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6725 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6726 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6727 | | }, |
| 6728 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6729 | | .clobbers = .{ .eflags = true }, |
| 6730 | | .each = .{ .once = &.{ |
| 6731 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 6732 | | .{ ._, ._ge, .cmov, .dst0w, .src1w, ._, ._ }, |
| 6733 | | } }, |
| 6734 | | }, .{ |
| 6735 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, |
| 6736 | | .patterns = &.{ |
| 6737 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6738 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6739 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6740 | | }, |
| 6741 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6742 | | .clobbers = .{ .eflags = true }, |
| 6743 | | .each = .{ .once = &.{ |
| 6744 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 6745 | | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 6746 | | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 6747 | | } }, |
| 6748 | | }, .{ |
| 6749 | | .required_features = .{ .cmov, null, null, null }, |
| 6750 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, |
| 6751 | | .patterns = &.{ |
| 6752 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6753 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6754 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6755 | | }, |
| 6756 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6757 | | .clobbers = .{ .eflags = true }, |
| 6758 | | .each = .{ .once = &.{ |
| 6759 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 6760 | | .{ ._, ._ae, .cmov, .dst0w, .src1w, ._, ._ }, |
| 6761 | | } }, |
| 6762 | | }, .{ |
| 6763 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, |
| 6764 | | .patterns = &.{ |
| 6765 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6766 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6767 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6768 | | }, |
| 6769 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6770 | | .clobbers = .{ .eflags = true }, |
| 6771 | | .each = .{ .once = &.{ |
| 6772 | | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 6773 | | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 6774 | | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 6775 | | } }, |
| 6776 | | }, .{ |
| 6777 | | .required_features = .{ .cmov, null, null, null }, |
| 6778 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, |
| 6779 | | .patterns = &.{ |
| 6780 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6781 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6782 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6783 | | }, |
| 6784 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6785 | | .clobbers = .{ .eflags = true }, |
| 6786 | | .each = .{ .once = &.{ |
| 6787 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 6788 | | .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ }, |
| 6789 | | } }, |
| 6790 | | }, .{ |
| 6791 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, |
| 6792 | | .patterns = &.{ |
| 6793 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6794 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6795 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6796 | | }, |
| 6797 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6798 | | .clobbers = .{ .eflags = true }, |
| 6799 | | .each = .{ .once = &.{ |
| 6800 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 6801 | | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 6802 | | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 6803 | | } }, |
| 6804 | | }, .{ |
| 6805 | | .required_features = .{ .cmov, null, null, null }, |
| 6806 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, |
| 6807 | | .patterns = &.{ |
| 6808 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6809 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6810 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6811 | | }, |
| 6812 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6813 | | .clobbers = .{ .eflags = true }, |
| 6814 | | .each = .{ .once = &.{ |
| 6815 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 6816 | | .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ }, |
| 6817 | | } }, |
| 6818 | | }, .{ |
| 6819 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, |
| 6820 | | .patterns = &.{ |
| 6821 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6822 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6823 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6824 | | }, |
| 6825 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6826 | | .clobbers = .{ .eflags = true }, |
| 6827 | | .each = .{ .once = &.{ |
| 6828 | | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 6829 | | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 6830 | | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 6831 | | } }, |
| 6832 | | }, .{ |
| 6833 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 6834 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, |
| 6835 | | .patterns = &.{ |
| 6836 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6837 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6838 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6839 | | }, |
| 6840 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6841 | | .clobbers = .{ .eflags = true }, |
| 6842 | | .each = .{ .once = &.{ |
| 6843 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 6844 | | .{ ._, ._ge, .cmov, .dst0q, .src1q, ._, ._ }, |
| 6845 | | } }, |
| 6846 | | }, .{ |
| 6847 | | .required_features = .{ .@"64bit", null, null, null }, |
| 6848 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, |
| 6849 | | .patterns = &.{ |
| 6850 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6851 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6852 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6853 | | }, |
| 6854 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6855 | | .clobbers = .{ .eflags = true }, |
| 6856 | | .each = .{ .once = &.{ |
| 6857 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 6858 | | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 6859 | | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 6860 | | } }, |
| 6861 | | }, .{ |
| 6862 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 6863 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, |
| 6864 | | .patterns = &.{ |
| 6865 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6866 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6867 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6868 | | }, |
| 6869 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6870 | | .clobbers = .{ .eflags = true }, |
| 6871 | | .each = .{ .once = &.{ |
| 6872 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 6873 | | .{ ._, ._ae, .cmov, .dst0q, .src1q, ._, ._ }, |
| 6874 | | } }, |
| 6875 | | }, .{ |
| 6876 | | .required_features = .{ .@"64bit", null, null, null }, |
| 6877 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, |
| 6878 | | .patterns = &.{ |
| 6879 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 6880 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 6881 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 6882 | | }, |
| 6883 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 6884 | | .clobbers = .{ .eflags = true }, |
| 6885 | | .each = .{ .once = &.{ |
| 6886 | | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 6887 | | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 6888 | | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 6889 | | } }, |
| 6890 | | }, .{ |
| 6891 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 6892 | | .src_constraints = .{ .any_signed_int, .any_signed_int }, |
| 6893 | | .patterns = &.{ |
| 6894 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6895 | | }, |
| 6896 | | .extra_temps = .{ |
| 6897 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 6898 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 6899 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6900 | | .unused, |
| 6901 | | .unused, |
| 6902 | | .unused, |
| 6903 | | .unused, |
| 6904 | | .unused, |
| 6905 | | .unused, |
| 6906 | | }, |
| 6907 | | .dst_temps = .{.mem}, |
| 6908 | | .clobbers = .{ .eflags = true }, |
| 6909 | | .each = .{ .once = &.{ |
| 6910 | | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 6911 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6912 | | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6913 | | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6914 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6915 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6916 | | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 6917 | | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 6918 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 6919 | | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 6920 | | .{ ._, ._ge, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 6921 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 6922 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 6923 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 6924 | | } }, |
| 6925 | | }, .{ |
| 6926 | | .required_features = .{ .@"64bit", null, null, null }, |
| 6927 | | .src_constraints = .{ .any_signed_int, .any_signed_int }, |
| 6928 | | .patterns = &.{ |
| 6929 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6930 | | }, |
| 6931 | | .extra_temps = .{ |
| 6932 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 6933 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 6934 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6935 | | .unused, |
| 6936 | | .unused, |
| 6937 | | .unused, |
| 6938 | | .unused, |
| 6939 | | .unused, |
| 6940 | | .unused, |
| 6941 | | }, |
| 6942 | | .dst_temps = .{.mem}, |
| 6943 | | .clobbers = .{ .eflags = true }, |
| 6944 | | .each = .{ .once = &.{ |
| 6945 | | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 6946 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6947 | | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6948 | | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6949 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6950 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6951 | | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 6952 | | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 6953 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 6954 | | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 6955 | | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 6956 | | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 6957 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 6958 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 6959 | | } }, |
| 6960 | | }, .{ |
| 6961 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 6962 | | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, |
| 6963 | | .patterns = &.{ |
| 6964 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6965 | | }, |
| 6966 | | .extra_temps = .{ |
| 6967 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 6968 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 6969 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6970 | | .unused, |
| 6971 | | .unused, |
| 6972 | | .unused, |
| 6973 | | .unused, |
| 6974 | | .unused, |
| 6975 | | .unused, |
| 6976 | | }, |
| 6977 | | .dst_temps = .{.mem}, |
| 6978 | | .clobbers = .{ .eflags = true }, |
| 6979 | | .each = .{ .once = &.{ |
| 6980 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 6981 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6982 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 6983 | | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 6984 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6985 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6986 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 6987 | | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 6988 | | .{ ._, ._ae, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 6989 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 6990 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 6991 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 6992 | | } }, |
| 6993 | | }, .{ |
| 6994 | | .required_features = .{ .@"64bit", null, null, null }, |
| 6995 | | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, |
| 6996 | | .patterns = &.{ |
| 6997 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 6998 | | }, |
| 6999 | | .extra_temps = .{ |
| 7000 | | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 7001 | | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 7002 | | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 7003 | | .unused, |
| 7004 | | .unused, |
| 7005 | | .unused, |
| 7006 | | .unused, |
| 7007 | | .unused, |
| 7008 | | .unused, |
| 7009 | | }, |
| 7010 | | .dst_temps = .{.mem}, |
| 7011 | | .clobbers = .{ .eflags = true }, |
| 7012 | | .each = .{ .once = &.{ |
| 7013 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 7014 | | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 7015 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 7016 | | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 7017 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 7018 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 7019 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 7020 | | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 7021 | | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 7022 | | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 7023 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 7024 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 7025 | | } }, |
| 7026 | | }, .{ |
| 7027 | | .required_features = .{ .avx, null, null, null }, |
| 7028 | | .src_constraints = .{ |
| 7029 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7030 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7031 | | }, |
| 7032 | | .patterns = &.{ |
| 7033 | | .{ .src = .{ .to_sse, .mem } }, |
| 7034 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7035 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 7036 | | }, |
| 7037 | | .dst_temps = .{.{ .rc = .sse }}, |
| 7038 | | .each = .{ .once = &.{ |
| 7039 | | .{ ._, .vp_b, .mins, .dst0x, .src0x, .src1x, ._ }, |
| 7040 | | } }, |
| 7041 | | }, .{ |
| 7042 | | .required_features = .{ .sse4_1, null, null, null }, |
| 7043 | | .src_constraints = .{ |
| 7044 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7045 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7046 | | }, |
| 7047 | | .patterns = &.{ |
| 7048 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 7049 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 7050 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 7051 | | }, |
| 7052 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 7053 | | .each = .{ .once = &.{ |
| 7054 | | .{ ._, .p_b, .mins, .dst0x, .src1x, ._, ._ }, |
| 7055 | | } }, |
| 7056 | | }, .{ |
| 7057 | | .required_features = .{ .sse2, null, null, null }, |
| 7058 | | .src_constraints = .{ |
| 7059 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7060 | | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7061 | | }, |
| 7062 | | .patterns = &.{ |
| 7063 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 7064 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 7065 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 7066 | | }, |
| 7067 | | .dst_temps = .{.{ .rc = .sse }}, |
| 7068 | | .each = .{ .once = &.{ |
| 7069 | | .{ ._, ._dqa, .mov, .dst0x, .src1x, ._, ._ }, |
| 7070 | | .{ ._, .p_b, .cmpgt, .dst0x, .src0x, ._, ._ }, |
| 7071 | | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 7072 | | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 7073 | | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 7074 | | } }, |
| 7075 | | }, .{ |
| 7076 | | .required_features = .{ .avx2, null, null, null }, |
| 7077 | | .src_constraints = .{ |
| 7078 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 7079 | | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 7080 | | }, |
| 7081 | | .patterns = &.{ |
| 7082 | | .{ .src = .{ .to_sse, .mem } }, |
| 7083 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7084 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 7085 | | }, |
| 7086 | | .dst_temps = .{.{ .rc = .sse }}, |
| 7087 | | .each = .{ .once = &.{ |
| 7088 | | .{ ._, .vp_b, .mins, .dst0y, .src0y, .src1y, ._ }, |
| 7089 | | } }, |
| 7090 | | }, .{ |
| 7091 | | .required_features = .{ .avx2, null, null, null }, |
| 7092 | | .src_constraints = .{ |
| 7093 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 7094 | | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 7095 | | }, |
| 7096 | | .patterns = &.{ |
| 7097 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 7098 | | }, |
| 7099 | | .extra_temps = .{ |
| 7100 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7101 | | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 7102 | | .unused, |
| 7103 | | .unused, |
| 7104 | | .unused, |
| 7105 | | .unused, |
| 7106 | | .unused, |
| 7107 | | .unused, |
| 7108 | | .unused, |
| 7109 | | }, |
| 7110 | | .dst_temps = .{.mem}, |
| 7111 | | .clobbers = .{ .eflags = true }, |
| 7112 | | .each = .{ .once = &.{ |
| 6048 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) { |
| 6049 | else => unreachable, |
| 6050 | .div_trunc => .zero, |
| 6051 | .div_floor => .down, |
| 6052 | })) { |
| 6053 | else => unreachable, |
| 6054 | inline .zero, .down => |direction| comptime &.{ .{ |
| 6055 | .required_features = .{ .f16c, null, null, null }, |
| 6056 | .src_constraints = .{ |
| 6057 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6058 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6059 | .any, |
| 6060 | }, |
| 6061 | .patterns = &.{ |
| 6062 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6063 | }, |
| 6064 | .extra_temps = .{ |
| 6065 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 6066 | .unused, |
| 6067 | .unused, |
| 6068 | .unused, |
| 6069 | .unused, |
| 6070 | .unused, |
| 6071 | .unused, |
| 6072 | .unused, |
| 6073 | .unused, |
| 6074 | }, |
| 6075 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6076 | .each = .{ .once = &.{ |
| 6077 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 6078 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 6079 | .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ }, |
| 6080 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6081 | .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ }, |
| 6082 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 6083 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6084 | } }, |
| 6085 | }, .{ |
| 6086 | .required_features = .{ .sse, null, null, null }, |
| 6087 | .src_constraints = .{ |
| 6088 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6089 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6090 | .any, |
| 6091 | }, |
| 6092 | .patterns = &.{ |
| 6093 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 6094 | }, |
| 6095 | .call_frame = .{ .alignment = .@"16" }, |
| 6096 | .extra_temps = .{ |
| 6097 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6098 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6099 | else => unreachable, |
| 6100 | .zero => "__trunch", |
| 6101 | .down => "__floorh", |
| 6102 | } } } }, |
| 6103 | .unused, |
| 6104 | .unused, |
| 6105 | .unused, |
| 6106 | .unused, |
| 6107 | .unused, |
| 6108 | .unused, |
| 6109 | .unused, |
| 6110 | }, |
| 6111 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6112 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6113 | .each = .{ .once = &.{ |
| 6114 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6115 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 6116 | } }, |
| 6117 | }, .{ |
| 6118 | .required_features = .{ .f16c, null, null, null }, |
| 6119 | .src_constraints = .{ |
| 6120 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 6121 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 6122 | .any, |
| 6123 | }, |
| 6124 | .patterns = &.{ |
| 6125 | .{ .src = .{ .mem, .mem, .none } }, |
| 6126 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6127 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 6128 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6129 | }, |
| 6130 | .extra_temps = .{ |
| 6131 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 6132 | .unused, |
| 6133 | .unused, |
| 6134 | .unused, |
| 6135 | .unused, |
| 6136 | .unused, |
| 6137 | .unused, |
| 6138 | .unused, |
| 6139 | .unused, |
| 6140 | }, |
| 6141 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6142 | .each = .{ .once = &.{ |
| 6143 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 6144 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 6145 | .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ }, |
| 6146 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6147 | .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ }, |
| 6148 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6149 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6150 | } }, |
| 6151 | }, .{ |
| 6152 | .required_features = .{ .f16c, null, null, null }, |
| 6153 | .src_constraints = .{ |
| 6154 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 6155 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 6156 | .any, |
| 6157 | }, |
| 6158 | .patterns = &.{ |
| 6159 | .{ .src = .{ .mem, .mem, .none } }, |
| 6160 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6161 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 6162 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6163 | }, |
| 6164 | .extra_temps = .{ |
| 6165 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 6166 | .unused, |
| 6167 | .unused, |
| 6168 | .unused, |
| 6169 | .unused, |
| 6170 | .unused, |
| 6171 | .unused, |
| 6172 | .unused, |
| 6173 | .unused, |
| 6174 | }, |
| 6175 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6176 | .each = .{ .once = &.{ |
| 6177 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 6178 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 6179 | .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ }, |
| 6180 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 6181 | .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ }, |
| 6182 | .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6183 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 6184 | } }, |
| 6185 | }, .{ |
| 6186 | .required_features = .{ .f16c, null, null, null }, |
| 6187 | .src_constraints = .{ |
| 6188 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 6189 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 6190 | .any, |
| 6191 | }, |
| 6192 | .patterns = &.{ |
| 6193 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6194 | }, |
| 6195 | .extra_temps = .{ |
| 6196 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6197 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 6198 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 6199 | .unused, |
| 6200 | .unused, |
| 6201 | .unused, |
| 6202 | .unused, |
| 6203 | .unused, |
| 6204 | .unused, |
| 6205 | }, |
| 6206 | .dst_temps = .{.mem}, |
| 6207 | .clobbers = .{ .eflags = true }, |
| 6208 | .each = .{ .once = &.{ |
| 6209 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6210 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6211 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6212 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 6213 | .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ }, |
| 6214 | .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ }, |
| 6215 | .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6216 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 6217 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6218 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6219 | } }, |
| 6220 | }, .{ |
| 6221 | .required_features = .{ .avx, null, null, null }, |
| 6222 | .src_constraints = .{ |
| 6223 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6224 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6225 | .any, |
| 6226 | }, |
| 6227 | .patterns = &.{ |
| 6228 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6229 | }, |
| 6230 | .call_frame = .{ .alignment = .@"16" }, |
| 6231 | .extra_temps = .{ |
| 6232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6233 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6234 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6235 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6236 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6237 | else => unreachable, |
| 6238 | .zero => "__trunch", |
| 6239 | .down => "__floorh", |
| 6240 | } } } }, |
| 6241 | .unused, |
| 6242 | .unused, |
| 6243 | .unused, |
| 6244 | .unused, |
| 6245 | }, |
| 6246 | .dst_temps = .{.mem}, |
| 6247 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6248 | .each = .{ .once = &.{ |
| 6249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6250 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 6251 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 6252 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 6253 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6254 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6255 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 6256 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6257 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6258 | } }, |
| 6259 | }, .{ |
| 6260 | .required_features = .{ .sse4_1, null, null, null }, |
| 6261 | .src_constraints = .{ |
| 6262 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6263 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6264 | .any, |
| 6265 | }, |
| 6266 | .patterns = &.{ |
| 6267 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6268 | }, |
| 6269 | .call_frame = .{ .alignment = .@"16" }, |
| 6270 | .extra_temps = .{ |
| 6271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6272 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6273 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6274 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6275 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6276 | else => unreachable, |
| 6277 | .zero => "__trunch", |
| 6278 | .down => "__floorh", |
| 6279 | } } } }, |
| 6280 | .unused, |
| 6281 | .unused, |
| 6282 | .unused, |
| 6283 | .unused, |
| 6284 | }, |
| 6285 | .dst_temps = .{.mem}, |
| 6286 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6287 | .each = .{ .once = &.{ |
| 6288 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6289 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6290 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6291 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6292 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6293 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6294 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6295 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 6296 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6297 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6298 | } }, |
| 6299 | }, .{ |
| 6300 | .required_features = .{ .sse2, null, null, null }, |
| 6301 | .src_constraints = .{ |
| 6302 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6303 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6304 | .any, |
| 6305 | }, |
| 6306 | .patterns = &.{ |
| 6307 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6308 | }, |
| 6309 | .call_frame = .{ .alignment = .@"16" }, |
| 6310 | .extra_temps = .{ |
| 6311 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6312 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6313 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6314 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6315 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6316 | else => unreachable, |
| 6317 | .zero => "__trunch", |
| 6318 | .down => "__floorh", |
| 6319 | } } } }, |
| 6320 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 6321 | .unused, |
| 6322 | .unused, |
| 6323 | .unused, |
| 6324 | }, |
| 6325 | .dst_temps = .{.mem}, |
| 6326 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6327 | .each = .{ .once = &.{ |
| 6328 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6329 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6330 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6331 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6332 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6333 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6334 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6335 | .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ }, |
| 6336 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ }, |
| 6337 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6338 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6339 | } }, |
| 6340 | }, .{ |
| 6341 | .required_features = .{ .sse, null, null, null }, |
| 6342 | .src_constraints = .{ |
| 6343 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6344 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6345 | .any, |
| 6346 | }, |
| 6347 | .patterns = &.{ |
| 6348 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6349 | }, |
| 6350 | .call_frame = .{ .alignment = .@"16" }, |
| 6351 | .extra_temps = .{ |
| 6352 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6353 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 6354 | .{ .type = .f32, .kind = .mem }, |
| 6355 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6356 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6357 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6358 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6359 | else => unreachable, |
| 6360 | .zero => "__trunch", |
| 6361 | .down => "__floorh", |
| 6362 | } } } }, |
| 6363 | .unused, |
| 6364 | .unused, |
| 6365 | }, |
| 6366 | .dst_temps = .{.mem}, |
| 6367 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6368 | .each = .{ .once = &.{ |
| 6369 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6370 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6371 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 6372 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 6373 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6374 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 6375 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 6376 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 6377 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 6378 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 6379 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 6380 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 6381 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6383 | } }, |
| 6384 | }, .{ |
| 6385 | .required_features = .{ .avx, null, null, null }, |
| 6386 | .src_constraints = .{ |
| 6387 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6388 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6389 | .any, |
| 6390 | }, |
| 6391 | .patterns = &.{ |
| 6392 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6393 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6394 | }, |
| 6395 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6396 | .each = .{ .once = &.{ |
| 6397 | .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ }, |
| 6398 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 6399 | } }, |
| 6400 | }, .{ |
| 6401 | .required_features = .{ .sse4_1, null, null, null }, |
| 6402 | .src_constraints = .{ |
| 6403 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6404 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6405 | .any, |
| 6406 | }, |
| 6407 | .patterns = &.{ |
| 6408 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 6409 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 6410 | }, |
| 6411 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6412 | .each = .{ .once = &.{ |
| 6413 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 6414 | .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6415 | } }, |
| 6416 | }, .{ |
| 6417 | .required_features = .{ .sse, null, null, null }, |
| 6418 | .src_constraints = .{ |
| 6419 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6420 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6421 | .any, |
| 6422 | }, |
| 6423 | .patterns = &.{ |
| 6424 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, |
| 6425 | }, |
| 6426 | .call_frame = .{ .alignment = .@"16" }, |
| 6427 | .extra_temps = .{ |
| 6428 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6429 | else => unreachable, |
| 6430 | .zero => "truncf", |
| 6431 | .down => "floorf", |
| 6432 | } } } }, |
| 6433 | .unused, |
| 6434 | .unused, |
| 6435 | .unused, |
| 6436 | .unused, |
| 6437 | .unused, |
| 6438 | .unused, |
| 6439 | .unused, |
| 6440 | .unused, |
| 6441 | }, |
| 6442 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6443 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6444 | .each = .{ .once = &.{ |
| 6445 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 6446 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6447 | } }, |
| 6448 | }, .{ |
| 6449 | .required_features = .{ .avx, null, null, null }, |
| 6450 | .src_constraints = .{ |
| 6451 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6452 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6453 | .any, |
| 6454 | }, |
| 6455 | .patterns = &.{ |
| 6456 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6457 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6458 | }, |
| 6459 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6460 | .each = .{ .once = &.{ |
| 6461 | .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ }, |
| 6462 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6463 | } }, |
| 6464 | }, .{ |
| 6465 | .required_features = .{ .sse4_1, null, null, null }, |
| 6466 | .src_constraints = .{ |
| 6467 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6468 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6469 | .any, |
| 6470 | }, |
| 6471 | .patterns = &.{ |
| 6472 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 6473 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 6474 | }, |
| 6475 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6476 | .each = .{ .once = &.{ |
| 6477 | .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ }, |
| 6478 | .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6479 | } }, |
| 6480 | }, .{ |
| 6481 | .required_features = .{ .sse, null, null, null }, |
| 6482 | .src_constraints = .{ |
| 6483 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6484 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 6485 | .any, |
| 6486 | }, |
| 6487 | .patterns = &.{ |
| 6488 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6489 | }, |
| 6490 | .call_frame = .{ .alignment = .@"16" }, |
| 6491 | .extra_temps = .{ |
| 6492 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6493 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 6494 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6495 | else => unreachable, |
| 6496 | .zero => "truncf", |
| 6497 | .down => "floorf", |
| 6498 | } } } }, |
| 6499 | .unused, |
| 6500 | .unused, |
| 6501 | .unused, |
| 6502 | .unused, |
| 6503 | .unused, |
| 6504 | .unused, |
| 6505 | }, |
| 6506 | .dst_temps = .{.mem}, |
| 6507 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6508 | .each = .{ .once = &.{ |
| 6509 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6510 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6511 | .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6512 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 6513 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 6514 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 6515 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6516 | } }, |
| 6517 | }, .{ |
| 6518 | .required_features = .{ .avx, null, null, null }, |
| 6519 | .src_constraints = .{ |
| 6520 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 6521 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 6522 | .any, |
| 6523 | }, |
| 6524 | .patterns = &.{ |
| 6525 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6526 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6527 | }, |
| 6528 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6529 | .each = .{ .once = &.{ |
| 6530 | .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ }, |
| 6531 | .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6532 | } }, |
| 6533 | }, .{ |
| 6534 | .required_features = .{ .avx, null, null, null }, |
| 6535 | .src_constraints = .{ |
| 6536 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 6537 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 6538 | .any, |
| 6539 | }, |
| 6540 | .patterns = &.{ |
| 6541 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6542 | }, |
| 6543 | .extra_temps = .{ |
| 6544 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6545 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 6546 | .unused, |
| 6547 | .unused, |
| 6548 | .unused, |
| 6549 | .unused, |
| 6550 | .unused, |
| 6551 | .unused, |
| 6552 | .unused, |
| 6553 | }, |
| 6554 | .dst_temps = .{.mem}, |
| 6555 | .clobbers = .{ .eflags = true }, |
| 6556 | .each = .{ .once = &.{ |
| 6557 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6558 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6559 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 6560 | .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6561 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 6562 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 6563 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6564 | } }, |
| 6565 | }, .{ |
| 6566 | .required_features = .{ .sse4_1, null, null, null }, |
| 6567 | .src_constraints = .{ |
| 6568 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6569 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 6570 | .any, |
| 6571 | }, |
| 6572 | .patterns = &.{ |
| 6573 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6574 | }, |
| 6575 | .extra_temps = .{ |
| 6576 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6577 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 6578 | .unused, |
| 6579 | .unused, |
| 6580 | .unused, |
| 6581 | .unused, |
| 6582 | .unused, |
| 6583 | .unused, |
| 6584 | .unused, |
| 6585 | }, |
| 6586 | .dst_temps = .{.mem}, |
| 6587 | .clobbers = .{ .eflags = true }, |
| 6588 | .each = .{ .once = &.{ |
| 6589 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6590 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6591 | .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6592 | .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6593 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 6594 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6595 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6596 | } }, |
| 6597 | }, .{ |
| 6598 | .required_features = .{ .avx, null, null, null }, |
| 6599 | .src_constraints = .{ |
| 6600 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6601 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6602 | .any, |
| 6603 | }, |
| 6604 | .patterns = &.{ |
| 6605 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6606 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6607 | }, |
| 6608 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6609 | .each = .{ .once = &.{ |
| 6610 | .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ }, |
| 6611 | .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 6612 | } }, |
| 6613 | }, .{ |
| 6614 | .required_features = .{ .sse4_1, null, null, null }, |
| 6615 | .src_constraints = .{ |
| 6616 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6617 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6618 | .any, |
| 6619 | }, |
| 6620 | .patterns = &.{ |
| 6621 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 6622 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 6623 | }, |
| 6624 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6625 | .each = .{ .once = &.{ |
| 6626 | .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ }, |
| 6627 | .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6628 | } }, |
| 6629 | }, .{ |
| 6630 | .required_features = .{ .sse2, null, null, null }, |
| 6631 | .src_constraints = .{ |
| 6632 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6633 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6634 | .any, |
| 6635 | }, |
| 6636 | .patterns = &.{ |
| 6637 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, |
| 6638 | }, |
| 6639 | .call_frame = .{ .alignment = .@"16" }, |
| 6640 | .extra_temps = .{ |
| 6641 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6642 | else => unreachable, |
| 6643 | .zero => "trunc", |
| 6644 | .down => "floor", |
| 6645 | } } } }, |
| 6646 | .unused, |
| 6647 | .unused, |
| 6648 | .unused, |
| 6649 | .unused, |
| 6650 | .unused, |
| 6651 | .unused, |
| 6652 | .unused, |
| 6653 | .unused, |
| 6654 | }, |
| 6655 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6656 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6657 | .each = .{ .once = &.{ |
| 6658 | .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ }, |
| 6659 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6660 | } }, |
| 6661 | }, .{ |
| 6662 | .required_features = .{ .sse, null, null, null }, |
| 6663 | .src_constraints = .{ |
| 6664 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6665 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6666 | .any, |
| 6667 | }, |
| 6668 | .patterns = &.{ |
| 6669 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 6670 | }, |
| 6671 | .call_frame = .{ .alignment = .@"16" }, |
| 6672 | .extra_temps = .{ |
| 6673 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } }, |
| 6674 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6675 | else => unreachable, |
| 6676 | .zero => "trunc", |
| 6677 | .down => "floor", |
| 6678 | } } } }, |
| 6679 | .unused, |
| 6680 | .unused, |
| 6681 | .unused, |
| 6682 | .unused, |
| 6683 | .unused, |
| 6684 | .unused, |
| 6685 | .unused, |
| 6686 | }, |
| 6687 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6688 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6689 | .each = .{ .once = &.{ |
| 6690 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6691 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 6692 | } }, |
| 6693 | }, .{ |
| 6694 | .required_features = .{ .avx, null, null, null }, |
| 6695 | .src_constraints = .{ |
| 6696 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6697 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6698 | .any, |
| 6699 | }, |
| 6700 | .patterns = &.{ |
| 6701 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6702 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6703 | }, |
| 6704 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6705 | .each = .{ .once = &.{ |
| 6706 | .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ }, |
| 6707 | .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6708 | } }, |
| 6709 | }, .{ |
| 6710 | .required_features = .{ .sse4_1, null, null, null }, |
| 6711 | .src_constraints = .{ |
| 6712 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6713 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6714 | .any, |
| 6715 | }, |
| 6716 | .patterns = &.{ |
| 6717 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 6718 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 6719 | }, |
| 6720 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6721 | .each = .{ .once = &.{ |
| 6722 | .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ }, |
| 6723 | .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6724 | } }, |
| 6725 | }, .{ |
| 6726 | .required_features = .{ .avx, null, null, null }, |
| 6727 | .src_constraints = .{ |
| 6728 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6729 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6730 | .any, |
| 6731 | }, |
| 6732 | .patterns = &.{ |
| 6733 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6734 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6735 | }, |
| 6736 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6737 | .each = .{ .once = &.{ |
| 6738 | .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ }, |
| 6739 | .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6740 | } }, |
| 6741 | }, .{ |
| 6742 | .required_features = .{ .avx, null, null, null }, |
| 6743 | .src_constraints = .{ |
| 6744 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6745 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 6746 | .any, |
| 6747 | }, |
| 6748 | .patterns = &.{ |
| 6749 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6750 | }, |
| 6751 | .extra_temps = .{ |
| 6752 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6753 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 6754 | .unused, |
| 6755 | .unused, |
| 6756 | .unused, |
| 6757 | .unused, |
| 6758 | .unused, |
| 6759 | .unused, |
| 6760 | .unused, |
| 6761 | }, |
| 6762 | .dst_temps = .{.mem}, |
| 6763 | .clobbers = .{ .eflags = true }, |
| 6764 | .each = .{ .once = &.{ |
| 6765 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6766 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6767 | .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 6768 | .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6769 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 6770 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 6771 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6772 | } }, |
| 6773 | }, .{ |
| 6774 | .required_features = .{ .sse4_1, null, null, null }, |
| 6775 | .src_constraints = .{ |
| 6776 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6777 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 6778 | .any, |
| 6779 | }, |
| 6780 | .patterns = &.{ |
| 6781 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6782 | }, |
| 6783 | .extra_temps = .{ |
| 6784 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6785 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 6786 | .unused, |
| 6787 | .unused, |
| 6788 | .unused, |
| 6789 | .unused, |
| 6790 | .unused, |
| 6791 | .unused, |
| 6792 | .unused, |
| 6793 | }, |
| 6794 | .dst_temps = .{.mem}, |
| 6795 | .clobbers = .{ .eflags = true }, |
| 6796 | .each = .{ .once = &.{ |
| 6797 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6798 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6799 | .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6800 | .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6801 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 6802 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6803 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6804 | } }, |
| 6805 | }, .{ |
| 6806 | .required_features = .{ .sse2, null, null, null }, |
| 6807 | .src_constraints = .{ |
| 6808 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6809 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6810 | .any, |
| 6811 | }, |
| 6812 | .patterns = &.{ |
| 6813 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6814 | }, |
| 6815 | .call_frame = .{ .alignment = .@"16" }, |
| 6816 | .extra_temps = .{ |
| 6817 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6818 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 6819 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6820 | else => unreachable, |
| 6821 | .zero => "trunc", |
| 6822 | .down => "floor", |
| 6823 | } } } }, |
| 6824 | .unused, |
| 6825 | .unused, |
| 6826 | .unused, |
| 6827 | .unused, |
| 6828 | .unused, |
| 6829 | .unused, |
| 6830 | }, |
| 6831 | .dst_temps = .{.mem}, |
| 6832 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6833 | .each = .{ .once = &.{ |
| 6834 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6835 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6836 | .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6837 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 6838 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 6839 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 6840 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6841 | } }, |
| 6842 | }, .{ |
| 6843 | .required_features = .{ .sse, null, null, null }, |
| 6844 | .src_constraints = .{ |
| 6845 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6846 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 6847 | .any, |
| 6848 | }, |
| 6849 | .patterns = &.{ |
| 6850 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6851 | }, |
| 6852 | .call_frame = .{ .alignment = .@"16" }, |
| 6853 | .extra_temps = .{ |
| 6854 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6855 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 6856 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 6857 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } }, |
| 6858 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6859 | else => unreachable, |
| 6860 | .zero => "trunc", |
| 6861 | .down => "floor", |
| 6862 | } } } }, |
| 6863 | .unused, |
| 6864 | .unused, |
| 6865 | .unused, |
| 6866 | .unused, |
| 6867 | }, |
| 6868 | .dst_temps = .{.mem}, |
| 6869 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6870 | .each = .{ .once = &.{ |
| 6871 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6872 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6873 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6874 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6875 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6876 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6877 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6878 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 6879 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 6880 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6881 | } }, |
| 6882 | }, .{ |
| 6883 | .required_features = .{ .x87, null, null, null }, |
| 6884 | .src_constraints = .{ |
| 6885 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6886 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6887 | .any, |
| 6888 | }, |
| 6889 | .patterns = &.{ |
| 6890 | .{ .src = .{ .mem, .mem, .none } }, |
| 6891 | }, |
| 6892 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 6893 | .extra_temps = .{ |
| 6894 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 6895 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6896 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 6897 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6898 | else => unreachable, |
| 6899 | .zero => "__truncx", |
| 6900 | .down => "__floorx", |
| 6901 | } } } }, |
| 6902 | .unused, |
| 6903 | .unused, |
| 6904 | .unused, |
| 6905 | .unused, |
| 6906 | .unused, |
| 6907 | }, |
| 6908 | .dst_temps = .{.{ .reg = .st0 }}, |
| 6909 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6910 | .each = .{ .once = &.{ |
| 6911 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 6912 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 6913 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 6914 | .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ }, |
| 6915 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6916 | } }, |
| 6917 | }, .{ |
| 6918 | .required_features = .{ .x87, null, null, null }, |
| 6919 | .src_constraints = .{ |
| 6920 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6921 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6922 | .any, |
| 6923 | }, |
| 6924 | .patterns = &.{ |
| 6925 | .{ .src = .{ .to_x87, .mem, .none } }, |
| 6926 | }, |
| 6927 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 6928 | .extra_temps = .{ |
| 6929 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6930 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 6931 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6932 | else => unreachable, |
| 6933 | .zero => "__truncx", |
| 6934 | .down => "__floorx", |
| 6935 | } } } }, |
| 6936 | .unused, |
| 6937 | .unused, |
| 6938 | .unused, |
| 6939 | .unused, |
| 6940 | .unused, |
| 6941 | .unused, |
| 6942 | }, |
| 6943 | .dst_temps = .{.{ .reg = .st0 }}, |
| 6944 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6945 | .each = .{ .once = &.{ |
| 6946 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 6947 | .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ }, |
| 6948 | .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ }, |
| 6949 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 6950 | } }, |
| 6951 | }, .{ |
| 6952 | .required_features = .{ .x87, null, null, null }, |
| 6953 | .src_constraints = .{ |
| 6954 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6955 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6956 | .any, |
| 6957 | }, |
| 6958 | .patterns = &.{ |
| 6959 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 6960 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 6961 | }, |
| 6962 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 6963 | .extra_temps = .{ |
| 6964 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 6965 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 6966 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6967 | else => unreachable, |
| 6968 | .zero => "__truncx", |
| 6969 | .down => "__floorx", |
| 6970 | } } } }, |
| 6971 | .unused, |
| 6972 | .unused, |
| 6973 | .unused, |
| 6974 | .unused, |
| 6975 | .unused, |
| 6976 | .unused, |
| 6977 | }, |
| 6978 | .dst_temps = .{.{ .reg = .st0 }}, |
| 6979 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6980 | .each = .{ .once = &.{ |
| 6981 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 6982 | .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ }, |
| 6983 | .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ }, |
| 6984 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 6985 | } }, |
| 6986 | }, .{ |
| 6987 | .required_features = .{ .x87, null, null, null }, |
| 6988 | .src_constraints = .{ |
| 6989 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6990 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 6991 | .any, |
| 6992 | }, |
| 6993 | .patterns = &.{ |
| 6994 | .{ .src = .{ .mem, .mem, .none } }, |
| 6995 | }, |
| 6996 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 6997 | .extra_temps = .{ |
| 6998 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6999 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 7000 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 7001 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 7002 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7003 | else => unreachable, |
| 7004 | .zero => "__truncx", |
| 7005 | .down => "__floorx", |
| 7006 | } } } }, |
| 7007 | .unused, |
| 7008 | .unused, |
| 7009 | .unused, |
| 7010 | .unused, |
| 7011 | }, |
| 7012 | .dst_temps = .{.mem}, |
| 7013 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7014 | .each = .{ .once = &.{ |
| 7015 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7016 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 7017 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 7018 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 7019 | .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ }, |
| 7020 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7021 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 7022 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 7023 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7024 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7025 | } }, |
| 7026 | }, .{ |
| 7027 | .required_features = .{ .sse, null, null, null }, |
| 7028 | .src_constraints = .{ |
| 7029 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7030 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7031 | .any, |
| 7032 | }, |
| 7033 | .patterns = &.{ |
| 7034 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 7035 | }, |
| 7036 | .call_frame = .{ .alignment = .@"16" }, |
| 7037 | .extra_temps = .{ |
| 7038 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 7039 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7040 | else => unreachable, |
| 7041 | .zero => "truncq", |
| 7042 | .down => "floorq", |
| 7043 | } } } }, |
| 7044 | .unused, |
| 7045 | .unused, |
| 7046 | .unused, |
| 7047 | .unused, |
| 7048 | .unused, |
| 7049 | .unused, |
| 7050 | .unused, |
| 7051 | }, |
| 7052 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7053 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7054 | .each = .{ .once = &.{ |
| 7055 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7056 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 7057 | } }, |
| 7058 | }, .{ |
| 7059 | .required_features = .{ .avx, null, null, null }, |
| 7060 | .src_constraints = .{ |
| 7061 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7062 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7063 | .any, |
| 7064 | }, |
| 7065 | .patterns = &.{ |
| 7066 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7067 | }, |
| 7068 | .call_frame = .{ .alignment = .@"16" }, |
| 7069 | .extra_temps = .{ |
| 7070 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7071 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 7072 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 7073 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 7074 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7075 | else => unreachable, |
| 7076 | .zero => "truncq", |
| 7077 | .down => "floorq", |
| 7078 | } } } }, |
| 7079 | .unused, |
| 7080 | .unused, |
| 7081 | .unused, |
| 7082 | .unused, |
| 7083 | }, |
| 7084 | .dst_temps = .{.mem}, |
| 7085 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7086 | .each = .{ .once = &.{ |
| 7087 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7088 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7089 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7090 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 7091 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7092 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7093 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7094 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7095 | } }, |
| 7096 | }, .{ |
| 7097 | .required_features = .{ .sse2, null, null, null }, |
| 7098 | .src_constraints = .{ |
| 7099 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7100 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7101 | .any, |
| 7102 | }, |
| 7103 | .patterns = &.{ |
| 7104 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7105 | }, |
| 7106 | .call_frame = .{ .alignment = .@"16" }, |
| 7107 | .extra_temps = .{ |
| 7108 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7109 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 7110 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 7111 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 7112 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7113 | else => unreachable, |
| 7114 | .zero => "truncq", |
| 7115 | .down => "floorq", |
| 7116 | } } } }, |
| 7117 | .unused, |
| 7118 | .unused, |
| 7119 | .unused, |
| 7120 | .unused, |
| 7121 | }, |
| 7122 | .dst_temps = .{.mem}, |
| 7123 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7124 | .each = .{ .once = &.{ |
| 7125 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7126 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7127 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7128 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 7129 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7130 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7131 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7132 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7133 | } }, |
| 7134 | }, .{ |
| 7135 | .required_features = .{ .sse, null, null, null }, |
| 7136 | .src_constraints = .{ |
| 7137 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7138 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 7139 | .any, |
| 7140 | }, |
| 7141 | .patterns = &.{ |
| 7142 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7143 | }, |
| 7144 | .call_frame = .{ .alignment = .@"16" }, |
| 7145 | .extra_temps = .{ |
| 7146 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7147 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 7148 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 7149 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 7150 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7151 | else => unreachable, |
| 7152 | .zero => "truncq", |
| 7153 | .down => "floorq", |
| 7154 | } } } }, |
| 7155 | .unused, |
| 7156 | .unused, |
| 7157 | .unused, |
| 7158 | .unused, |
| 7159 | }, |
| 7160 | .dst_temps = .{.mem}, |
| 7161 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7162 | .each = .{ .once = &.{ |
| 7163 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7164 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7165 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7166 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 7167 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7168 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7169 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7170 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7171 | } }, |
| 7172 | } }, |
| 7173 | }) catch |err| switch (err) { |
| 7174 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 7175 | @tagName(air_tag), |
| 7176 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 7177 | ops[0].tracking(cg), |
| 7178 | ops[1].tracking(cg), |
| 7179 | }), |
| 7180 | else => |e| return e, |
| 7181 | }; |
| 7182 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 7183 | }, |
| 7184 | .div_trunc_optimized, .div_floor_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) { |
| 7185 | else => unreachable, |
| 7186 | .div_trunc_optimized => .div_trunc, |
| 7187 | .div_floor_optimized => .div_floor, |
| 7188 | }) else { |
| 7189 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 7190 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 7191 | var res: [1]Temp = undefined; |
| 7192 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) { |
| 7193 | else => unreachable, |
| 7194 | .div_trunc_optimized => .zero, |
| 7195 | .div_floor_optimized => .down, |
| 7196 | })) { |
| 7197 | else => unreachable, |
| 7198 | inline .zero, .down => |direction| comptime &.{ .{ |
| 7199 | .required_features = .{ .f16c, null, null, null }, |
| 7200 | .src_constraints = .{ |
| 7201 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 7202 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 7203 | .any, |
| 7204 | }, |
| 7205 | .patterns = &.{ |
| 7206 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7207 | }, |
| 7208 | .extra_temps = .{ |
| 7209 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 7210 | .unused, |
| 7211 | .unused, |
| 7212 | .unused, |
| 7213 | .unused, |
| 7214 | .unused, |
| 7215 | .unused, |
| 7216 | .unused, |
| 7217 | .unused, |
| 7218 | }, |
| 7219 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7220 | .each = .{ .once = &.{ |
| 7221 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 7222 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 7223 | .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ }, |
| 7224 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 7225 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 7226 | } }, |
| 7227 | }, .{ |
| 7228 | .required_features = .{ .sse, null, null, null }, |
| 7229 | .src_constraints = .{ |
| 7230 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 7231 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 7232 | .any, |
| 7233 | }, |
| 7234 | .patterns = &.{ |
| 7235 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 7236 | }, |
| 7237 | .call_frame = .{ .alignment = .@"16" }, |
| 7238 | .extra_temps = .{ |
| 7239 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 7240 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7241 | else => unreachable, |
| 7242 | .zero => "__trunch", |
| 7243 | .down => "__floorh", |
| 7244 | } } } }, |
| 7245 | .unused, |
| 7246 | .unused, |
| 7247 | .unused, |
| 7248 | .unused, |
| 7249 | .unused, |
| 7250 | .unused, |
| 7251 | .unused, |
| 7252 | }, |
| 7253 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7254 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7255 | .each = .{ .once = &.{ |
| 7256 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7257 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 7258 | } }, |
| 7259 | }, .{ |
| 7260 | .required_features = .{ .f16c, null, null, null }, |
| 7261 | .src_constraints = .{ |
| 7262 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 7263 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 7264 | .any, |
| 7265 | }, |
| 7266 | .patterns = &.{ |
| 7267 | .{ .src = .{ .mem, .mem, .none } }, |
| 7268 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7269 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 7270 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7271 | }, |
| 7272 | .extra_temps = .{ |
| 7273 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 7274 | .unused, |
| 7275 | .unused, |
| 7276 | .unused, |
| 7277 | .unused, |
| 7278 | .unused, |
| 7279 | .unused, |
| 7280 | .unused, |
| 7281 | .unused, |
| 7282 | }, |
| 7283 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7284 | .each = .{ .once = &.{ |
| 7285 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 7286 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 7287 | .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ }, |
| 7288 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7289 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 7290 | } }, |
| 7291 | }, .{ |
| 7292 | .required_features = .{ .f16c, null, null, null }, |
| 7293 | .src_constraints = .{ |
| 7294 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 7295 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 7296 | .any, |
| 7297 | }, |
| 7298 | .patterns = &.{ |
| 7299 | .{ .src = .{ .mem, .mem, .none } }, |
| 7300 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7301 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 7302 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7303 | }, |
| 7304 | .extra_temps = .{ |
| 7305 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 7306 | .unused, |
| 7307 | .unused, |
| 7308 | .unused, |
| 7309 | .unused, |
| 7310 | .unused, |
| 7311 | .unused, |
| 7312 | .unused, |
| 7313 | .unused, |
| 7314 | }, |
| 7315 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7316 | .each = .{ .once = &.{ |
| 7317 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 7318 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 7319 | .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ }, |
| 7320 | .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7321 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 7322 | } }, |
| 7323 | }, .{ |
| 7324 | .required_features = .{ .f16c, null, null, null }, |
| 7325 | .src_constraints = .{ |
| 7326 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 7327 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 7328 | .any, |
| 7329 | }, |
| 7330 | .patterns = &.{ |
| 7331 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7332 | }, |
| 7333 | .extra_temps = .{ |
| 7334 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7335 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 7336 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 7337 | .unused, |
| 7338 | .unused, |
| 7339 | .unused, |
| 7340 | .unused, |
| 7341 | .unused, |
| 7342 | .unused, |
| 7343 | }, |
| 7344 | .dst_temps = .{.mem}, |
| 7345 | .clobbers = .{ .eflags = true }, |
| 7346 | .each = .{ .once = &.{ |
| 7347 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7348 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7349 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7350 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 7351 | .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7352 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 7353 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7354 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7355 | } }, |
| 7356 | }, .{ |
| 7357 | .required_features = .{ .avx, null, null, null }, |
| 7358 | .src_constraints = .{ |
| 7359 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7360 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7361 | .any, |
| 7362 | }, |
| 7363 | .patterns = &.{ |
| 7364 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7365 | }, |
| 7366 | .call_frame = .{ .alignment = .@"16" }, |
| 7367 | .extra_temps = .{ |
| 7368 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7369 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 7370 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 7371 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 7372 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7373 | else => unreachable, |
| 7374 | .zero => "__trunch", |
| 7375 | .down => "__floorh", |
| 7376 | } } } }, |
| 7377 | .unused, |
| 7378 | .unused, |
| 7379 | .unused, |
| 7380 | .unused, |
| 7381 | }, |
| 7382 | .dst_temps = .{.mem}, |
| 7383 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7384 | .each = .{ .once = &.{ |
| 7385 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7386 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 7387 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 7388 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 7389 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 7390 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7391 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 7392 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 7393 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7394 | } }, |
| 7395 | }, .{ |
| 7396 | .required_features = .{ .sse4_1, null, null, null }, |
| 7397 | .src_constraints = .{ |
| 7398 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7399 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7400 | .any, |
| 7401 | }, |
| 7402 | .patterns = &.{ |
| 7403 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7404 | }, |
| 7405 | .call_frame = .{ .alignment = .@"16" }, |
| 7406 | .extra_temps = .{ |
| 7407 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7408 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 7409 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 7410 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 7411 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7412 | else => unreachable, |
| 7413 | .zero => "__trunch", |
| 7414 | .down => "__floorh", |
| 7415 | } } } }, |
| 7416 | .unused, |
| 7417 | .unused, |
| 7418 | .unused, |
| 7419 | .unused, |
| 7420 | }, |
| 7421 | .dst_temps = .{.mem}, |
| 7422 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7423 | .each = .{ .once = &.{ |
| 7424 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7425 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 7426 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 7427 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 7428 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 7429 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 7430 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7431 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 7432 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 7433 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7434 | } }, |
| 7435 | }, .{ |
| 7436 | .required_features = .{ .sse2, null, null, null }, |
| 7437 | .src_constraints = .{ |
| 7438 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7439 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7440 | .any, |
| 7441 | }, |
| 7442 | .patterns = &.{ |
| 7443 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7444 | }, |
| 7445 | .call_frame = .{ .alignment = .@"16" }, |
| 7446 | .extra_temps = .{ |
| 7447 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7448 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 7449 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 7450 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 7451 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7452 | else => unreachable, |
| 7453 | .zero => "__trunch", |
| 7454 | .down => "__floorh", |
| 7455 | } } } }, |
| 7456 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 7457 | .unused, |
| 7458 | .unused, |
| 7459 | .unused, |
| 7460 | }, |
| 7461 | .dst_temps = .{.mem}, |
| 7462 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7463 | .each = .{ .once = &.{ |
| 7464 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7465 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 7466 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 7467 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 7468 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 7469 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 7470 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 7471 | .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ }, |
| 7472 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ }, |
| 7473 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 7474 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7475 | } }, |
| 7476 | }, .{ |
| 7477 | .required_features = .{ .sse, null, null, null }, |
| 7478 | .src_constraints = .{ |
| 7479 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7480 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 7481 | .any, |
| 7482 | }, |
| 7483 | .patterns = &.{ |
| 7484 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7485 | }, |
| 7486 | .call_frame = .{ .alignment = .@"16" }, |
| 7487 | .extra_temps = .{ |
| 7488 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7489 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 7490 | .{ .type = .f32, .kind = .mem }, |
| 7491 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 7492 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 7493 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 7494 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7495 | else => unreachable, |
| 7496 | .zero => "__trunch", |
| 7497 | .down => "__floorh", |
| 7498 | } } } }, |
| 7499 | .unused, |
| 7500 | .unused, |
| 7501 | }, |
| 7502 | .dst_temps = .{.mem}, |
| 7503 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7504 | .each = .{ .once = &.{ |
| 7505 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7506 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7507 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 7508 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 7509 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7510 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 7511 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 7512 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 7513 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 7514 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 7515 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 7516 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 7517 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 7518 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7519 | } }, |
| 7520 | }, .{ |
| 7521 | .required_features = .{ .avx, null, null, null }, |
| 7522 | .src_constraints = .{ |
| 7523 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7524 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7525 | .any, |
| 7526 | }, |
| 7527 | .patterns = &.{ |
| 7528 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7529 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7530 | }, |
| 7531 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7532 | .each = .{ .once = &.{ |
| 7533 | .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ }, |
| 7534 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 7535 | } }, |
| 7536 | }, .{ |
| 7537 | .required_features = .{ .sse4_1, null, null, null }, |
| 7538 | .src_constraints = .{ |
| 7539 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7540 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7541 | .any, |
| 7542 | }, |
| 7543 | .patterns = &.{ |
| 7544 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7545 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7546 | }, |
| 7547 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7548 | .each = .{ .once = &.{ |
| 7549 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 7550 | .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7551 | } }, |
| 7552 | }, .{ |
| 7553 | .required_features = .{ .sse, null, null, null }, |
| 7554 | .src_constraints = .{ |
| 7555 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7556 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7557 | .any, |
| 7558 | }, |
| 7559 | .patterns = &.{ |
| 7560 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, |
| 7561 | }, |
| 7562 | .call_frame = .{ .alignment = .@"16" }, |
| 7563 | .extra_temps = .{ |
| 7564 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7565 | else => unreachable, |
| 7566 | .zero => "truncf", |
| 7567 | .down => "floorf", |
| 7568 | } } } }, |
| 7569 | .unused, |
| 7570 | .unused, |
| 7571 | .unused, |
| 7572 | .unused, |
| 7573 | .unused, |
| 7574 | .unused, |
| 7575 | .unused, |
| 7576 | .unused, |
| 7577 | }, |
| 7578 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7579 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7580 | .each = .{ .once = &.{ |
| 7581 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 7582 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7583 | } }, |
| 7584 | }, .{ |
| 7585 | .required_features = .{ .avx, null, null, null }, |
| 7586 | .src_constraints = .{ |
| 7587 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7588 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7589 | .any, |
| 7590 | }, |
| 7591 | .patterns = &.{ |
| 7592 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7593 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7594 | }, |
| 7595 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7596 | .each = .{ .once = &.{ |
| 7597 | .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ }, |
| 7598 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7599 | } }, |
| 7600 | }, .{ |
| 7601 | .required_features = .{ .sse4_1, null, null, null }, |
| 7602 | .src_constraints = .{ |
| 7603 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7604 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7605 | .any, |
| 7606 | }, |
| 7607 | .patterns = &.{ |
| 7608 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7609 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7610 | }, |
| 7611 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7612 | .each = .{ .once = &.{ |
| 7613 | .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ }, |
| 7614 | .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7615 | } }, |
| 7616 | }, .{ |
| 7617 | .required_features = .{ .sse, null, null, null }, |
| 7618 | .src_constraints = .{ |
| 7619 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7620 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7621 | .any, |
| 7622 | }, |
| 7623 | .patterns = &.{ |
| 7624 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7625 | }, |
| 7626 | .call_frame = .{ .alignment = .@"16" }, |
| 7627 | .extra_temps = .{ |
| 7628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7629 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 7630 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7631 | else => unreachable, |
| 7632 | .zero => "truncf", |
| 7633 | .down => "floorf", |
| 7634 | } } } }, |
| 7635 | .unused, |
| 7636 | .unused, |
| 7637 | .unused, |
| 7638 | .unused, |
| 7639 | .unused, |
| 7640 | .unused, |
| 7641 | }, |
| 7642 | .dst_temps = .{.mem}, |
| 7643 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7644 | .each = .{ .once = &.{ |
| 7645 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7646 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7647 | .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7648 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 7649 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7650 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 7651 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7652 | } }, |
| 7653 | }, .{ |
| 7654 | .required_features = .{ .avx, null, null, null }, |
| 7655 | .src_constraints = .{ |
| 7656 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 7657 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 7658 | .any, |
| 7659 | }, |
| 7660 | .patterns = &.{ |
| 7661 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7662 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7663 | }, |
| 7664 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7665 | .each = .{ .once = &.{ |
| 7666 | .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ }, |
| 7667 | .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7668 | } }, |
| 7669 | }, .{ |
| 7670 | .required_features = .{ .avx, null, null, null }, |
| 7671 | .src_constraints = .{ |
| 7672 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 7673 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 7674 | .any, |
| 7675 | }, |
| 7676 | .patterns = &.{ |
| 7677 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7678 | }, |
| 7679 | .extra_temps = .{ |
| 7680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7681 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 7682 | .unused, |
| 7683 | .unused, |
| 7684 | .unused, |
| 7685 | .unused, |
| 7686 | .unused, |
| 7687 | .unused, |
| 7688 | .unused, |
| 7689 | }, |
| 7690 | .dst_temps = .{.mem}, |
| 7691 | .clobbers = .{ .eflags = true }, |
| 7692 | .each = .{ .once = &.{ |
| 7693 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7694 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7695 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 7696 | .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7697 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 7698 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 7699 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7700 | } }, |
| 7701 | }, .{ |
| 7702 | .required_features = .{ .sse4_1, null, null, null }, |
| 7703 | .src_constraints = .{ |
| 7704 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7705 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7706 | .any, |
| 7707 | }, |
| 7708 | .patterns = &.{ |
| 7709 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7710 | }, |
| 7711 | .extra_temps = .{ |
| 7712 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7713 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 7714 | .unused, |
| 7715 | .unused, |
| 7716 | .unused, |
| 7717 | .unused, |
| 7718 | .unused, |
| 7719 | .unused, |
| 7720 | .unused, |
| 7721 | }, |
| 7722 | .dst_temps = .{.mem}, |
| 7723 | .clobbers = .{ .eflags = true }, |
| 7724 | .each = .{ .once = &.{ |
| 7725 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7726 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7727 | .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7728 | .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7729 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7730 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7731 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7732 | } }, |
| 7733 | }, .{ |
| 7734 | .required_features = .{ .avx, null, null, null }, |
| 7735 | .src_constraints = .{ |
| 7736 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7737 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7738 | .any, |
| 7739 | }, |
| 7740 | .patterns = &.{ |
| 7741 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7742 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7743 | }, |
| 7744 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7745 | .each = .{ .once = &.{ |
| 7746 | .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ }, |
| 7747 | .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 7748 | } }, |
| 7749 | }, .{ |
| 7750 | .required_features = .{ .sse4_1, null, null, null }, |
| 7751 | .src_constraints = .{ |
| 7752 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7753 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7754 | .any, |
| 7755 | }, |
| 7756 | .patterns = &.{ |
| 7757 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7758 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7759 | }, |
| 7760 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7761 | .each = .{ .once = &.{ |
| 7762 | .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ }, |
| 7763 | .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7764 | } }, |
| 7765 | }, .{ |
| 7766 | .required_features = .{ .sse2, null, null, null }, |
| 7767 | .src_constraints = .{ |
| 7768 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7769 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7770 | .any, |
| 7771 | }, |
| 7772 | .patterns = &.{ |
| 7773 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, |
| 7774 | }, |
| 7775 | .call_frame = .{ .alignment = .@"16" }, |
| 7776 | .extra_temps = .{ |
| 7777 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7778 | else => unreachable, |
| 7779 | .zero => "trunc", |
| 7780 | .down => "floor", |
| 7781 | } } } }, |
| 7782 | .unused, |
| 7783 | .unused, |
| 7784 | .unused, |
| 7785 | .unused, |
| 7786 | .unused, |
| 7787 | .unused, |
| 7788 | .unused, |
| 7789 | .unused, |
| 7790 | }, |
| 7791 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7792 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7793 | .each = .{ .once = &.{ |
| 7794 | .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ }, |
| 7795 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7796 | } }, |
| 7797 | }, .{ |
| 7798 | .required_features = .{ .sse, null, null, null }, |
| 7799 | .src_constraints = .{ |
| 7800 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7801 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7802 | .any, |
| 7803 | }, |
| 7804 | .patterns = &.{ |
| 7805 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 7806 | }, |
| 7807 | .call_frame = .{ .alignment = .@"16" }, |
| 7808 | .extra_temps = .{ |
| 7809 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } }, |
| 7810 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7811 | else => unreachable, |
| 7812 | .zero => "trunc", |
| 7813 | .down => "floor", |
| 7814 | } } } }, |
| 7815 | .unused, |
| 7816 | .unused, |
| 7817 | .unused, |
| 7818 | .unused, |
| 7819 | .unused, |
| 7820 | .unused, |
| 7821 | .unused, |
| 7822 | }, |
| 7823 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7824 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7825 | .each = .{ .once = &.{ |
| 7826 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7827 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 7828 | } }, |
| 7829 | }, .{ |
| 7830 | .required_features = .{ .avx, null, null, null }, |
| 7831 | .src_constraints = .{ |
| 7832 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 7833 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 7834 | .any, |
| 7835 | }, |
| 7836 | .patterns = &.{ |
| 7837 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7838 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7839 | }, |
| 7840 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7841 | .each = .{ .once = &.{ |
| 7842 | .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ }, |
| 7843 | .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7844 | } }, |
| 7845 | }, .{ |
| 7846 | .required_features = .{ .sse4_1, null, null, null }, |
| 7847 | .src_constraints = .{ |
| 7848 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 7849 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 7850 | .any, |
| 7851 | }, |
| 7852 | .patterns = &.{ |
| 7853 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7854 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7855 | }, |
| 7856 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7857 | .each = .{ .once = &.{ |
| 7858 | .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ }, |
| 7859 | .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7860 | } }, |
| 7861 | }, .{ |
| 7862 | .required_features = .{ .avx, null, null, null }, |
| 7863 | .src_constraints = .{ |
| 7864 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 7865 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 7866 | .any, |
| 7867 | }, |
| 7868 | .patterns = &.{ |
| 7869 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7870 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7871 | }, |
| 7872 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7873 | .each = .{ .once = &.{ |
| 7874 | .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ }, |
| 7875 | .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7876 | } }, |
| 7877 | }, .{ |
| 7878 | .required_features = .{ .avx, null, null, null }, |
| 7879 | .src_constraints = .{ |
| 7880 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 7881 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 7882 | .any, |
| 7883 | }, |
| 7884 | .patterns = &.{ |
| 7885 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7886 | }, |
| 7887 | .extra_temps = .{ |
| 7888 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7889 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 7890 | .unused, |
| 7891 | .unused, |
| 7892 | .unused, |
| 7893 | .unused, |
| 7894 | .unused, |
| 7895 | .unused, |
| 7896 | .unused, |
| 7897 | }, |
| 7898 | .dst_temps = .{.mem}, |
| 7899 | .clobbers = .{ .eflags = true }, |
| 7900 | .each = .{ .once = &.{ |
| 7901 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7902 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7903 | .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 7904 | .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7905 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 7906 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 7907 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7908 | } }, |
| 7909 | }, .{ |
| 7910 | .required_features = .{ .sse4_1, null, null, null }, |
| 7911 | .src_constraints = .{ |
| 7912 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 7913 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 7914 | .any, |
| 7915 | }, |
| 7916 | .patterns = &.{ |
| 7917 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7918 | }, |
| 7919 | .extra_temps = .{ |
| 7920 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7921 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 7922 | .unused, |
| 7923 | .unused, |
| 7924 | .unused, |
| 7925 | .unused, |
| 7926 | .unused, |
| 7927 | .unused, |
| 7928 | .unused, |
| 7929 | }, |
| 7930 | .dst_temps = .{.mem}, |
| 7931 | .clobbers = .{ .eflags = true }, |
| 7932 | .each = .{ .once = &.{ |
| 7933 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7934 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7935 | .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7936 | .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7937 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7938 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7939 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7940 | } }, |
| 7941 | }, .{ |
| 7942 | .required_features = .{ .sse2, null, null, null }, |
| 7943 | .src_constraints = .{ |
| 7944 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7945 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7946 | .any, |
| 7947 | }, |
| 7948 | .patterns = &.{ |
| 7949 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7950 | }, |
| 7951 | .call_frame = .{ .alignment = .@"16" }, |
| 7952 | .extra_temps = .{ |
| 7953 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7954 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 7955 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7956 | else => unreachable, |
| 7957 | .zero => "trunc", |
| 7958 | .down => "floor", |
| 7959 | } } } }, |
| 7960 | .unused, |
| 7961 | .unused, |
| 7962 | .unused, |
| 7963 | .unused, |
| 7964 | .unused, |
| 7965 | .unused, |
| 7966 | }, |
| 7967 | .dst_temps = .{.mem}, |
| 7968 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7969 | .each = .{ .once = &.{ |
| 7970 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7971 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7972 | .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 7973 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 7974 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 7975 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 7976 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7977 | } }, |
| 7978 | }, .{ |
| 7979 | .required_features = .{ .sse, null, null, null }, |
| 7980 | .src_constraints = .{ |
| 7981 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7982 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 7983 | .any, |
| 7984 | }, |
| 7985 | .patterns = &.{ |
| 7986 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7987 | }, |
| 7988 | .call_frame = .{ .alignment = .@"16" }, |
| 7989 | .extra_temps = .{ |
| 7990 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 7991 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 7992 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 7993 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } }, |
| 7994 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7995 | else => unreachable, |
| 7996 | .zero => "trunc", |
| 7997 | .down => "floor", |
| 7998 | } } } }, |
| 7999 | .unused, |
| 8000 | .unused, |
| 8001 | .unused, |
| 8002 | .unused, |
| 8003 | }, |
| 8004 | .dst_temps = .{.mem}, |
| 8005 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8006 | .each = .{ .once = &.{ |
| 8007 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8008 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 8009 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 8010 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8011 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8012 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8013 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8014 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8015 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 8016 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8017 | } }, |
| 8018 | }, .{ |
| 8019 | .required_features = .{ .x87, null, null, null }, |
| 8020 | .src_constraints = .{ |
| 8021 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8022 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8023 | .any, |
| 8024 | }, |
| 8025 | .patterns = &.{ |
| 8026 | .{ .src = .{ .mem, .mem, .none } }, |
| 8027 | }, |
| 8028 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 8029 | .extra_temps = .{ |
| 8030 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 8031 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 8032 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8033 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8034 | else => unreachable, |
| 8035 | .zero => "__truncx", |
| 8036 | .down => "__floorx", |
| 8037 | } } } }, |
| 8038 | .unused, |
| 8039 | .unused, |
| 8040 | .unused, |
| 8041 | .unused, |
| 8042 | .unused, |
| 8043 | }, |
| 8044 | .dst_temps = .{.{ .reg = .st0 }}, |
| 8045 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8046 | .each = .{ .once = &.{ |
| 8047 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 8048 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 8049 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 8050 | .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ }, |
| 8051 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8052 | } }, |
| 8053 | }, .{ |
| 8054 | .required_features = .{ .x87, null, null, null }, |
| 8055 | .src_constraints = .{ |
| 8056 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8057 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8058 | .any, |
| 8059 | }, |
| 8060 | .patterns = &.{ |
| 8061 | .{ .src = .{ .to_x87, .mem, .none } }, |
| 8062 | }, |
| 8063 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 8064 | .extra_temps = .{ |
| 8065 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 8066 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8067 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8068 | else => unreachable, |
| 8069 | .zero => "__truncx", |
| 8070 | .down => "__floorx", |
| 8071 | } } } }, |
| 8072 | .unused, |
| 8073 | .unused, |
| 8074 | .unused, |
| 8075 | .unused, |
| 8076 | .unused, |
| 8077 | .unused, |
| 8078 | }, |
| 8079 | .dst_temps = .{.{ .reg = .st0 }}, |
| 8080 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8081 | .each = .{ .once = &.{ |
| 8082 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 8083 | .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ }, |
| 8084 | .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ }, |
| 8085 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 8086 | } }, |
| 8087 | }, .{ |
| 8088 | .required_features = .{ .x87, null, null, null }, |
| 8089 | .src_constraints = .{ |
| 8090 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8091 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8092 | .any, |
| 8093 | }, |
| 8094 | .patterns = &.{ |
| 8095 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 8096 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 8097 | }, |
| 8098 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 8099 | .extra_temps = .{ |
| 8100 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 8101 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8102 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8103 | else => unreachable, |
| 8104 | .zero => "__truncx", |
| 8105 | .down => "__floorx", |
| 8106 | } } } }, |
| 8107 | .unused, |
| 8108 | .unused, |
| 8109 | .unused, |
| 8110 | .unused, |
| 8111 | .unused, |
| 8112 | .unused, |
| 8113 | }, |
| 8114 | .dst_temps = .{.{ .reg = .st0 }}, |
| 8115 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8116 | .each = .{ .once = &.{ |
| 8117 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 8118 | .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ }, |
| 8119 | .{ ._, .f_p, .st, .mem(.tmp1t), ._, ._, ._ }, |
| 8120 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 8121 | } }, |
| 8122 | }, .{ |
| 8123 | .required_features = .{ .x87, null, null, null }, |
| 8124 | .src_constraints = .{ |
| 8125 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8126 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8127 | .any, |
| 8128 | }, |
| 8129 | .patterns = &.{ |
| 8130 | .{ .src = .{ .mem, .mem, .none } }, |
| 8131 | }, |
| 8132 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 8133 | .extra_temps = .{ |
| 8134 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8135 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 8136 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 8137 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8138 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8139 | else => unreachable, |
| 8140 | .zero => "__truncx", |
| 8141 | .down => "__floorx", |
| 8142 | } } } }, |
| 8143 | .unused, |
| 8144 | .unused, |
| 8145 | .unused, |
| 8146 | .unused, |
| 8147 | }, |
| 8148 | .dst_temps = .{.mem}, |
| 8149 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8150 | .each = .{ .once = &.{ |
| 8151 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8152 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8153 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8154 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 8155 | .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ }, |
| 8156 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8157 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 8158 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8159 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8160 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8161 | } }, |
| 8162 | }, .{ |
| 8163 | .required_features = .{ .sse, null, null, null }, |
| 8164 | .src_constraints = .{ |
| 8165 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8166 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8167 | .any, |
| 8168 | }, |
| 8169 | .patterns = &.{ |
| 8170 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 8171 | }, |
| 8172 | .call_frame = .{ .alignment = .@"16" }, |
| 8173 | .extra_temps = .{ |
| 8174 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 8175 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8176 | else => unreachable, |
| 8177 | .zero => "truncq", |
| 8178 | .down => "floorq", |
| 8179 | } } } }, |
| 8180 | .unused, |
| 8181 | .unused, |
| 8182 | .unused, |
| 8183 | .unused, |
| 8184 | .unused, |
| 8185 | .unused, |
| 8186 | .unused, |
| 8187 | }, |
| 8188 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8189 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8190 | .each = .{ .once = &.{ |
| 8191 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8192 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 8193 | } }, |
| 8194 | }, .{ |
| 8195 | .required_features = .{ .avx, null, null, null }, |
| 8196 | .src_constraints = .{ |
| 8197 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8198 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8199 | .any, |
| 8200 | }, |
| 8201 | .patterns = &.{ |
| 8202 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8203 | }, |
| 8204 | .call_frame = .{ .alignment = .@"16" }, |
| 8205 | .extra_temps = .{ |
| 8206 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8207 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 8208 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 8209 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 8210 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8211 | else => unreachable, |
| 8212 | .zero => "truncq", |
| 8213 | .down => "floorq", |
| 8214 | } } } }, |
| 8215 | .unused, |
| 8216 | .unused, |
| 8217 | .unused, |
| 8218 | .unused, |
| 8219 | }, |
| 8220 | .dst_temps = .{.mem}, |
| 8221 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8222 | .each = .{ .once = &.{ |
| 8223 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8224 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8225 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8226 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8227 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8228 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8229 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8230 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8231 | } }, |
| 8232 | }, .{ |
| 8233 | .required_features = .{ .sse2, null, null, null }, |
| 8234 | .src_constraints = .{ |
| 8235 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8236 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8237 | .any, |
| 8238 | }, |
| 8239 | .patterns = &.{ |
| 8240 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8241 | }, |
| 8242 | .call_frame = .{ .alignment = .@"16" }, |
| 8243 | .extra_temps = .{ |
| 8244 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8245 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 8246 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 8247 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 8248 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8249 | else => unreachable, |
| 8250 | .zero => "truncq", |
| 8251 | .down => "floorq", |
| 8252 | } } } }, |
| 8253 | .unused, |
| 8254 | .unused, |
| 8255 | .unused, |
| 8256 | .unused, |
| 8257 | }, |
| 8258 | .dst_temps = .{.mem}, |
| 8259 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8260 | .each = .{ .once = &.{ |
| 8261 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8262 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8263 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8264 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8265 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8266 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8267 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8268 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8269 | } }, |
| 8270 | }, .{ |
| 8271 | .required_features = .{ .sse, null, null, null }, |
| 8272 | .src_constraints = .{ |
| 8273 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8274 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8275 | .any, |
| 8276 | }, |
| 8277 | .patterns = &.{ |
| 8278 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8279 | }, |
| 8280 | .call_frame = .{ .alignment = .@"16" }, |
| 8281 | .extra_temps = .{ |
| 8282 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8283 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 8284 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 8285 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 8286 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 8287 | else => unreachable, |
| 8288 | .zero => "truncq", |
| 8289 | .down => "floorq", |
| 8290 | } } } }, |
| 8291 | .unused, |
| 8292 | .unused, |
| 8293 | .unused, |
| 8294 | .unused, |
| 8295 | }, |
| 8296 | .dst_temps = .{.mem}, |
| 8297 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8298 | .each = .{ .once = &.{ |
| 8299 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8300 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8301 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8302 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8303 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8304 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8305 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8306 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8307 | } }, |
| 8308 | } }, |
| 8309 | }) catch |err| switch (err) { |
| 8310 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 8311 | @tagName(air_tag), |
| 8312 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 8313 | ops[0].tracking(cg), |
| 8314 | ops[1].tracking(cg), |
| 8315 | }), |
| 8316 | else => |e| return e, |
| 8317 | }; |
| 8318 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 8319 | }, |
| 8320 | .rem, .rem_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .rem) else fallback: { |
| 8321 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 8322 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, .rem); |
| 8323 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 8324 | var res: [1]Temp = undefined; |
| 8325 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 8326 | .required_features = .{ .sse, null, null, null }, |
| 8327 | .src_constraints = .{ |
| 8328 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 8329 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 8330 | .any, |
| 8331 | }, |
| 8332 | .patterns = &.{ |
| 8333 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 8334 | }, |
| 8335 | .call_frame = .{ .alignment = .@"16" }, |
| 8336 | .extra_temps = .{ |
| 8337 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } }, |
| 8338 | .unused, |
| 8339 | .unused, |
| 8340 | .unused, |
| 8341 | .unused, |
| 8342 | .unused, |
| 8343 | .unused, |
| 8344 | .unused, |
| 8345 | .unused, |
| 8346 | }, |
| 8347 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8348 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8349 | .each = .{ .once = &.{ |
| 8350 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8351 | } }, |
| 8352 | }, .{ |
| 8353 | .required_features = .{ .avx, null, null, null }, |
| 8354 | .src_constraints = .{ |
| 8355 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8356 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8357 | .any, |
| 8358 | }, |
| 8359 | .patterns = &.{ |
| 8360 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8361 | }, |
| 8362 | .call_frame = .{ .alignment = .@"16" }, |
| 8363 | .extra_temps = .{ |
| 8364 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8365 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 8366 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 8367 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } }, |
| 8368 | .unused, |
| 8369 | .unused, |
| 8370 | .unused, |
| 8371 | .unused, |
| 8372 | .unused, |
| 8373 | }, |
| 8374 | .dst_temps = .{.mem}, |
| 8375 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8376 | .each = .{ .once = &.{ |
| 8377 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8378 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 8379 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 8380 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 8381 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8382 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 8383 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 8384 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8385 | } }, |
| 8386 | }, .{ |
| 8387 | .required_features = .{ .sse4_1, null, null, null }, |
| 8388 | .src_constraints = .{ |
| 8389 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8390 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8391 | .any, |
| 8392 | }, |
| 8393 | .patterns = &.{ |
| 8394 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8395 | }, |
| 8396 | .call_frame = .{ .alignment = .@"16" }, |
| 8397 | .extra_temps = .{ |
| 8398 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8399 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 8400 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 8401 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } }, |
| 8402 | .unused, |
| 8403 | .unused, |
| 8404 | .unused, |
| 8405 | .unused, |
| 8406 | .unused, |
| 8407 | }, |
| 8408 | .dst_temps = .{.mem}, |
| 8409 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8410 | .each = .{ .once = &.{ |
| 8411 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8412 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 8413 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 8414 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 8415 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 8416 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8417 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 8418 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 8419 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8420 | } }, |
| 8421 | }, .{ |
| 8422 | .required_features = .{ .sse2, null, null, null }, |
| 8423 | .src_constraints = .{ |
| 8424 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8425 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8426 | .any, |
| 8427 | }, |
| 8428 | .patterns = &.{ |
| 8429 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8430 | }, |
| 8431 | .call_frame = .{ .alignment = .@"16" }, |
| 8432 | .extra_temps = .{ |
| 8433 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8434 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 8435 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 8436 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } }, |
| 8437 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 8438 | .unused, |
| 8439 | .unused, |
| 8440 | .unused, |
| 8441 | .unused, |
| 8442 | }, |
| 8443 | .dst_temps = .{.mem}, |
| 8444 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8445 | .each = .{ .once = &.{ |
| 8446 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8447 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 8448 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 8449 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 8450 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 8451 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8452 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 8453 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 8454 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 8455 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8456 | } }, |
| 8457 | }, .{ |
| 8458 | .required_features = .{ .sse, null, null, null }, |
| 8459 | .src_constraints = .{ |
| 8460 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8461 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 8462 | .any, |
| 8463 | }, |
| 8464 | .patterns = &.{ |
| 8465 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8466 | }, |
| 8467 | .call_frame = .{ .alignment = .@"16" }, |
| 8468 | .extra_temps = .{ |
| 8469 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8470 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 8471 | .{ .type = .f32, .kind = .mem }, |
| 8472 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 8473 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 8474 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodh" } } }, |
| 8475 | .unused, |
| 8476 | .unused, |
| 8477 | .unused, |
| 8478 | }, |
| 8479 | .dst_temps = .{.mem}, |
| 8480 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8481 | .each = .{ .once = &.{ |
| 8482 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8483 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8484 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 8485 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 8486 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8487 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 8488 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 8489 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 8490 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 8491 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 8492 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 8493 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 8494 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8495 | } }, |
| 8496 | }, .{ |
| 8497 | .required_features = .{ .sse, null, null, null }, |
| 8498 | .src_constraints = .{ |
| 8499 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 8500 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 8501 | .any, |
| 8502 | }, |
| 8503 | .patterns = &.{ |
| 8504 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 8505 | }, |
| 8506 | .call_frame = .{ .alignment = .@"16" }, |
| 8507 | .extra_temps = .{ |
| 8508 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } }, |
| 8509 | .unused, |
| 8510 | .unused, |
| 8511 | .unused, |
| 8512 | .unused, |
| 8513 | .unused, |
| 8514 | .unused, |
| 8515 | .unused, |
| 8516 | .unused, |
| 8517 | }, |
| 8518 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8519 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8520 | .each = .{ .once = &.{ |
| 8521 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8522 | } }, |
| 8523 | }, .{ |
| 8524 | .required_features = .{ .avx, null, null, null }, |
| 8525 | .src_constraints = .{ |
| 8526 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 8527 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 8528 | .any, |
| 8529 | }, |
| 8530 | .patterns = &.{ |
| 8531 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8532 | }, |
| 8533 | .call_frame = .{ .alignment = .@"16" }, |
| 8534 | .extra_temps = .{ |
| 8535 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8536 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 8537 | .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, |
| 8538 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } }, |
| 8539 | .unused, |
| 8540 | .unused, |
| 8541 | .unused, |
| 8542 | .unused, |
| 8543 | .unused, |
| 8544 | }, |
| 8545 | .dst_temps = .{.mem}, |
| 8546 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8547 | .each = .{ .once = &.{ |
| 8548 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8549 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8550 | .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8551 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8552 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8553 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 8554 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8555 | } }, |
| 8556 | }, .{ |
| 8557 | .required_features = .{ .sse, null, null, null }, |
| 8558 | .src_constraints = .{ |
| 8559 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 8560 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 8561 | .any, |
| 8562 | }, |
| 8563 | .patterns = &.{ |
| 8564 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8565 | }, |
| 8566 | .call_frame = .{ .alignment = .@"16" }, |
| 8567 | .extra_temps = .{ |
| 8568 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8569 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 8570 | .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, |
| 8571 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodf" } } }, |
| 8572 | .unused, |
| 8573 | .unused, |
| 8574 | .unused, |
| 8575 | .unused, |
| 8576 | .unused, |
| 8577 | }, |
| 8578 | .dst_temps = .{.mem}, |
| 8579 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8580 | .each = .{ .once = &.{ |
| 8581 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8582 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8583 | .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8584 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8585 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8586 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 8587 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8588 | } }, |
| 8589 | }, .{ |
| 8590 | .required_features = .{ .sse, null, null, null }, |
| 8591 | .src_constraints = .{ |
| 8592 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8593 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8594 | .any, |
| 8595 | }, |
| 8596 | .patterns = &.{ |
| 8597 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 8598 | }, |
| 8599 | .call_frame = .{ .alignment = .@"16" }, |
| 8600 | .extra_temps = .{ |
| 8601 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } }, |
| 8602 | .unused, |
| 8603 | .unused, |
| 8604 | .unused, |
| 8605 | .unused, |
| 8606 | .unused, |
| 8607 | .unused, |
| 8608 | .unused, |
| 8609 | .unused, |
| 8610 | }, |
| 8611 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8612 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8613 | .each = .{ .once = &.{ |
| 8614 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8615 | } }, |
| 8616 | }, .{ |
| 8617 | .required_features = .{ .avx, null, null, null }, |
| 8618 | .src_constraints = .{ |
| 8619 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8620 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8621 | .any, |
| 8622 | }, |
| 8623 | .patterns = &.{ |
| 8624 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8625 | }, |
| 8626 | .call_frame = .{ .alignment = .@"16" }, |
| 8627 | .extra_temps = .{ |
| 8628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8629 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 8630 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 8631 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } }, |
| 8632 | .unused, |
| 8633 | .unused, |
| 8634 | .unused, |
| 8635 | .unused, |
| 8636 | .unused, |
| 8637 | }, |
| 8638 | .dst_temps = .{.mem}, |
| 8639 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8640 | .each = .{ .once = &.{ |
| 8641 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8642 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8643 | .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8644 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8645 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8646 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 8647 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8648 | } }, |
| 8649 | }, .{ |
| 8650 | .required_features = .{ .sse2, null, null, null }, |
| 8651 | .src_constraints = .{ |
| 8652 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8653 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8654 | .any, |
| 8655 | }, |
| 8656 | .patterns = &.{ |
| 8657 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8658 | }, |
| 8659 | .call_frame = .{ .alignment = .@"16" }, |
| 8660 | .extra_temps = .{ |
| 8661 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8662 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 8663 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 8664 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } }, |
| 8665 | .unused, |
| 8666 | .unused, |
| 8667 | .unused, |
| 8668 | .unused, |
| 8669 | .unused, |
| 8670 | }, |
| 8671 | .dst_temps = .{.mem}, |
| 8672 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8673 | .each = .{ .once = &.{ |
| 8674 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8675 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8676 | .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8677 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8678 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8679 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 8680 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8681 | } }, |
| 8682 | }, .{ |
| 8683 | .required_features = .{ .sse, null, null, null }, |
| 8684 | .src_constraints = .{ |
| 8685 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8686 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 8687 | .any, |
| 8688 | }, |
| 8689 | .patterns = &.{ |
| 8690 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8691 | }, |
| 8692 | .call_frame = .{ .alignment = .@"16" }, |
| 8693 | .extra_temps = .{ |
| 8694 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8695 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 8696 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 8697 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmod" } } }, |
| 8698 | .unused, |
| 8699 | .unused, |
| 8700 | .unused, |
| 8701 | .unused, |
| 8702 | .unused, |
| 8703 | }, |
| 8704 | .dst_temps = .{.mem}, |
| 8705 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8706 | .each = .{ .once = &.{ |
| 8707 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8708 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 8709 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 8710 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8711 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8712 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8713 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8714 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 8715 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8716 | } }, |
| 8717 | }, .{ |
| 8718 | .required_features = .{ .avx, .x87, null, null }, |
| 8719 | .src_constraints = .{ |
| 8720 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8721 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8722 | .any, |
| 8723 | }, |
| 8724 | .patterns = &.{ |
| 8725 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8726 | }, |
| 8727 | .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, |
| 8728 | .extra_temps = .{ |
| 8729 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 8730 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8731 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } }, |
| 8732 | .unused, |
| 8733 | .unused, |
| 8734 | .unused, |
| 8735 | .unused, |
| 8736 | .unused, |
| 8737 | .unused, |
| 8738 | }, |
| 8739 | .dst_temps = .{.{ .reg = .st0 }}, |
| 8740 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8741 | .each = .{ .once = &.{ |
| 8742 | .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 8743 | .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 8744 | .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ }, |
| 8745 | .{ ._, .v_dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ }, |
| 8746 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 8747 | } }, |
| 8748 | }, .{ |
| 8749 | .required_features = .{ .sse2, .x87, null, null }, |
| 8750 | .src_constraints = .{ |
| 8751 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8752 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8753 | .any, |
| 8754 | }, |
| 8755 | .patterns = &.{ |
| 8756 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8757 | }, |
| 8758 | .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, |
| 8759 | .extra_temps = .{ |
| 8760 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 8761 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8762 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } }, |
| 8763 | .unused, |
| 8764 | .unused, |
| 8765 | .unused, |
| 8766 | .unused, |
| 8767 | .unused, |
| 8768 | .unused, |
| 8769 | }, |
| 8770 | .dst_temps = .{.{ .reg = .st0 }}, |
| 8771 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8772 | .each = .{ .once = &.{ |
| 8773 | .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 8774 | .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 8775 | .{ ._, ._dqa, .mov, .tmp0x, .mem(.src1x), ._, ._ }, |
| 8776 | .{ ._, ._dqa, .mov, .memd(.tmp1x, 16), .tmp0x, ._, ._ }, |
| 8777 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 8778 | } }, |
| 8779 | }, .{ |
| 8780 | .required_features = .{ .sse, .x87, null, null }, |
| 8781 | .src_constraints = .{ |
| 8782 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8783 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8784 | .any, |
| 8785 | }, |
| 8786 | .patterns = &.{ |
| 8787 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8788 | }, |
| 8789 | .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, |
| 8790 | .extra_temps = .{ |
| 8791 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 8792 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8793 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } }, |
| 8794 | .unused, |
| 8795 | .unused, |
| 8796 | .unused, |
| 8797 | .unused, |
| 8798 | .unused, |
| 8799 | .unused, |
| 8800 | }, |
| 8801 | .dst_temps = .{.{ .reg = .st0 }}, |
| 8802 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8803 | .each = .{ .once = &.{ |
| 8804 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ }, |
| 8805 | .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 8806 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ }, |
| 8807 | .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ }, |
| 8808 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 8809 | } }, |
| 8810 | }, .{ |
| 8811 | .required_features = .{ .avx, .x87, null, null }, |
| 8812 | .src_constraints = .{ |
| 8813 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8814 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8815 | .any, |
| 8816 | }, |
| 8817 | .patterns = &.{ |
| 8818 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8819 | }, |
| 8820 | .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, |
| 8821 | .extra_temps = .{ |
| 8822 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8823 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 8824 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8825 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } }, |
| 8826 | .unused, |
| 8827 | .unused, |
| 8828 | .unused, |
| 8829 | .unused, |
| 8830 | .unused, |
| 8831 | }, |
| 8832 | .dst_temps = .{.mem}, |
| 8833 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8834 | .each = .{ .once = &.{ |
| 8835 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8836 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8837 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 8838 | .{ ._, .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8839 | .{ ._, .v_dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ }, |
| 8840 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8841 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 8842 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8843 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8844 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8845 | } }, |
| 8846 | }, .{ |
| 8847 | .required_features = .{ .sse2, .x87, null, null }, |
| 8848 | .src_constraints = .{ |
| 8849 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8850 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8851 | .any, |
| 8852 | }, |
| 8853 | .patterns = &.{ |
| 8854 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8855 | }, |
| 8856 | .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, |
| 8857 | .extra_temps = .{ |
| 8858 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8859 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 8860 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8861 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } }, |
| 8862 | .unused, |
| 8863 | .unused, |
| 8864 | .unused, |
| 8865 | .unused, |
| 8866 | .unused, |
| 8867 | }, |
| 8868 | .dst_temps = .{.mem}, |
| 8869 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8870 | .each = .{ .once = &.{ |
| 8871 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8872 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8873 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 8874 | .{ ._, ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8875 | .{ ._, ._dqa, .mov, .memd(.tmp2x, 16), .tmp1x, ._, ._ }, |
| 8876 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8877 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 8878 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8879 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8880 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8881 | } }, |
| 8882 | }, .{ |
| 8883 | .required_features = .{ .sse, .x87, null, null }, |
| 8884 | .src_constraints = .{ |
| 8885 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8886 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 8887 | .any, |
| 8888 | }, |
| 8889 | .patterns = &.{ |
| 8890 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8891 | }, |
| 8892 | .call_frame = .{ .size = 16 * 2, .alignment = .@"16" }, |
| 8893 | .extra_temps = .{ |
| 8894 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8895 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 8896 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 8897 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmodx" } } }, |
| 8898 | .unused, |
| 8899 | .unused, |
| 8900 | .unused, |
| 8901 | .unused, |
| 8902 | .unused, |
| 8903 | }, |
| 8904 | .dst_temps = .{.mem}, |
| 8905 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8906 | .each = .{ .once = &.{ |
| 8907 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8908 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8909 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 8910 | .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8911 | .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ }, |
| 8912 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8913 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 8914 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8915 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8916 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8917 | } }, |
| 8918 | }, .{ |
| 8919 | .required_features = .{ .sse, null, null, null }, |
| 8920 | .src_constraints = .{ |
| 8921 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8922 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8923 | .any, |
| 8924 | }, |
| 8925 | .patterns = &.{ |
| 8926 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 8927 | }, |
| 8928 | .call_frame = .{ .alignment = .@"16" }, |
| 8929 | .extra_temps = .{ |
| 8930 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } }, |
| 8931 | .unused, |
| 8932 | .unused, |
| 8933 | .unused, |
| 8934 | .unused, |
| 8935 | .unused, |
| 8936 | .unused, |
| 8937 | .unused, |
| 8938 | .unused, |
| 8939 | }, |
| 8940 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8941 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8942 | .each = .{ .once = &.{ |
| 8943 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8944 | } }, |
| 8945 | }, .{ |
| 8946 | .required_features = .{ .avx, null, null, null }, |
| 8947 | .src_constraints = .{ |
| 8948 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8949 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8950 | .any, |
| 8951 | }, |
| 8952 | .patterns = &.{ |
| 8953 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8954 | }, |
| 8955 | .call_frame = .{ .alignment = .@"16" }, |
| 8956 | .extra_temps = .{ |
| 8957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8958 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 8959 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 8960 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } }, |
| 8961 | .unused, |
| 8962 | .unused, |
| 8963 | .unused, |
| 8964 | .unused, |
| 8965 | .unused, |
| 8966 | }, |
| 8967 | .dst_temps = .{.mem}, |
| 8968 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8969 | .each = .{ .once = &.{ |
| 8970 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8971 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8972 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8973 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 8974 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 8975 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8976 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8977 | } }, |
| 8978 | }, .{ |
| 8979 | .required_features = .{ .sse2, null, null, null }, |
| 8980 | .src_constraints = .{ |
| 8981 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8982 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 8983 | .any, |
| 8984 | }, |
| 8985 | .patterns = &.{ |
| 8986 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8987 | }, |
| 8988 | .call_frame = .{ .alignment = .@"16" }, |
| 8989 | .extra_temps = .{ |
| 8990 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8991 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 8992 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 8993 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } }, |
| 8994 | .unused, |
| 8995 | .unused, |
| 8996 | .unused, |
| 8997 | .unused, |
| 8998 | .unused, |
| 8999 | }, |
| 9000 | .dst_temps = .{.mem}, |
| 9001 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 9002 | .each = .{ .once = &.{ |
| 9003 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 9004 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 9005 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 9006 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 9007 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 9008 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9009 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9010 | } }, |
| 9011 | }, .{ |
| 9012 | .required_features = .{ .sse, null, null, null }, |
| 9013 | .src_constraints = .{ |
| 9014 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 9015 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 9016 | .any, |
| 9017 | }, |
| 9018 | .patterns = &.{ |
| 9019 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9020 | }, |
| 9021 | .call_frame = .{ .alignment = .@"16" }, |
| 9022 | .extra_temps = .{ |
| 9023 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9024 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 9025 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 9026 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmodq" } } }, |
| 9027 | .unused, |
| 9028 | .unused, |
| 9029 | .unused, |
| 9030 | .unused, |
| 9031 | .unused, |
| 9032 | }, |
| 9033 | .dst_temps = .{.mem}, |
| 9034 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 9035 | .each = .{ .once = &.{ |
| 9036 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 9037 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 9038 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 9039 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 9040 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 9041 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9042 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9043 | } }, |
| 9044 | } }) catch |err| switch (err) { |
| 9045 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 9046 | @tagName(air_tag), |
| 9047 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 9048 | ops[0].tracking(cg), |
| 9049 | ops[1].tracking(cg), |
| 9050 | }), |
| 9051 | else => |e| return e, |
| 9052 | }; |
| 9053 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 9054 | }, |
| 9055 | .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { |
| 9056 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 9057 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 9058 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 9059 | try ops[0].toSlicePtr(cg); |
| 9060 | var res: [1]Temp = undefined; |
| 9061 | if (ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{ |
| 9062 | .patterns = &.{ |
| 9063 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 9064 | }, |
| 9065 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9066 | .each = .{ .once = &.{ |
| 9067 | .{ ._, ._, .lea, .dst0p, .leaa(.src0, .add_src0_elem_size_times_src1), ._, ._ }, |
| 9068 | } }, |
| 9069 | }, .{ |
| 9070 | .dst_constraints = .{.{ .elem_size_is = 1 }}, |
| 9071 | .patterns = &.{ |
| 9072 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9073 | }, |
| 9074 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9075 | .each = .{ .once = &.{ |
| 9076 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 9077 | } }, |
| 9078 | }, .{ |
| 9079 | .dst_constraints = .{.{ .elem_size_is = 2 }}, |
| 9080 | .patterns = &.{ |
| 9081 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9082 | }, |
| 9083 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9084 | .each = .{ .once = &.{ |
| 9085 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ }, |
| 9086 | } }, |
| 9087 | }, .{ |
| 9088 | .dst_constraints = .{.{ .elem_size_is = 2 + 1 }}, |
| 9089 | .patterns = &.{ |
| 9090 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9091 | }, |
| 9092 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9093 | .each = .{ .once = &.{ |
| 9094 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ }, |
| 9095 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9096 | } }, |
| 9097 | }, .{ |
| 9098 | .dst_constraints = .{.{ .elem_size_is = 4 }}, |
| 9099 | .patterns = &.{ |
| 9100 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9101 | }, |
| 9102 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9103 | .each = .{ .once = &.{ |
| 9104 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ }, |
| 9105 | } }, |
| 9106 | }, .{ |
| 9107 | .dst_constraints = .{.{ .elem_size_is = 4 + 1 }}, |
| 9108 | .patterns = &.{ |
| 9109 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9110 | }, |
| 9111 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9112 | .each = .{ .once = &.{ |
| 9113 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, |
| 9114 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9115 | } }, |
| 9116 | }, .{ |
| 9117 | .required_features = .{ .@"64bit", null, null, null }, |
| 9118 | .dst_constraints = .{.{ .elem_size_is = 8 }}, |
| 9119 | .patterns = &.{ |
| 9120 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9121 | }, |
| 9122 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9123 | .each = .{ .once = &.{ |
| 9124 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ }, |
| 9125 | } }, |
| 9126 | }, .{ |
| 9127 | .required_features = .{ .@"64bit", null, null, null }, |
| 9128 | .dst_constraints = .{.{ .elem_size_is = 8 + 1 }}, |
| 9129 | .patterns = &.{ |
| 9130 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9131 | }, |
| 9132 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9133 | .each = .{ .once = &.{ |
| 9134 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, |
| 9135 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9136 | } }, |
| 9137 | }, .{ |
| 9138 | .dst_constraints = .{.po2_elem_size}, |
| 9139 | .patterns = &.{ |
| 9140 | .{ .src = .{ .to_gpr, .to_mut_gpr, .none } }, |
| 9141 | }, |
| 9142 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9143 | .clobbers = .{ .eflags = true }, |
| 9144 | .each = .{ .once = &.{ |
| 9145 | .{ ._, ._l, .sh, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ }, |
| 9146 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 9147 | } }, |
| 9148 | }, .{ |
| 9149 | .patterns = &.{ |
| 9150 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9151 | }, |
| 9152 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9153 | .clobbers = .{ .eflags = true }, |
| 9154 | .each = .{ .once = &.{ |
| 9155 | .{ ._, .i_, .mul, .dst0p, .src1p, .sa(.none, .add_src0_elem_size), ._ }, |
| 9156 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9157 | } }, |
| 9158 | } }) catch |err| switch (err) { |
| 9159 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 9160 | @tagName(air_tag), |
| 9161 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 9162 | ops[0].tracking(cg), |
| 9163 | ops[1].tracking(cg), |
| 9164 | }), |
| 9165 | else => |e| return e, |
| 9166 | } else { // hack around Sema OPV bugs |
| 9167 | res[0] = ops[0]; |
| 9168 | } |
| 9169 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 9170 | }, |
| 9171 | .ptr_sub => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { |
| 9172 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 9173 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 9174 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 9175 | try ops[0].toSlicePtr(cg); |
| 9176 | var res: [1]Temp = undefined; |
| 9177 | if (ty_pl.ty.toType().elemType2(zcu).hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{ty_pl.ty.toType()}, &ops, comptime &.{ .{ |
| 9178 | .patterns = &.{ |
| 9179 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 9180 | }, |
| 9181 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9182 | .each = .{ .once = &.{ |
| 9183 | .{ ._, ._, .lea, .dst0p, .leaa(.src0, .sub_src0_elem_size_times_src1), ._, ._ }, |
| 9184 | } }, |
| 9185 | }, .{ |
| 9186 | .dst_constraints = .{.{ .elem_size_is = 1 }}, |
| 9187 | .patterns = &.{ |
| 9188 | .{ .src = .{ .to_gpr, .to_mut_gpr, .none } }, |
| 9189 | }, |
| 9190 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9191 | .clobbers = .{ .eflags = true }, |
| 9192 | .each = .{ .once = &.{ |
| 9193 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 9194 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 9195 | } }, |
| 9196 | }, .{ |
| 9197 | .dst_constraints = .{.{ .elem_size_is = 2 }}, |
| 9198 | .patterns = &.{ |
| 9199 | .{ .src = .{ .to_gpr, .to_mut_gpr, .none } }, |
| 9200 | }, |
| 9201 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9202 | .clobbers = .{ .eflags = true }, |
| 9203 | .each = .{ .once = &.{ |
| 9204 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 9205 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ }, |
| 9206 | } }, |
| 9207 | }, .{ |
| 9208 | .dst_constraints = .{.{ .elem_size_is = 2 + 1 }}, |
| 9209 | .patterns = &.{ |
| 9210 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9211 | }, |
| 9212 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9213 | .clobbers = .{ .eflags = true }, |
| 9214 | .each = .{ .once = &.{ |
| 9215 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ }, |
| 9216 | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, |
| 9217 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9218 | } }, |
| 9219 | }, .{ |
| 9220 | .dst_constraints = .{.{ .elem_size_is = 4 }}, |
| 9221 | .patterns = &.{ |
| 9222 | .{ .src = .{ .to_gpr, .to_mut_gpr, .none } }, |
| 9223 | }, |
| 9224 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9225 | .clobbers = .{ .eflags = true }, |
| 9226 | .each = .{ .once = &.{ |
| 9227 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 9228 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ }, |
| 9229 | } }, |
| 9230 | }, .{ |
| 9231 | .dst_constraints = .{.{ .elem_size_is = 4 + 1 }}, |
| 9232 | .patterns = &.{ |
| 9233 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9234 | }, |
| 9235 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9236 | .clobbers = .{ .eflags = true }, |
| 9237 | .each = .{ .once = &.{ |
| 9238 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, |
| 9239 | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, |
| 9240 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9241 | } }, |
| 9242 | }, .{ |
| 9243 | .required_features = .{ .@"64bit", null, null, null }, |
| 9244 | .dst_constraints = .{.{ .elem_size_is = 8 }}, |
| 9245 | .patterns = &.{ |
| 9246 | .{ .src = .{ .to_gpr, .to_mut_gpr, .none } }, |
| 9247 | }, |
| 9248 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9249 | .clobbers = .{ .eflags = true }, |
| 9250 | .each = .{ .once = &.{ |
| 9251 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 9252 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ }, |
| 9253 | } }, |
| 9254 | }, .{ |
| 9255 | .required_features = .{ .@"64bit", null, null, null }, |
| 9256 | .dst_constraints = .{.{ .elem_size_is = 8 + 1 }}, |
| 9257 | .patterns = &.{ |
| 9258 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9259 | }, |
| 9260 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9261 | .clobbers = .{ .eflags = true }, |
| 9262 | .each = .{ .once = &.{ |
| 9263 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, |
| 9264 | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, |
| 9265 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9266 | } }, |
| 9267 | }, .{ |
| 9268 | .dst_constraints = .{.po2_elem_size}, |
| 9269 | .patterns = &.{ |
| 9270 | .{ .src = .{ .to_gpr, .to_mut_gpr, .none } }, |
| 9271 | }, |
| 9272 | .dst_temps = .{.{ .ref = .src1 }}, |
| 9273 | .clobbers = .{ .eflags = true }, |
| 9274 | .each = .{ .once = &.{ |
| 9275 | .{ ._, ._l, .sa, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ }, |
| 9276 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, |
| 9277 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, |
| 9278 | } }, |
| 9279 | }, .{ |
| 9280 | .patterns = &.{ |
| 9281 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 9282 | }, |
| 9283 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 9284 | .clobbers = .{ .eflags = true }, |
| 9285 | .each = .{ .once = &.{ |
| 9286 | .{ ._, .i_, .mul, .dst0p, .src1p, .sa(.none, .sub_src0_elem_size), ._ }, |
| 9287 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, |
| 9288 | } }, |
| 9289 | } }) catch |err| switch (err) { |
| 9290 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 9291 | @tagName(air_tag), |
| 9292 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 9293 | ops[0].tracking(cg), |
| 9294 | ops[1].tracking(cg), |
| 9295 | }), |
| 9296 | else => |e| return e, |
| 9297 | } else { |
| 9298 | // hack around Sema OPV bugs |
| 9299 | res[0] = ops[0]; |
| 9300 | } |
| 9301 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 9302 | }, |
| 9303 | .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { |
| 9304 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 9305 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 9306 | var res: [1]Temp = undefined; |
| 9307 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 9308 | .required_features = .{ .cmov, null, null, null }, |
| 9309 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 9310 | .patterns = &.{ |
| 9311 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9312 | }, |
| 9313 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9314 | .clobbers = .{ .eflags = true }, |
| 9315 | .each = .{ .once = &.{ |
| 9316 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 9317 | .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ }, |
| 9318 | } }, |
| 9319 | }, .{ |
| 9320 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 9321 | .patterns = &.{ |
| 9322 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9323 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9324 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9325 | }, |
| 9326 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9327 | .clobbers = .{ .eflags = true }, |
| 9328 | .each = .{ .once = &.{ |
| 9329 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 9330 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 9331 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 9332 | } }, |
| 9333 | }, .{ |
| 9334 | .required_features = .{ .cmov, null, null, null }, |
| 9335 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 9336 | .patterns = &.{ |
| 9337 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9338 | }, |
| 9339 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9340 | .clobbers = .{ .eflags = true }, |
| 9341 | .each = .{ .once = &.{ |
| 9342 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 9343 | .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ }, |
| 9344 | } }, |
| 9345 | }, .{ |
| 9346 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 9347 | .patterns = &.{ |
| 9348 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9349 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9350 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9351 | }, |
| 9352 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9353 | .clobbers = .{ .eflags = true }, |
| 9354 | .each = .{ .once = &.{ |
| 9355 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 9356 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 9357 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 9358 | } }, |
| 9359 | }, .{ |
| 9360 | .required_features = .{ .cmov, null, null, null }, |
| 9361 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 9362 | .patterns = &.{ |
| 9363 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9364 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9365 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9366 | }, |
| 9367 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9368 | .clobbers = .{ .eflags = true }, |
| 9369 | .each = .{ .once = &.{ |
| 9370 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 9371 | .{ ._, ._l, .cmov, .dst0w, .src1w, ._, ._ }, |
| 9372 | } }, |
| 9373 | }, .{ |
| 9374 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 9375 | .patterns = &.{ |
| 9376 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9377 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9378 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9379 | }, |
| 9380 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9381 | .clobbers = .{ .eflags = true }, |
| 9382 | .each = .{ .once = &.{ |
| 9383 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 9384 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 9385 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 9386 | } }, |
| 9387 | }, .{ |
| 9388 | .required_features = .{ .cmov, null, null, null }, |
| 9389 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 9390 | .patterns = &.{ |
| 9391 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9392 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9393 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9394 | }, |
| 9395 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9396 | .clobbers = .{ .eflags = true }, |
| 9397 | .each = .{ .once = &.{ |
| 9398 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 9399 | .{ ._, ._b, .cmov, .dst0w, .src1w, ._, ._ }, |
| 9400 | } }, |
| 9401 | }, .{ |
| 9402 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 9403 | .patterns = &.{ |
| 9404 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9405 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9406 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9407 | }, |
| 9408 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9409 | .clobbers = .{ .eflags = true }, |
| 9410 | .each = .{ .once = &.{ |
| 9411 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 9412 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 9413 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 9414 | } }, |
| 9415 | }, .{ |
| 9416 | .required_features = .{ .cmov, null, null, null }, |
| 9417 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 9418 | .patterns = &.{ |
| 9419 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9420 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9421 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9422 | }, |
| 9423 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9424 | .clobbers = .{ .eflags = true }, |
| 9425 | .each = .{ .once = &.{ |
| 9426 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 9427 | .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ }, |
| 9428 | } }, |
| 9429 | }, .{ |
| 9430 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 9431 | .patterns = &.{ |
| 9432 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9433 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9434 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9435 | }, |
| 9436 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9437 | .clobbers = .{ .eflags = true }, |
| 9438 | .each = .{ .once = &.{ |
| 9439 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 9440 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 9441 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 9442 | } }, |
| 9443 | }, .{ |
| 9444 | .required_features = .{ .cmov, null, null, null }, |
| 9445 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 9446 | .patterns = &.{ |
| 9447 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9448 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9449 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9450 | }, |
| 9451 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9452 | .clobbers = .{ .eflags = true }, |
| 9453 | .each = .{ .once = &.{ |
| 9454 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 9455 | .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ }, |
| 9456 | } }, |
| 9457 | }, .{ |
| 9458 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 9459 | .patterns = &.{ |
| 9460 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9461 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9462 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9463 | }, |
| 9464 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9465 | .clobbers = .{ .eflags = true }, |
| 9466 | .each = .{ .once = &.{ |
| 9467 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 9468 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 9469 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 9470 | } }, |
| 9471 | }, .{ |
| 9472 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 9473 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 9474 | .patterns = &.{ |
| 9475 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9476 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9477 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9478 | }, |
| 9479 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9480 | .clobbers = .{ .eflags = true }, |
| 9481 | .each = .{ .once = &.{ |
| 9482 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 9483 | .{ ._, ._l, .cmov, .dst0q, .src1q, ._, ._ }, |
| 9484 | } }, |
| 9485 | }, .{ |
| 9486 | .required_features = .{ .@"64bit", null, null, null }, |
| 9487 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 9488 | .patterns = &.{ |
| 9489 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9490 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9491 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9492 | }, |
| 9493 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9494 | .clobbers = .{ .eflags = true }, |
| 9495 | .each = .{ .once = &.{ |
| 9496 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 9497 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 9498 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 9499 | } }, |
| 9500 | }, .{ |
| 9501 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 9502 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 9503 | .patterns = &.{ |
| 9504 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9505 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9506 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9507 | }, |
| 9508 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9509 | .clobbers = .{ .eflags = true }, |
| 9510 | .each = .{ .once = &.{ |
| 9511 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 9512 | .{ ._, ._b, .cmov, .dst0q, .src1q, ._, ._ }, |
| 9513 | } }, |
| 9514 | }, .{ |
| 9515 | .required_features = .{ .@"64bit", null, null, null }, |
| 9516 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 9517 | .patterns = &.{ |
| 9518 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 9519 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 9520 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 9521 | }, |
| 9522 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9523 | .clobbers = .{ .eflags = true }, |
| 9524 | .each = .{ .once = &.{ |
| 9525 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 9526 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 9527 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 9528 | } }, |
| 9529 | }, .{ |
| 9530 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 9531 | .src_constraints = .{ .any_signed_int, .any_signed_int, .any }, |
| 9532 | .patterns = &.{ |
| 9533 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9534 | }, |
| 9535 | .extra_temps = .{ |
| 9536 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 9537 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 9538 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 9539 | .unused, |
| 9540 | .unused, |
| 9541 | .unused, |
| 9542 | .unused, |
| 9543 | .unused, |
| 9544 | .unused, |
| 9545 | }, |
| 9546 | .dst_temps = .{.mem}, |
| 9547 | .clobbers = .{ .eflags = true }, |
| 9548 | .each = .{ .once = &.{ |
| 9549 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 9550 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 9551 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 9552 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 9553 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 9554 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 9555 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 9556 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 9557 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 9558 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 9559 | .{ ._, ._l, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 9560 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 9561 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 9562 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 9563 | } }, |
| 9564 | }, .{ |
| 9565 | .required_features = .{ .@"64bit", null, null, null }, |
| 9566 | .src_constraints = .{ .any_signed_int, .any_signed_int, .any }, |
| 9567 | .patterns = &.{ |
| 9568 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9569 | }, |
| 9570 | .extra_temps = .{ |
| 9571 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 9572 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 9573 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 9574 | .unused, |
| 9575 | .unused, |
| 9576 | .unused, |
| 9577 | .unused, |
| 9578 | .unused, |
| 9579 | .unused, |
| 9580 | }, |
| 9581 | .dst_temps = .{.mem}, |
| 9582 | .clobbers = .{ .eflags = true }, |
| 9583 | .each = .{ .once = &.{ |
| 9584 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 9585 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 9586 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 9587 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 9588 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 9589 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 9590 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 9591 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 9592 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 9593 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, |
| 9594 | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 9595 | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 9596 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 9597 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 9598 | } }, |
| 9599 | }, .{ |
| 9600 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 9601 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any }, |
| 9602 | .patterns = &.{ |
| 9603 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9604 | }, |
| 9605 | .extra_temps = .{ |
| 9606 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 9607 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 9608 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 9609 | .unused, |
| 9610 | .unused, |
| 9611 | .unused, |
| 9612 | .unused, |
| 9613 | .unused, |
| 9614 | .unused, |
| 9615 | }, |
| 9616 | .dst_temps = .{.mem}, |
| 9617 | .clobbers = .{ .eflags = true }, |
| 9618 | .each = .{ .once = &.{ |
| 9619 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 9620 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 9621 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 9622 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 9623 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 9624 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 9625 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 9626 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 9627 | .{ ._, ._b, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 9628 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 9629 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 9630 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 9631 | } }, |
| 9632 | }, .{ |
| 9633 | .required_features = .{ .@"64bit", null, null, null }, |
| 9634 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any }, |
| 9635 | .patterns = &.{ |
| 9636 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9637 | }, |
| 9638 | .extra_temps = .{ |
| 9639 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 9640 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 9641 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 9642 | .unused, |
| 9643 | .unused, |
| 9644 | .unused, |
| 9645 | .unused, |
| 9646 | .unused, |
| 9647 | .unused, |
| 9648 | }, |
| 9649 | .dst_temps = .{.mem}, |
| 9650 | .clobbers = .{ .eflags = true }, |
| 9651 | .each = .{ .once = &.{ |
| 9652 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 9653 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 9654 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 9655 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 9656 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 9657 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 9658 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 9659 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, |
| 9660 | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 9661 | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 9662 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 9663 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 9664 | } }, |
| 9665 | }, .{ |
| 9666 | .required_features = .{ .avx, null, null, null }, |
| 9667 | .src_constraints = .{ |
| 9668 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9669 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9670 | .any, |
| 9671 | }, |
| 9672 | .patterns = &.{ |
| 9673 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 9674 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 9675 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9676 | }, |
| 9677 | .dst_temps = .{.{ .rc = .sse }}, |
| 9678 | .each = .{ .once = &.{ |
| 9679 | .{ ._, .vp_b, .maxs, .dst0x, .src0x, .src1x, ._ }, |
| 9680 | } }, |
| 9681 | }, .{ |
| 9682 | .required_features = .{ .sse4_1, null, null, null }, |
| 9683 | .src_constraints = .{ |
| 9684 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9685 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9686 | .any, |
| 9687 | }, |
| 9688 | .patterns = &.{ |
| 9689 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 9690 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 9691 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9692 | }, |
| 9693 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9694 | .each = .{ .once = &.{ |
| 9695 | .{ ._, .p_b, .maxs, .dst0x, .src1x, ._, ._ }, |
| 9696 | } }, |
| 9697 | }, .{ |
| 9698 | .required_features = .{ .sse2, null, null, null }, |
| 9699 | .src_constraints = .{ |
| 9700 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9701 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9702 | .any, |
| 9703 | }, |
| 9704 | .patterns = &.{ |
| 9705 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 9706 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 9707 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9708 | }, |
| 9709 | .dst_temps = .{.{ .rc = .sse }}, |
| 9710 | .each = .{ .once = &.{ |
| 9711 | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| 9712 | .{ ._, .p_b, .cmpgt, .dst0x, .src1x, ._, ._ }, |
| 9713 | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 9714 | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 9715 | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 9716 | } }, |
| 9717 | }, .{ |
| 9718 | .required_features = .{ .avx2, null, null, null }, |
| 9719 | .src_constraints = .{ |
| 9720 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 9721 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 9722 | .any, |
| 9723 | }, |
| 9724 | .patterns = &.{ |
| 9725 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 9726 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 9727 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9728 | }, |
| 9729 | .dst_temps = .{.{ .rc = .sse }}, |
| 9730 | .each = .{ .once = &.{ |
| 9731 | .{ ._, .vp_b, .maxs, .dst0y, .src0y, .src1y, ._ }, |
| 9732 | } }, |
| 9733 | }, .{ |
| 9734 | .required_features = .{ .avx2, null, null, null }, |
| 9735 | .src_constraints = .{ |
| 9736 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 9737 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 9738 | .any, |
| 9739 | }, |
| 9740 | .patterns = &.{ |
| 9741 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9742 | }, |
| 9743 | .extra_temps = .{ |
| 9744 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9745 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 9746 | .unused, |
| 9747 | .unused, |
| 9748 | .unused, |
| 9749 | .unused, |
| 9750 | .unused, |
| 9751 | .unused, |
| 9752 | .unused, |
| 9753 | }, |
| 9754 | .dst_temps = .{.mem}, |
| 9755 | .clobbers = .{ .eflags = true }, |
| 9756 | .each = .{ .once = &.{ |
| 9757 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9758 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 9759 | .{ ._, .vp_b, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 9760 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 9761 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 9762 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9763 | } }, |
| 9764 | }, .{ |
| 9765 | .required_features = .{ .avx, null, null, null }, |
| 9766 | .src_constraints = .{ |
| 9767 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9768 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9769 | .any, |
| 9770 | }, |
| 9771 | .patterns = &.{ |
| 9772 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9773 | }, |
| 9774 | .extra_temps = .{ |
| 9775 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9776 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 9777 | .unused, |
| 9778 | .unused, |
| 9779 | .unused, |
| 9780 | .unused, |
| 9781 | .unused, |
| 9782 | .unused, |
| 9783 | .unused, |
| 9784 | }, |
| 9785 | .dst_temps = .{.mem}, |
| 9786 | .clobbers = .{ .eflags = true }, |
| 9787 | .each = .{ .once = &.{ |
| 9788 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9789 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 9790 | .{ ._, .vp_b, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 9791 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 9792 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9793 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9794 | } }, |
| 9795 | }, .{ |
| 9796 | .required_features = .{ .sse4_1, null, null, null }, |
| 9797 | .src_constraints = .{ |
| 9798 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9799 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9800 | .any, |
| 9801 | }, |
| 9802 | .patterns = &.{ |
| 9803 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9804 | }, |
| 9805 | .extra_temps = .{ |
| 9806 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9807 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 9808 | .unused, |
| 9809 | .unused, |
| 9810 | .unused, |
| 9811 | .unused, |
| 9812 | .unused, |
| 9813 | .unused, |
| 9814 | .unused, |
| 9815 | }, |
| 9816 | .dst_temps = .{.mem}, |
| 9817 | .clobbers = .{ .eflags = true }, |
| 9818 | .each = .{ .once = &.{ |
| 9819 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9820 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 9821 | .{ ._, .p_b, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9822 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 9823 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9824 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9825 | } }, |
| 9826 | }, .{ |
| 9827 | .required_features = .{ .sse2, null, null, null }, |
| 9828 | .src_constraints = .{ |
| 9829 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9830 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 9831 | .any, |
| 9832 | }, |
| 9833 | .patterns = &.{ |
| 9834 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9835 | }, |
| 9836 | .extra_temps = .{ |
| 9837 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9838 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 9839 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 9840 | .unused, |
| 9841 | .unused, |
| 9842 | .unused, |
| 9843 | .unused, |
| 9844 | .unused, |
| 9845 | .unused, |
| 9846 | }, |
| 9847 | .dst_temps = .{.mem}, |
| 9848 | .clobbers = .{ .eflags = true }, |
| 9849 | .each = .{ .once = &.{ |
| 9850 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9851 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 9852 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 9853 | .{ ._, .p_b, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9854 | .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ }, |
| 9855 | .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9856 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, |
| 9857 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 9858 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9859 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9860 | } }, |
| 9861 | }, .{ |
| 9862 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| 9863 | .src_constraints = .{ |
| 9864 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9865 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9866 | .any, |
| 9867 | }, |
| 9868 | .patterns = &.{ |
| 9869 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9870 | }, |
| 9871 | .extra_temps = .{ |
| 9872 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9873 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 9874 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 9875 | .unused, |
| 9876 | .unused, |
| 9877 | .unused, |
| 9878 | .unused, |
| 9879 | .unused, |
| 9880 | .unused, |
| 9881 | }, |
| 9882 | .dst_temps = .{.mem}, |
| 9883 | .clobbers = .{ .eflags = true }, |
| 9884 | .each = .{ .once = &.{ |
| 9885 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9886 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 9887 | .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 9888 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 9889 | .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 9890 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 9891 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 9892 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9893 | } }, |
| 9894 | }, .{ |
| 9895 | .required_features = .{ .cmov, null, null, null }, |
| 9896 | .src_constraints = .{ |
| 9897 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9898 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9899 | .any, |
| 9900 | }, |
| 9901 | .patterns = &.{ |
| 9902 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9903 | }, |
| 9904 | .extra_temps = .{ |
| 9905 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9906 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 9907 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 9908 | .unused, |
| 9909 | .unused, |
| 9910 | .unused, |
| 9911 | .unused, |
| 9912 | .unused, |
| 9913 | .unused, |
| 9914 | }, |
| 9915 | .dst_temps = .{.mem}, |
| 9916 | .clobbers = .{ .eflags = true }, |
| 9917 | .each = .{ .once = &.{ |
| 9918 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9919 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 9920 | .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 9921 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 9922 | .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 9923 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 9924 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 9925 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 9926 | } }, |
| 9927 | }, .{ |
| 9928 | .required_features = .{ .slow_incdec, null, null, null }, |
| 9929 | .src_constraints = .{ |
| 9930 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9931 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9932 | .any, |
| 9933 | }, |
| 9934 | .patterns = &.{ |
| 9935 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9936 | }, |
| 9937 | .extra_temps = .{ |
| 9938 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9939 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 9940 | .unused, |
| 9941 | .unused, |
| 9942 | .unused, |
| 9943 | .unused, |
| 9944 | .unused, |
| 9945 | .unused, |
| 9946 | .unused, |
| 9947 | }, |
| 9948 | .dst_temps = .{.mem}, |
| 9949 | .clobbers = .{ .eflags = true }, |
| 9950 | .each = .{ .once = &.{ |
| 9951 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9952 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 9953 | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 9954 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 9955 | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 9956 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 9957 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 9958 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9959 | } }, |
| 9960 | }, .{ |
| 9961 | .src_constraints = .{ |
| 9962 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9963 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 9964 | .any, |
| 9965 | }, |
| 9966 | .patterns = &.{ |
| 9967 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9968 | }, |
| 9969 | .extra_temps = .{ |
| 9970 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9971 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 9972 | .unused, |
| 9973 | .unused, |
| 9974 | .unused, |
| 9975 | .unused, |
| 9976 | .unused, |
| 9977 | .unused, |
| 9978 | .unused, |
| 9979 | }, |
| 9980 | .dst_temps = .{.mem}, |
| 9981 | .clobbers = .{ .eflags = true }, |
| 9982 | .each = .{ .once = &.{ |
| 9983 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 9984 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 9985 | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 9986 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 9987 | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 9988 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 9989 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 9990 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 9991 | } }, |
| 9992 | }, .{ |
| 9993 | .required_features = .{ .sse, .mmx, null, null }, |
| 9994 | .src_constraints = .{ |
| 9995 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 9996 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 9997 | .any, |
| 9998 | }, |
| 9999 | .patterns = &.{ |
| 10000 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 10001 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 10002 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 10003 | }, |
| 10004 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10005 | .each = .{ .once = &.{ |
| 10006 | .{ ._, .p_b, .maxu, .dst0q, .src1q, ._, ._ }, |
| 10007 | } }, |
| 10008 | }, .{ |
| 10009 | .required_features = .{ .avx, null, null, null }, |
| 10010 | .src_constraints = .{ |
| 10011 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10012 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10013 | .any, |
| 10014 | }, |
| 10015 | .patterns = &.{ |
| 10016 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10017 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10018 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10019 | }, |
| 10020 | .dst_temps = .{.{ .rc = .sse }}, |
| 10021 | .each = .{ .once = &.{ |
| 10022 | .{ ._, .vp_b, .maxu, .dst0x, .src0x, .src1x, ._ }, |
| 10023 | } }, |
| 10024 | }, .{ |
| 10025 | .required_features = .{ .sse2, null, null, null }, |
| 10026 | .src_constraints = .{ |
| 10027 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10028 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10029 | .any, |
| 10030 | }, |
| 10031 | .patterns = &.{ |
| 10032 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 10033 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 10034 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 10035 | }, |
| 10036 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10037 | .each = .{ .once = &.{ |
| 10038 | .{ ._, .p_b, .maxu, .dst0x, .src1x, ._, ._ }, |
| 10039 | } }, |
| 10040 | }, .{ |
| 10041 | .required_features = .{ .avx2, null, null, null }, |
| 10042 | .src_constraints = .{ |
| 10043 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 10044 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 10045 | .any, |
| 10046 | }, |
| 10047 | .patterns = &.{ |
| 10048 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10049 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10050 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10051 | }, |
| 10052 | .dst_temps = .{.{ .rc = .sse }}, |
| 10053 | .each = .{ .once = &.{ |
| 10054 | .{ ._, .vp_b, .maxu, .dst0y, .src0y, .src1y, ._ }, |
| 10055 | } }, |
| 10056 | }, .{ |
| 10057 | .required_features = .{ .avx2, null, null, null }, |
| 10058 | .src_constraints = .{ |
| 10059 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 10060 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 10061 | .any, |
| 10062 | }, |
| 10063 | .patterns = &.{ |
| 10064 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10065 | }, |
| 10066 | .extra_temps = .{ |
| 10067 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10068 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 10069 | .unused, |
| 10070 | .unused, |
| 10071 | .unused, |
| 10072 | .unused, |
| 10073 | .unused, |
| 10074 | .unused, |
| 10075 | .unused, |
| 10076 | }, |
| 10077 | .dst_temps = .{.mem}, |
| 10078 | .clobbers = .{ .eflags = true }, |
| 10079 | .each = .{ .once = &.{ |
| 10080 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10081 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 10082 | .{ ._, .vp_b, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 10083 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 10084 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 10085 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10086 | } }, |
| 10087 | }, .{ |
| 10088 | .required_features = .{ .avx, null, null, null }, |
| 10089 | .src_constraints = .{ |
| 10090 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10091 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10092 | .any, |
| 10093 | }, |
| 10094 | .patterns = &.{ |
| 10095 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10096 | }, |
| 10097 | .extra_temps = .{ |
| 10098 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10099 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 10100 | .unused, |
| 10101 | .unused, |
| 10102 | .unused, |
| 10103 | .unused, |
| 10104 | .unused, |
| 10105 | .unused, |
| 10106 | .unused, |
| 10107 | }, |
| 10108 | .dst_temps = .{.mem}, |
| 10109 | .clobbers = .{ .eflags = true }, |
| 10110 | .each = .{ .once = &.{ |
| 10111 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10112 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10113 | .{ ._, .vp_b, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 10114 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10115 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10116 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10117 | } }, |
| 10118 | }, .{ |
| 10119 | .required_features = .{ .sse2, null, null, null }, |
| 10120 | .src_constraints = .{ |
| 10121 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10122 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 10123 | .any, |
| 10124 | }, |
| 10125 | .patterns = &.{ |
| 10126 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10127 | }, |
| 10128 | .extra_temps = .{ |
| 10129 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10130 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 10131 | .unused, |
| 10132 | .unused, |
| 10133 | .unused, |
| 10134 | .unused, |
| 10135 | .unused, |
| 10136 | .unused, |
| 10137 | .unused, |
| 10138 | }, |
| 10139 | .dst_temps = .{.mem}, |
| 10140 | .clobbers = .{ .eflags = true }, |
| 10141 | .each = .{ .once = &.{ |
| 10142 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10143 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10144 | .{ ._, .p_b, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10145 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10146 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10147 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10148 | } }, |
| 10149 | }, .{ |
| 10150 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| 10151 | .src_constraints = .{ |
| 10152 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10153 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10154 | .any, |
| 10155 | }, |
| 10156 | .patterns = &.{ |
| 10157 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10158 | }, |
| 10159 | .extra_temps = .{ |
| 10160 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10161 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 10162 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 10163 | .unused, |
| 10164 | .unused, |
| 10165 | .unused, |
| 10166 | .unused, |
| 10167 | .unused, |
| 10168 | .unused, |
| 10169 | }, |
| 10170 | .dst_temps = .{.mem}, |
| 10171 | .clobbers = .{ .eflags = true }, |
| 10172 | .each = .{ .once = &.{ |
| 10173 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10174 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 10175 | .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 10176 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 10177 | .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 10178 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 10179 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 10180 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10181 | } }, |
| 10182 | }, .{ |
| 10183 | .required_features = .{ .cmov, null, null, null }, |
| 10184 | .src_constraints = .{ |
| 10185 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10186 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10187 | .any, |
| 10188 | }, |
| 10189 | .patterns = &.{ |
| 10190 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10191 | }, |
| 10192 | .extra_temps = .{ |
| 10193 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10194 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 10195 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 10196 | .unused, |
| 10197 | .unused, |
| 10198 | .unused, |
| 10199 | .unused, |
| 10200 | .unused, |
| 10201 | .unused, |
| 10202 | }, |
| 10203 | .dst_temps = .{.mem}, |
| 10204 | .clobbers = .{ .eflags = true }, |
| 10205 | .each = .{ .once = &.{ |
| 10206 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10207 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 10208 | .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 10209 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, |
| 10210 | .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 10211 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 10212 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 10213 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 10214 | } }, |
| 10215 | }, .{ |
| 10216 | .required_features = .{ .slow_incdec, null, null, null }, |
| 10217 | .src_constraints = .{ |
| 10218 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10219 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10220 | .any, |
| 10221 | }, |
| 10222 | .patterns = &.{ |
| 10223 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10224 | }, |
| 10225 | .extra_temps = .{ |
| 10226 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10227 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 10228 | .unused, |
| 10229 | .unused, |
| 10230 | .unused, |
| 10231 | .unused, |
| 10232 | .unused, |
| 10233 | .unused, |
| 10234 | .unused, |
| 10235 | }, |
| 10236 | .dst_temps = .{.mem}, |
| 10237 | .clobbers = .{ .eflags = true }, |
| 10238 | .each = .{ .once = &.{ |
| 10239 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10240 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 10241 | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 10242 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 10243 | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 10244 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 10245 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 10246 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10247 | } }, |
| 10248 | }, .{ |
| 10249 | .src_constraints = .{ |
| 10250 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10251 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 10252 | .any, |
| 10253 | }, |
| 10254 | .patterns = &.{ |
| 10255 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10256 | }, |
| 10257 | .extra_temps = .{ |
| 10258 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10259 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 10260 | .unused, |
| 10261 | .unused, |
| 10262 | .unused, |
| 10263 | .unused, |
| 10264 | .unused, |
| 10265 | .unused, |
| 10266 | .unused, |
| 10267 | }, |
| 10268 | .dst_temps = .{.mem}, |
| 10269 | .clobbers = .{ .eflags = true }, |
| 10270 | .each = .{ .once = &.{ |
| 10271 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10272 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 10273 | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 10274 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 10275 | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, |
| 10276 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 10277 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 10278 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 10279 | } }, |
| 10280 | }, .{ |
| 10281 | .required_features = .{ .sse, .mmx, null, null }, |
| 10282 | .src_constraints = .{ |
| 10283 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 10284 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 10285 | .any, |
| 10286 | }, |
| 10287 | .patterns = &.{ |
| 10288 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 10289 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 10290 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 10291 | }, |
| 10292 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10293 | .each = .{ .once = &.{ |
| 10294 | .{ ._, .p_w, .maxs, .dst0q, .src1q, ._, ._ }, |
| 10295 | } }, |
| 10296 | }, .{ |
| 10297 | .required_features = .{ .avx, null, null, null }, |
| 10298 | .src_constraints = .{ |
| 10299 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10300 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10301 | .any, |
| 10302 | }, |
| 10303 | .patterns = &.{ |
| 10304 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10305 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10306 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10307 | }, |
| 10308 | .dst_temps = .{.{ .rc = .sse }}, |
| 10309 | .each = .{ .once = &.{ |
| 10310 | .{ ._, .vp_w, .maxs, .dst0x, .src0x, .src1x, ._ }, |
| 10311 | } }, |
| 10312 | }, .{ |
| 10313 | .required_features = .{ .sse2, null, null, null }, |
| 10314 | .src_constraints = .{ |
| 10315 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10316 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10317 | .any, |
| 10318 | }, |
| 10319 | .patterns = &.{ |
| 10320 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 10321 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 10322 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 10323 | }, |
| 10324 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10325 | .each = .{ .once = &.{ |
| 10326 | .{ ._, .p_w, .maxs, .dst0x, .src1x, ._, ._ }, |
| 10327 | } }, |
| 10328 | }, .{ |
| 10329 | .required_features = .{ .avx2, null, null, null }, |
| 10330 | .src_constraints = .{ |
| 10331 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 10332 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 10333 | .any, |
| 10334 | }, |
| 10335 | .patterns = &.{ |
| 10336 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10337 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10338 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10339 | }, |
| 10340 | .dst_temps = .{.{ .rc = .sse }}, |
| 10341 | .each = .{ .once = &.{ |
| 10342 | .{ ._, .vp_w, .maxs, .dst0y, .src0y, .src1y, ._ }, |
| 10343 | } }, |
| 10344 | }, .{ |
| 10345 | .required_features = .{ .avx2, null, null, null }, |
| 10346 | .src_constraints = .{ |
| 10347 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 10348 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 10349 | .any, |
| 10350 | }, |
| 10351 | .patterns = &.{ |
| 10352 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10353 | }, |
| 10354 | .extra_temps = .{ |
| 10355 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10356 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 10357 | .unused, |
| 10358 | .unused, |
| 10359 | .unused, |
| 10360 | .unused, |
| 10361 | .unused, |
| 10362 | .unused, |
| 10363 | .unused, |
| 10364 | }, |
| 10365 | .dst_temps = .{.mem}, |
| 10366 | .clobbers = .{ .eflags = true }, |
| 10367 | .each = .{ .once = &.{ |
| 10368 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10369 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 10370 | .{ ._, .vp_w, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 10371 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 10372 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 10373 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10374 | } }, |
| 10375 | }, .{ |
| 10376 | .required_features = .{ .avx, null, null, null }, |
| 10377 | .src_constraints = .{ |
| 10378 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10379 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10380 | .any, |
| 10381 | }, |
| 10382 | .patterns = &.{ |
| 10383 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10384 | }, |
| 10385 | .extra_temps = .{ |
| 10386 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10387 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 10388 | .unused, |
| 10389 | .unused, |
| 10390 | .unused, |
| 10391 | .unused, |
| 10392 | .unused, |
| 10393 | .unused, |
| 10394 | .unused, |
| 10395 | }, |
| 10396 | .dst_temps = .{.mem}, |
| 10397 | .clobbers = .{ .eflags = true }, |
| 10398 | .each = .{ .once = &.{ |
| 10399 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10400 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10401 | .{ ._, .vp_w, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 10402 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10403 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10404 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10405 | } }, |
| 10406 | }, .{ |
| 10407 | .required_features = .{ .sse2, null, null, null }, |
| 10408 | .src_constraints = .{ |
| 10409 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10410 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 10411 | .any, |
| 10412 | }, |
| 10413 | .patterns = &.{ |
| 10414 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10415 | }, |
| 10416 | .extra_temps = .{ |
| 10417 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10418 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 10419 | .unused, |
| 10420 | .unused, |
| 10421 | .unused, |
| 10422 | .unused, |
| 10423 | .unused, |
| 10424 | .unused, |
| 10425 | .unused, |
| 10426 | }, |
| 10427 | .dst_temps = .{.mem}, |
| 10428 | .clobbers = .{ .eflags = true }, |
| 10429 | .each = .{ .once = &.{ |
| 10430 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10431 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10432 | .{ ._, .p_w, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10433 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10434 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10435 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10436 | } }, |
| 10437 | }, .{ |
| 10438 | .required_features = .{ .cmov, null, null, null }, |
| 10439 | .src_constraints = .{ |
| 10440 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 10441 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 10442 | .any, |
| 10443 | }, |
| 10444 | .patterns = &.{ |
| 10445 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10446 | }, |
| 10447 | .extra_temps = .{ |
| 10448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10449 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 10450 | .unused, |
| 10451 | .unused, |
| 10452 | .unused, |
| 10453 | .unused, |
| 10454 | .unused, |
| 10455 | .unused, |
| 10456 | .unused, |
| 10457 | }, |
| 10458 | .dst_temps = .{.mem}, |
| 10459 | .clobbers = .{ .eflags = true }, |
| 10460 | .each = .{ .once = &.{ |
| 10461 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10462 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 10463 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10464 | .{ ._, ._l, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10465 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 10466 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 10467 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10468 | } }, |
| 10469 | }, .{ |
| 10470 | .src_constraints = .{ |
| 10471 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 10472 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 10473 | .any, |
| 10474 | }, |
| 10475 | .patterns = &.{ |
| 10476 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10477 | }, |
| 10478 | .extra_temps = .{ |
| 10479 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10480 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 10481 | .unused, |
| 10482 | .unused, |
| 10483 | .unused, |
| 10484 | .unused, |
| 10485 | .unused, |
| 10486 | .unused, |
| 10487 | .unused, |
| 10488 | }, |
| 10489 | .dst_temps = .{.mem}, |
| 10490 | .clobbers = .{ .eflags = true }, |
| 10491 | .each = .{ .once = &.{ |
| 10492 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10493 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 10494 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10495 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 10496 | .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10497 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 10498 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 10499 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10500 | } }, |
| 10501 | }, .{ |
| 10502 | .required_features = .{ .avx, null, null, null }, |
| 10503 | .src_constraints = .{ |
| 10504 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10505 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10506 | .any, |
| 10507 | }, |
| 10508 | .patterns = &.{ |
| 10509 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10510 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10511 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10512 | }, |
| 10513 | .dst_temps = .{.{ .rc = .sse }}, |
| 10514 | .each = .{ .once = &.{ |
| 10515 | .{ ._, .vp_w, .maxu, .dst0x, .src0x, .src1x, ._ }, |
| 10516 | } }, |
| 10517 | }, .{ |
| 10518 | .required_features = .{ .sse4_1, null, null, null }, |
| 10519 | .src_constraints = .{ |
| 10520 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10521 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10522 | .any, |
| 10523 | }, |
| 10524 | .patterns = &.{ |
| 10525 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 10526 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 10527 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 10528 | }, |
| 10529 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10530 | .each = .{ .once = &.{ |
| 10531 | .{ ._, .p_w, .maxu, .dst0x, .src1x, ._, ._ }, |
| 10532 | } }, |
| 10533 | }, .{ |
| 10534 | .required_features = .{ .sse2, null, null, null }, |
| 10535 | .src_constraints = .{ |
| 10536 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10537 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10538 | .any, |
| 10539 | }, |
| 10540 | .patterns = &.{ |
| 10541 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 10542 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 10543 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 10544 | }, |
| 10545 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10546 | .each = .{ .once = &.{ |
| 10547 | .{ ._, .p_w, .subus, .dst0x, .src1x, ._, ._ }, |
| 10548 | .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ }, |
| 10549 | } }, |
| 10550 | }, .{ |
| 10551 | .required_features = .{ .avx2, null, null, null }, |
| 10552 | .src_constraints = .{ |
| 10553 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 10554 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 10555 | .any, |
| 10556 | }, |
| 10557 | .patterns = &.{ |
| 10558 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10559 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10560 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10561 | }, |
| 10562 | .dst_temps = .{.{ .rc = .sse }}, |
| 10563 | .each = .{ .once = &.{ |
| 10564 | .{ ._, .vp_w, .maxu, .dst0y, .src0y, .src1y, ._ }, |
| 10565 | } }, |
| 10566 | }, .{ |
| 10567 | .required_features = .{ .avx2, null, null, null }, |
| 10568 | .src_constraints = .{ |
| 10569 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 10570 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 10571 | .any, |
| 10572 | }, |
| 10573 | .patterns = &.{ |
| 10574 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10575 | }, |
| 10576 | .extra_temps = .{ |
| 10577 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10578 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 10579 | .unused, |
| 10580 | .unused, |
| 10581 | .unused, |
| 10582 | .unused, |
| 10583 | .unused, |
| 10584 | .unused, |
| 10585 | .unused, |
| 10586 | }, |
| 10587 | .dst_temps = .{.mem}, |
| 10588 | .clobbers = .{ .eflags = true }, |
| 10589 | .each = .{ .once = &.{ |
| 10590 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10591 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 10592 | .{ ._, .vp_w, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 10593 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 10594 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 10595 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10596 | } }, |
| 10597 | }, .{ |
| 10598 | .required_features = .{ .avx, null, null, null }, |
| 10599 | .src_constraints = .{ |
| 10600 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10601 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10602 | .any, |
| 10603 | }, |
| 10604 | .patterns = &.{ |
| 10605 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10606 | }, |
| 10607 | .extra_temps = .{ |
| 10608 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10609 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 10610 | .unused, |
| 10611 | .unused, |
| 10612 | .unused, |
| 10613 | .unused, |
| 10614 | .unused, |
| 10615 | .unused, |
| 10616 | .unused, |
| 10617 | }, |
| 10618 | .dst_temps = .{.mem}, |
| 10619 | .clobbers = .{ .eflags = true }, |
| 10620 | .each = .{ .once = &.{ |
| 10621 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10622 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10623 | .{ ._, .vp_w, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 10624 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10625 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10626 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10627 | } }, |
| 10628 | }, .{ |
| 10629 | .required_features = .{ .sse4_1, null, null, null }, |
| 10630 | .src_constraints = .{ |
| 10631 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10632 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10633 | .any, |
| 10634 | }, |
| 10635 | .patterns = &.{ |
| 10636 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10637 | }, |
| 10638 | .extra_temps = .{ |
| 10639 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10640 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 10641 | .unused, |
| 10642 | .unused, |
| 10643 | .unused, |
| 10644 | .unused, |
| 10645 | .unused, |
| 10646 | .unused, |
| 10647 | .unused, |
| 10648 | }, |
| 10649 | .dst_temps = .{.mem}, |
| 10650 | .clobbers = .{ .eflags = true }, |
| 10651 | .each = .{ .once = &.{ |
| 10652 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10653 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10654 | .{ ._, .p_w, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10655 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10656 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10657 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10658 | } }, |
| 10659 | }, .{ |
| 10660 | .required_features = .{ .sse2, null, null, null }, |
| 10661 | .src_constraints = .{ |
| 10662 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10663 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 10664 | .any, |
| 10665 | }, |
| 10666 | .patterns = &.{ |
| 10667 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10668 | }, |
| 10669 | .extra_temps = .{ |
| 10670 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10671 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 10672 | .unused, |
| 10673 | .unused, |
| 10674 | .unused, |
| 10675 | .unused, |
| 10676 | .unused, |
| 10677 | .unused, |
| 10678 | .unused, |
| 10679 | }, |
| 10680 | .dst_temps = .{.mem}, |
| 10681 | .clobbers = .{ .eflags = true }, |
| 10682 | .each = .{ .once = &.{ |
| 10683 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10684 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10685 | .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10686 | .{ ._, .p_w, .add, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10687 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10688 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10689 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10690 | } }, |
| 10691 | }, .{ |
| 10692 | .required_features = .{ .cmov, null, null, null }, |
| 10693 | .src_constraints = .{ |
| 10694 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 10695 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 10696 | .any, |
| 10697 | }, |
| 10698 | .patterns = &.{ |
| 10699 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10700 | }, |
| 10701 | .extra_temps = .{ |
| 10702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10703 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 10704 | .unused, |
| 10705 | .unused, |
| 10706 | .unused, |
| 10707 | .unused, |
| 10708 | .unused, |
| 10709 | .unused, |
| 10710 | .unused, |
| 10711 | }, |
| 10712 | .dst_temps = .{.mem}, |
| 10713 | .clobbers = .{ .eflags = true }, |
| 10714 | .each = .{ .once = &.{ |
| 10715 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10716 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 10717 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10718 | .{ ._, ._b, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10719 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 10720 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 10721 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10722 | } }, |
| 10723 | }, .{ |
| 10724 | .src_constraints = .{ |
| 10725 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 10726 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 10727 | .any, |
| 10728 | }, |
| 10729 | .patterns = &.{ |
| 10730 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10731 | }, |
| 10732 | .extra_temps = .{ |
| 10733 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10734 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 10735 | .unused, |
| 10736 | .unused, |
| 10737 | .unused, |
| 10738 | .unused, |
| 10739 | .unused, |
| 10740 | .unused, |
| 10741 | .unused, |
| 10742 | }, |
| 10743 | .dst_temps = .{.mem}, |
| 10744 | .clobbers = .{ .eflags = true }, |
| 10745 | .each = .{ .once = &.{ |
| 10746 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10747 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 10748 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10749 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 10750 | .{ ._, ._, .mov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 10751 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 10752 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 10753 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10754 | } }, |
| 10755 | }, .{ |
| 10756 | .required_features = .{ .avx, null, null, null }, |
| 10757 | .src_constraints = .{ |
| 10758 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10759 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10760 | .any, |
| 10761 | }, |
| 10762 | .patterns = &.{ |
| 10763 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10764 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10765 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10766 | }, |
| 10767 | .dst_temps = .{.{ .rc = .sse }}, |
| 10768 | .each = .{ .once = &.{ |
| 10769 | .{ ._, .vp_d, .maxs, .dst0x, .src0x, .src1x, ._ }, |
| 10770 | } }, |
| 10771 | }, .{ |
| 10772 | .required_features = .{ .sse4_1, null, null, null }, |
| 10773 | .src_constraints = .{ |
| 10774 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10775 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10776 | .any, |
| 10777 | }, |
| 10778 | .patterns = &.{ |
| 10779 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 10780 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 10781 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 10782 | }, |
| 10783 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10784 | .each = .{ .once = &.{ |
| 10785 | .{ ._, .p_d, .maxs, .dst0x, .src1x, ._, ._ }, |
| 10786 | } }, |
| 10787 | }, .{ |
| 10788 | .required_features = .{ .sse2, null, null, null }, |
| 10789 | .src_constraints = .{ |
| 10790 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10791 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10792 | .any, |
| 10793 | }, |
| 10794 | .patterns = &.{ |
| 10795 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 10796 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 10797 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 10798 | }, |
| 10799 | .dst_temps = .{.{ .rc = .sse }}, |
| 10800 | .each = .{ .once = &.{ |
| 10801 | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| 10802 | .{ ._, .p_d, .cmpgt, .dst0x, .src1x, ._, ._ }, |
| 10803 | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 10804 | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 10805 | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 10806 | } }, |
| 10807 | }, .{ |
| 10808 | .required_features = .{ .avx2, null, null, null }, |
| 10809 | .src_constraints = .{ |
| 10810 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 10811 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 10812 | .any, |
| 10813 | }, |
| 10814 | .patterns = &.{ |
| 10815 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 10816 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 10817 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 10818 | }, |
| 10819 | .dst_temps = .{.{ .rc = .sse }}, |
| 10820 | .each = .{ .once = &.{ |
| 10821 | .{ ._, .vp_d, .maxs, .dst0y, .src0y, .src1y, ._ }, |
| 10822 | } }, |
| 10823 | }, .{ |
| 10824 | .required_features = .{ .avx2, null, null, null }, |
| 10825 | .src_constraints = .{ |
| 10826 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 10827 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 10828 | .any, |
| 10829 | }, |
| 10830 | .patterns = &.{ |
| 10831 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10832 | }, |
| 10833 | .extra_temps = .{ |
| 10834 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10835 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 10836 | .unused, |
| 10837 | .unused, |
| 10838 | .unused, |
| 10839 | .unused, |
| 10840 | .unused, |
| 10841 | .unused, |
| 10842 | .unused, |
| 10843 | }, |
| 10844 | .dst_temps = .{.mem}, |
| 10845 | .clobbers = .{ .eflags = true }, |
| 10846 | .each = .{ .once = &.{ |
| 10847 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10848 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 10849 | .{ ._, .vp_d, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 10850 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 10851 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 10852 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10853 | } }, |
| 10854 | }, .{ |
| 10855 | .required_features = .{ .avx, null, null, null }, |
| 10856 | .src_constraints = .{ |
| 10857 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10858 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10859 | .any, |
| 10860 | }, |
| 10861 | .patterns = &.{ |
| 10862 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10863 | }, |
| 10864 | .extra_temps = .{ |
| 10865 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10866 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 10867 | .unused, |
| 10868 | .unused, |
| 10869 | .unused, |
| 10870 | .unused, |
| 10871 | .unused, |
| 10872 | .unused, |
| 10873 | .unused, |
| 10874 | }, |
| 10875 | .dst_temps = .{.mem}, |
| 10876 | .clobbers = .{ .eflags = true }, |
| 10877 | .each = .{ .once = &.{ |
| 10878 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10879 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10880 | .{ ._, .vp_d, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 10881 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10882 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10883 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10884 | } }, |
| 10885 | }, .{ |
| 10886 | .required_features = .{ .sse4_1, null, null, null }, |
| 10887 | .src_constraints = .{ |
| 10888 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10889 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10890 | .any, |
| 10891 | }, |
| 10892 | .patterns = &.{ |
| 10893 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10894 | }, |
| 10895 | .extra_temps = .{ |
| 10896 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10897 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 10898 | .unused, |
| 10899 | .unused, |
| 10900 | .unused, |
| 10901 | .unused, |
| 10902 | .unused, |
| 10903 | .unused, |
| 10904 | .unused, |
| 10905 | }, |
| 10906 | .dst_temps = .{.mem}, |
| 10907 | .clobbers = .{ .eflags = true }, |
| 10908 | .each = .{ .once = &.{ |
| 10909 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10910 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10911 | .{ ._, .p_d, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10912 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10913 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10914 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10915 | } }, |
| 10916 | }, .{ |
| 10917 | .required_features = .{ .sse2, null, null, null }, |
| 10918 | .src_constraints = .{ |
| 10919 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10920 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 10921 | .any, |
| 10922 | }, |
| 10923 | .patterns = &.{ |
| 10924 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10925 | }, |
| 10926 | .extra_temps = .{ |
| 10927 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10928 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 10929 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 10930 | .unused, |
| 10931 | .unused, |
| 10932 | .unused, |
| 10933 | .unused, |
| 10934 | .unused, |
| 10935 | .unused, |
| 10936 | }, |
| 10937 | .dst_temps = .{.mem}, |
| 10938 | .clobbers = .{ .eflags = true }, |
| 10939 | .each = .{ .once = &.{ |
| 10940 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10941 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 10942 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 10943 | .{ ._, .p_d, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10944 | .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ }, |
| 10945 | .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10946 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, |
| 10947 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 10948 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 10949 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10950 | } }, |
| 10951 | }, .{ |
| 10952 | .required_features = .{ .cmov, null, null, null }, |
| 10953 | .src_constraints = .{ |
| 10954 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 10955 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 10956 | .any, |
| 10957 | }, |
| 10958 | .patterns = &.{ |
| 10959 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10960 | }, |
| 10961 | .extra_temps = .{ |
| 10962 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10963 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 10964 | .unused, |
| 10965 | .unused, |
| 10966 | .unused, |
| 10967 | .unused, |
| 10968 | .unused, |
| 10969 | .unused, |
| 10970 | .unused, |
| 10971 | }, |
| 10972 | .dst_temps = .{.mem}, |
| 10973 | .clobbers = .{ .eflags = true }, |
| 10974 | .each = .{ .once = &.{ |
| 10975 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 10976 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 10977 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 10978 | .{ ._, ._l, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 10979 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 10980 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 10981 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10982 | } }, |
| 10983 | }, .{ |
| 10984 | .src_constraints = .{ |
| 10985 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 10986 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 10987 | .any, |
| 10988 | }, |
| 10989 | .patterns = &.{ |
| 10990 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10991 | }, |
| 10992 | .extra_temps = .{ |
| 10993 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 10994 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 10995 | .unused, |
| 10996 | .unused, |
| 10997 | .unused, |
| 10998 | .unused, |
| 10999 | .unused, |
| 11000 | .unused, |
| 11001 | .unused, |
| 11002 | }, |
| 11003 | .dst_temps = .{.mem}, |
| 11004 | .clobbers = .{ .eflags = true }, |
| 11005 | .each = .{ .once = &.{ |
| 11006 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11007 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 11008 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 11009 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 11010 | .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 11011 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 11012 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 11013 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11014 | } }, |
| 11015 | }, .{ |
| 11016 | .required_features = .{ .avx, null, null, null }, |
| 11017 | .src_constraints = .{ |
| 11018 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11019 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11020 | .any, |
| 11021 | }, |
| 11022 | .patterns = &.{ |
| 11023 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 11024 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 11025 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11026 | }, |
| 11027 | .dst_temps = .{.{ .rc = .sse }}, |
| 11028 | .each = .{ .once = &.{ |
| 11029 | .{ ._, .vp_d, .maxu, .dst0x, .src0x, .src1x, ._ }, |
| 11030 | } }, |
| 11031 | }, .{ |
| 11032 | .required_features = .{ .sse4_1, null, null, null }, |
| 11033 | .src_constraints = .{ |
| 11034 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11035 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11036 | .any, |
| 11037 | }, |
| 11038 | .patterns = &.{ |
| 11039 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 11040 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 11041 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 11042 | }, |
| 11043 | .dst_temps = .{.{ .ref = .src0 }}, |
| 11044 | .each = .{ .once = &.{ |
| 11045 | .{ ._, .p_d, .maxu, .dst0x, .src1x, ._, ._ }, |
| 11046 | } }, |
| 11047 | }, .{ |
| 11048 | .required_features = .{ .sse2, null, null, null }, |
| 11049 | .src_constraints = .{ |
| 11050 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11051 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11052 | .any, |
| 11053 | }, |
| 11054 | .patterns = &.{ |
| 11055 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 11056 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 11057 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 11058 | }, |
| 11059 | .extra_temps = .{ |
| 11060 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 11061 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 11062 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11063 | .unused, |
| 11064 | .unused, |
| 11065 | .unused, |
| 11066 | .unused, |
| 11067 | .unused, |
| 11068 | .unused, |
| 11069 | }, |
| 11070 | .dst_temps = .{.{ .rc = .sse }}, |
| 11071 | .each = .{ .once = &.{ |
| 11072 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11073 | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 11074 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| 11075 | .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ }, |
| 11076 | .{ ._, .p_, .xor, .tmp2x, .src1x, ._, ._ }, |
| 11077 | .{ ._, .p_d, .cmpgt, .dst0x, .tmp2x, ._, ._ }, |
| 11078 | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 11079 | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 11080 | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 11081 | } }, |
| 11082 | }, .{ |
| 11083 | .required_features = .{ .avx2, null, null, null }, |
| 11084 | .src_constraints = .{ |
| 11085 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 11086 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 11087 | .any, |
| 11088 | }, |
| 11089 | .patterns = &.{ |
| 11090 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 11091 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 11092 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11093 | }, |
| 11094 | .dst_temps = .{.{ .rc = .sse }}, |
| 11095 | .each = .{ .once = &.{ |
| 11096 | .{ ._, .vp_d, .maxu, .dst0y, .src0y, .src1y, ._ }, |
| 11097 | } }, |
| 11098 | }, .{ |
| 11099 | .required_features = .{ .avx2, null, null, null }, |
| 11100 | .src_constraints = .{ |
| 11101 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 11102 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 11103 | .any, |
| 11104 | }, |
| 11105 | .patterns = &.{ |
| 11106 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11107 | }, |
| 11108 | .extra_temps = .{ |
| 11109 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11110 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 11111 | .unused, |
| 11112 | .unused, |
| 11113 | .unused, |
| 11114 | .unused, |
| 11115 | .unused, |
| 11116 | .unused, |
| 11117 | .unused, |
| 11118 | }, |
| 11119 | .dst_temps = .{.mem}, |
| 11120 | .clobbers = .{ .eflags = true }, |
| 11121 | .each = .{ .once = &.{ |
| 11122 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11123 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 11124 | .{ ._, .vp_d, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| 11125 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 11126 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 11127 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11128 | } }, |
| 11129 | }, .{ |
| 11130 | .required_features = .{ .avx, null, null, null }, |
| 11131 | .src_constraints = .{ |
| 11132 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11133 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11134 | .any, |
| 11135 | }, |
| 11136 | .patterns = &.{ |
| 11137 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11138 | }, |
| 11139 | .extra_temps = .{ |
| 11140 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11141 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11142 | .unused, |
| 11143 | .unused, |
| 11144 | .unused, |
| 11145 | .unused, |
| 11146 | .unused, |
| 11147 | .unused, |
| 11148 | .unused, |
| 11149 | }, |
| 11150 | .dst_temps = .{.mem}, |
| 11151 | .clobbers = .{ .eflags = true }, |
| 11152 | .each = .{ .once = &.{ |
| 11153 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11154 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11155 | .{ ._, .vp_d, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, |
| 11156 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 11157 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11158 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11159 | } }, |
| 11160 | }, .{ |
| 11161 | .required_features = .{ .sse4_1, null, null, null }, |
| 11162 | .src_constraints = .{ |
| 11163 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11164 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11165 | .any, |
| 11166 | }, |
| 11167 | .patterns = &.{ |
| 11168 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11169 | }, |
| 11170 | .extra_temps = .{ |
| 11171 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11172 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11173 | .unused, |
| 11174 | .unused, |
| 11175 | .unused, |
| 11176 | .unused, |
| 11177 | .unused, |
| 11178 | .unused, |
| 11179 | .unused, |
| 11180 | }, |
| 11181 | .dst_temps = .{.mem}, |
| 11182 | .clobbers = .{ .eflags = true }, |
| 11183 | .each = .{ .once = &.{ |
| 11184 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11185 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11186 | .{ ._, .p_d, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 11187 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 11188 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11189 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11190 | } }, |
| 11191 | }, .{ |
| 11192 | .required_features = .{ .sse2, null, null, null }, |
| 11193 | .src_constraints = .{ |
| 11194 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11195 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 11196 | .any, |
| 11197 | }, |
| 11198 | .patterns = &.{ |
| 11199 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11200 | }, |
| 11201 | .extra_temps = .{ |
| 11202 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11203 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 11204 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11205 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11206 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11207 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11208 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 11209 | .unused, |
| 11210 | .unused, |
| 11211 | }, |
| 11212 | .dst_temps = .{.mem}, |
| 11213 | .clobbers = .{ .eflags = true }, |
| 11214 | .each = .{ .once = &.{ |
| 11215 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11216 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 11217 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11218 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11219 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 11220 | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| 11221 | .{ ._, ._dqa, .mov, .tmp6x, .tmp4x, ._, ._ }, |
| 11222 | .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ }, |
| 11223 | .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ }, |
| 11224 | .{ ._, .p_d, .cmpgt, .tmp5x, .tmp6x, ._, ._ }, |
| 11225 | .{ ._, .p_, .@"and", .tmp3x, .tmp5x, ._, ._ }, |
| 11226 | .{ ._, .p_, .andn, .tmp5x, .tmp4x, ._, ._ }, |
| 11227 | .{ ._, .p_, .@"or", .tmp3x, .tmp5x, ._, ._ }, |
| 11228 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 11229 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11230 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11231 | } }, |
| 11232 | }, .{ |
| 11233 | .required_features = .{ .cmov, null, null, null }, |
| 11234 | .src_constraints = .{ |
| 11235 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 11236 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 11237 | .any, |
| 11238 | }, |
| 11239 | .patterns = &.{ |
| 11240 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11241 | }, |
| 11242 | .extra_temps = .{ |
| 11243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11244 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 11245 | .unused, |
| 11246 | .unused, |
| 11247 | .unused, |
| 11248 | .unused, |
| 11249 | .unused, |
| 11250 | .unused, |
| 11251 | .unused, |
| 11252 | }, |
| 11253 | .dst_temps = .{.mem}, |
| 11254 | .clobbers = .{ .eflags = true }, |
| 11255 | .each = .{ .once = &.{ |
| 11256 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11257 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 11258 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 11259 | .{ ._, ._b, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 11260 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 11261 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 11262 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11263 | } }, |
| 11264 | }, .{ |
| 11265 | .src_constraints = .{ |
| 11266 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 11267 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 11268 | .any, |
| 11269 | }, |
| 11270 | .patterns = &.{ |
| 11271 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11272 | }, |
| 11273 | .extra_temps = .{ |
| 11274 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11275 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 11276 | .unused, |
| 11277 | .unused, |
| 11278 | .unused, |
| 11279 | .unused, |
| 11280 | .unused, |
| 11281 | .unused, |
| 11282 | .unused, |
| 11283 | }, |
| 11284 | .dst_temps = .{.mem}, |
| 11285 | .clobbers = .{ .eflags = true }, |
| 11286 | .each = .{ .once = &.{ |
| 11287 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11288 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 11289 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 11290 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 11291 | .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 11292 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 11293 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 11294 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11295 | } }, |
| 11296 | }, .{ |
| 11297 | .required_features = .{ .avx, null, null, null }, |
| 11298 | .src_constraints = .{ |
| 11299 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11300 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11301 | .any, |
| 11302 | }, |
| 11303 | .patterns = &.{ |
| 11304 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11305 | }, |
| 11306 | .dst_temps = .{.{ .rc = .sse }}, |
| 11307 | .each = .{ .once = &.{ |
| 11308 | .{ ._, .vp_q, .cmpgt, .dst0x, .src1x, .src0x, ._ }, |
| 11309 | .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x }, |
| 11310 | } }, |
| 11311 | }, .{ |
| 11312 | .required_features = .{ .sse4_2, null, null, null }, |
| 11313 | .src_constraints = .{ |
| 11314 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11315 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11316 | .any, |
| 11317 | }, |
| 11318 | .patterns = &.{ |
| 11319 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 11320 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 11321 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 11322 | }, |
| 11323 | .extra_temps = .{ |
| 11324 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| 11325 | .unused, |
| 11326 | .unused, |
| 11327 | .unused, |
| 11328 | .unused, |
| 11329 | .unused, |
| 11330 | .unused, |
| 11331 | .unused, |
| 11332 | .unused, |
| 11333 | }, |
| 11334 | .dst_temps = .{.{ .ref = .src0 }}, |
| 11335 | .each = .{ .once = &.{ |
| 11336 | .{ ._, ._dqa, .mov, .tmp0x, .src1x, ._, ._ }, |
| 11337 | .{ ._, .p_q, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 11338 | .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp0x, ._ }, |
| 11339 | } }, |
| 11340 | }, .{ |
| 11341 | .required_features = .{ .avx2, null, null, null }, |
| 11342 | .src_constraints = .{ |
| 11343 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 11344 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 11345 | .any, |
| 11346 | }, |
| 11347 | .patterns = &.{ |
| 11348 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11349 | }, |
| 11350 | .dst_temps = .{.{ .rc = .sse }}, |
| 11351 | .each = .{ .once = &.{ |
| 11352 | .{ ._, .vp_q, .cmpgt, .dst0y, .src1y, .src0y, ._ }, |
| 11353 | .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y }, |
| 11354 | } }, |
| 11355 | }, .{ |
| 11356 | .required_features = .{ .avx2, null, null, null }, |
| 11357 | .src_constraints = .{ |
| 11358 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 11359 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 11360 | .any, |
| 11361 | }, |
| 11362 | .patterns = &.{ |
| 11363 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11364 | }, |
| 11365 | .extra_temps = .{ |
| 11366 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11367 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 11368 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 11369 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 11370 | .unused, |
| 11371 | .unused, |
| 11372 | .unused, |
| 11373 | .unused, |
| 11374 | .unused, |
| 11375 | }, |
| 11376 | .dst_temps = .{.mem}, |
| 11377 | .clobbers = .{ .eflags = true }, |
| 11378 | .each = .{ .once = &.{ |
| 11379 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11380 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 11381 | .{ ._, .v_dqa, .mov, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 11382 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .tmp1y, ._ }, |
| 11383 | .{ ._, .vp_b, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 11384 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 11385 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 11386 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11387 | } }, |
| 11388 | }, .{ |
| 11389 | .required_features = .{ .avx, null, null, null }, |
| 11390 | .src_constraints = .{ |
| 11391 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11392 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11393 | .any, |
| 11394 | }, |
| 11395 | .patterns = &.{ |
| 11396 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11397 | }, |
| 11398 | .extra_temps = .{ |
| 11399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11400 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 11401 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 11402 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 11403 | .unused, |
| 11404 | .unused, |
| 11405 | .unused, |
| 11406 | .unused, |
| 11407 | .unused, |
| 11408 | }, |
| 11409 | .dst_temps = .{.mem}, |
| 11410 | .clobbers = .{ .eflags = true }, |
| 11411 | .each = .{ .once = &.{ |
| 11412 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11413 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11414 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 11415 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 11416 | .{ ._, .vp_b, .blendv, .tmp1x, .tmp1x, .tmp2x, .tmp3x }, |
| 11417 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 11418 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11419 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11420 | } }, |
| 11421 | }, .{ |
| 11422 | .required_features = .{ .sse4_2, null, null, null }, |
| 11423 | .src_constraints = .{ |
| 11424 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11425 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 11426 | .any, |
| 11427 | }, |
| 11428 | .patterns = &.{ |
| 11429 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11430 | }, |
| 11431 | .extra_temps = .{ |
| 11432 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11433 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 11434 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 11435 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| 11436 | .unused, |
| 11437 | .unused, |
| 11438 | .unused, |
| 11439 | .unused, |
| 11440 | .unused, |
| 11441 | }, |
| 11442 | .dst_temps = .{.mem}, |
| 11443 | .clobbers = .{ .eflags = true }, |
| 11444 | .each = .{ .once = &.{ |
| 11445 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11446 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11447 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 11448 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 11449 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp1x, ._, ._ }, |
| 11450 | .{ ._, .p_b, .blendv, .tmp1x, .tmp2x, .tmp3x, ._ }, |
| 11451 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 11452 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11453 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11454 | } }, |
| 11455 | }, .{ |
| 11456 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 11457 | .src_constraints = .{ |
| 11458 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 11459 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 11460 | .any, |
| 11461 | }, |
| 11462 | .patterns = &.{ |
| 11463 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11464 | }, |
| 11465 | .extra_temps = .{ |
| 11466 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11467 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 11468 | .unused, |
| 11469 | .unused, |
| 11470 | .unused, |
| 11471 | .unused, |
| 11472 | .unused, |
| 11473 | .unused, |
| 11474 | .unused, |
| 11475 | }, |
| 11476 | .dst_temps = .{.mem}, |
| 11477 | .clobbers = .{ .eflags = true }, |
| 11478 | .each = .{ .once = &.{ |
| 11479 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11480 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11481 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11482 | .{ ._, ._l, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11483 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 11484 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 11485 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11486 | } }, |
| 11487 | }, .{ |
| 11488 | .required_features = .{ .@"64bit", null, null, null }, |
| 11489 | .src_constraints = .{ |
| 11490 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 11491 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 11492 | .any, |
| 11493 | }, |
| 11494 | .patterns = &.{ |
| 11495 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11496 | }, |
| 11497 | .extra_temps = .{ |
| 11498 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11499 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 11500 | .unused, |
| 11501 | .unused, |
| 11502 | .unused, |
| 11503 | .unused, |
| 11504 | .unused, |
| 11505 | .unused, |
| 11506 | .unused, |
| 11507 | }, |
| 11508 | .dst_temps = .{.mem}, |
| 11509 | .clobbers = .{ .eflags = true }, |
| 11510 | .each = .{ .once = &.{ |
| 11511 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11512 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11513 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11514 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 11515 | .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11516 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 11517 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 11518 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11519 | } }, |
| 11520 | }, .{ |
| 11521 | .required_features = .{ .avx, null, null, null }, |
| 11522 | .src_constraints = .{ |
| 11523 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11524 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11525 | .any, |
| 11526 | }, |
| 11527 | .patterns = &.{ |
| 11528 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 11529 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 11530 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11531 | }, |
| 11532 | .extra_temps = .{ |
| 11533 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 11534 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 11535 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11536 | .unused, |
| 11537 | .unused, |
| 11538 | .unused, |
| 11539 | .unused, |
| 11540 | .unused, |
| 11541 | .unused, |
| 11542 | }, |
| 11543 | .dst_temps = .{.{ .rc = .sse }}, |
| 11544 | .each = .{ .once = &.{ |
| 11545 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11546 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 11547 | .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ }, |
| 11548 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .src1x, ._ }, |
| 11549 | .{ ._, .vp_q, .cmpgt, .dst0x, .tmp2x, .dst0x, ._ }, |
| 11550 | .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x }, |
| 11551 | } }, |
| 11552 | }, .{ |
| 11553 | .required_features = .{ .sse4_2, null, null, null }, |
| 11554 | .src_constraints = .{ |
| 11555 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11556 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11557 | .any, |
| 11558 | }, |
| 11559 | .patterns = &.{ |
| 11560 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 11561 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 11562 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 11563 | }, |
| 11564 | .extra_temps = .{ |
| 11565 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 11566 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 11567 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11568 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 11569 | .unused, |
| 11570 | .unused, |
| 11571 | .unused, |
| 11572 | .unused, |
| 11573 | .unused, |
| 11574 | }, |
| 11575 | .dst_temps = .{.{ .ref = .src0 }}, |
| 11576 | .each = .{ .once = &.{ |
| 11577 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11578 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 11579 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 11580 | .{ ._, .p_, .xor, .tmp2x, .src0x, ._, ._ }, |
| 11581 | .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ }, |
| 11582 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| 11583 | .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp3x, ._ }, |
| 11584 | } }, |
| 11585 | }, .{ |
| 11586 | .required_features = .{ .avx2, null, null, null }, |
| 11587 | .src_constraints = .{ |
| 11588 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 11589 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 11590 | .any, |
| 11591 | }, |
| 11592 | .patterns = &.{ |
| 11593 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 11594 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 11595 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11596 | }, |
| 11597 | .extra_temps = .{ |
| 11598 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 11599 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 11600 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 11601 | .unused, |
| 11602 | .unused, |
| 11603 | .unused, |
| 11604 | .unused, |
| 11605 | .unused, |
| 11606 | .unused, |
| 11607 | }, |
| 11608 | .dst_temps = .{.{ .rc = .sse }}, |
| 11609 | .each = .{ .once = &.{ |
| 11610 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11611 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| 11612 | .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ }, |
| 11613 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .src1y, ._ }, |
| 11614 | .{ ._, .vp_q, .cmpgt, .dst0y, .tmp2y, .dst0y, ._ }, |
| 11615 | .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y }, |
| 11616 | } }, |
| 11617 | }, .{ |
| 11618 | .required_features = .{ .avx2, null, null, null }, |
| 11619 | .src_constraints = .{ |
| 11620 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 11621 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 11622 | .any, |
| 11623 | }, |
| 11624 | .patterns = &.{ |
| 11625 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11626 | }, |
| 11627 | .extra_temps = .{ |
| 11628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11629 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 11630 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 11631 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 11632 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 11633 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 11634 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 11635 | .unused, |
| 11636 | .unused, |
| 11637 | }, |
| 11638 | .dst_temps = .{.mem}, |
| 11639 | .clobbers = .{ .eflags = true }, |
| 11640 | .each = .{ .once = &.{ |
| 11641 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11642 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| 11643 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11644 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 11645 | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 11646 | .{ ._, .vp_, .xor, .tmp5y, .tmp3y, .tmp2y, ._ }, |
| 11647 | .{ ._, .vp_, .xor, .tmp6y, .tmp4y, .tmp2y, ._ }, |
| 11648 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp6y, .tmp5y, ._ }, |
| 11649 | .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp4y, .tmp5y }, |
| 11650 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 11651 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 11652 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11653 | } }, |
| 11654 | }, .{ |
| 11655 | .required_features = .{ .avx, null, null, null }, |
| 11656 | .src_constraints = .{ |
| 11657 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11658 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11659 | .any, |
| 11660 | }, |
| 11661 | .patterns = &.{ |
| 11662 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11663 | }, |
| 11664 | .extra_temps = .{ |
| 11665 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11666 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 11667 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11668 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11669 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11670 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11671 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11672 | .unused, |
| 11673 | .unused, |
| 11674 | }, |
| 11675 | .dst_temps = .{.mem}, |
| 11676 | .clobbers = .{ .eflags = true }, |
| 11677 | .each = .{ .once = &.{ |
| 11678 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11679 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 11680 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11681 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11682 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 11683 | .{ ._, .vp_, .xor, .tmp5x, .tmp3x, .tmp2x, ._ }, |
| 11684 | .{ ._, .vp_, .xor, .tmp6x, .tmp4x, .tmp2x, ._ }, |
| 11685 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp6x, .tmp5x, ._ }, |
| 11686 | .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp4x, .tmp5x }, |
| 11687 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 11688 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11689 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11690 | } }, |
| 11691 | }, .{ |
| 11692 | .required_features = .{ .sse4_2, null, null, null }, |
| 11693 | .src_constraints = .{ |
| 11694 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11695 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 11696 | .any, |
| 11697 | }, |
| 11698 | .patterns = &.{ |
| 11699 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11700 | }, |
| 11701 | .extra_temps = .{ |
| 11702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11703 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 11704 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11705 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11706 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11707 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 11708 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 11709 | .unused, |
| 11710 | .unused, |
| 11711 | }, |
| 11712 | .dst_temps = .{.mem}, |
| 11713 | .clobbers = .{ .eflags = true }, |
| 11714 | .each = .{ .once = &.{ |
| 11715 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 11716 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 11717 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11718 | .{ .@"0:", ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ }, |
| 11719 | .{ ._, ._dqa, .mov, .tmp6x, .tmp2x, ._, ._ }, |
| 11720 | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 11721 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 11722 | .{ ._, .p_, .xor, .tmp5x, .tmp3x, ._, ._ }, |
| 11723 | .{ ._, .p_, .xor, .tmp6x, .tmp4x, ._, ._ }, |
| 11724 | .{ ._, .p_q, .cmpgt, .tmp6x, .tmp5x, ._, ._ }, |
| 11725 | .{ ._, .p_b, .blendv, .tmp3x, .tmp4x, .tmp6x, ._ }, |
| 11726 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 11727 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 11728 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11729 | } }, |
| 11730 | }, .{ |
| 11731 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 11732 | .src_constraints = .{ |
| 11733 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 11734 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 11735 | .any, |
| 11736 | }, |
| 11737 | .patterns = &.{ |
| 11738 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11739 | }, |
| 11740 | .extra_temps = .{ |
| 11741 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11742 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 11743 | .unused, |
| 11744 | .unused, |
| 11745 | .unused, |
| 11746 | .unused, |
| 11747 | .unused, |
| 11748 | .unused, |
| 11749 | .unused, |
| 11750 | }, |
| 11751 | .dst_temps = .{.mem}, |
| 11752 | .clobbers = .{ .eflags = true }, |
| 11753 | .each = .{ .once = &.{ |
| 11754 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11755 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11756 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11757 | .{ ._, ._b, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11758 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 11759 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 11760 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11761 | } }, |
| 11762 | }, .{ |
| 11763 | .required_features = .{ .@"64bit", null, null, null }, |
| 11764 | .src_constraints = .{ |
| 11765 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 11766 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 11767 | .any, |
| 11768 | }, |
| 11769 | .patterns = &.{ |
| 11770 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11771 | }, |
| 11772 | .extra_temps = .{ |
| 11773 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11774 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 11775 | .unused, |
| 11776 | .unused, |
| 11777 | .unused, |
| 11778 | .unused, |
| 11779 | .unused, |
| 11780 | .unused, |
| 11781 | .unused, |
| 11782 | }, |
| 11783 | .dst_temps = .{.mem}, |
| 11784 | .clobbers = .{ .eflags = true }, |
| 11785 | .each = .{ .once = &.{ |
| 11786 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11787 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11788 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11789 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 11790 | .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11791 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 11792 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 11793 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11794 | } }, |
| 11795 | }, .{ |
| 11796 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 11797 | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any }, |
| 11798 | .patterns = &.{ |
| 11799 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11800 | }, |
| 11801 | .extra_temps = .{ |
| 11802 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11803 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 11804 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 11805 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 11806 | .unused, |
| 11807 | .unused, |
| 11808 | .unused, |
| 11809 | .unused, |
| 11810 | .unused, |
| 11811 | }, |
| 11812 | .dst_temps = .{.mem}, |
| 11813 | .clobbers = .{ .eflags = true }, |
| 11814 | .each = .{ .once = &.{ |
| 11815 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11816 | .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11817 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 11818 | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11819 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11820 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 11821 | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 11822 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 11823 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11824 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11825 | .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 11826 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 11827 | .{ ._, ._l, .cmov, .tmp1p, .tmp2p, ._, ._ }, |
| 11828 | .{ ._, ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 11829 | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11830 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 11831 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 11832 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11833 | } }, |
| 11834 | }, .{ |
| 11835 | .required_features = .{ .@"64bit", null, null, null }, |
| 11836 | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any }, |
| 11837 | .patterns = &.{ |
| 11838 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11839 | }, |
| 11840 | .extra_temps = .{ |
| 11841 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11842 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 11843 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 11844 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 11845 | .unused, |
| 11846 | .unused, |
| 11847 | .unused, |
| 11848 | .unused, |
| 11849 | .unused, |
| 11850 | }, |
| 11851 | .dst_temps = .{.mem}, |
| 11852 | .clobbers = .{ .eflags = true }, |
| 11853 | .each = .{ .once = &.{ |
| 11854 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11855 | .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11856 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 11857 | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11858 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11859 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 11860 | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 11861 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 11862 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11863 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11864 | .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 11865 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, |
| 11866 | .{ ._, ._, .lea, .tmp1p, .memiad(.src1, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 11867 | .{ .@"1:", ._, .lea, .tmp2p, .memiad(.dst0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, |
| 11868 | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11869 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 11870 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 11871 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 11872 | } }, |
| 11873 | }, .{ |
| 11874 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 11875 | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any }, |
| 11876 | .patterns = &.{ |
| 11877 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11878 | }, |
| 11879 | .extra_temps = .{ |
| 11880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11881 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 11882 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 11883 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 11884 | .unused, |
| 11885 | .unused, |
| 11886 | .unused, |
| 11887 | .unused, |
| 11888 | .unused, |
| 11889 | }, |
| 11890 | .dst_temps = .{.mem}, |
| 11891 | .clobbers = .{ .eflags = true }, |
| 11892 | .each = .{ .once = &.{ |
| 11893 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11894 | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11895 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 11896 | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11897 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11898 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 11899 | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 11900 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 11901 | .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 11902 | .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 11903 | .{ ._, ._b, .cmov, .tmp1p, .tmp2p, ._, ._ }, |
| 11904 | .{ ._, ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 11905 | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11906 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 11907 | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, |
| 11908 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 11909 | } }, |
| 11910 | }, .{ |
| 11911 | .required_features = .{ .@"64bit", null, null, null }, |
| 11912 | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any }, |
| 11913 | .patterns = &.{ |
| 11914 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 11915 | }, |
| 11916 | .extra_temps = .{ |
| 11917 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 11918 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 11919 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 11920 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 11921 | .unused, |
| 11922 | .unused, |
| 11923 | .unused, |
| 11924 | .unused, |
| 11925 | .unused, |
| 11926 | }, |
| 11927 | .dst_temps = .{.mem}, |
| 11928 | .clobbers = .{ .eflags = true }, |
| 11929 | .each = .{ .once = &.{ |
| 11930 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 11931 | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11932 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 11933 | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 11934 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 11935 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, |
| 11936 | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, |
| 11937 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 11938 | .{ ._, ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 11939 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, |
| 11940 | .{ ._, ._, .lea, .tmp1p, .memia(.src1, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 11941 | .{ .@"1:", ._, .lea, .tmp2p, .memia(.dst0, .tmp0, .add_size_sub_elem_size), ._, ._ }, |
| 11942 | .{ ._, ._, .mov, .tmp3d, .sa(.none, .add_src0_elem_size_div_8), ._, ._ }, |
| 11943 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 11944 | .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, |
| 11945 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 11946 | } }, |
| 11947 | }, .{ |
| 11948 | .required_features = .{ .f16c, null, null, null }, |
| 11949 | .src_constraints = .{ |
| 11950 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 11951 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 11952 | .any, |
| 11953 | }, |
| 11954 | .patterns = &.{ |
| 11955 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 11956 | }, |
| 11957 | .extra_temps = .{ |
| 11958 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 11959 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 11960 | .unused, |
| 11961 | .unused, |
| 11962 | .unused, |
| 11963 | .unused, |
| 11964 | .unused, |
| 11965 | .unused, |
| 11966 | .unused, |
| 11967 | }, |
| 11968 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 11969 | .each = .{ .once = &.{ |
| 11970 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 11971 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 11972 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0d, .dst0x, .vp(.unord) }, |
| 11973 | .{ ._, .v_ss, .max, .dst0x, .tmp0d, .dst0x, ._ }, |
| 11974 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 11975 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 11976 | } }, |
| 11977 | }, .{ |
| 11978 | .required_features = .{ .sse, null, null, null }, |
| 11979 | .src_constraints = .{ |
| 11980 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 11981 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 11982 | .any, |
| 11983 | }, |
| 11984 | .patterns = &.{ |
| 11985 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 11986 | }, |
| 11987 | .call_frame = .{ .alignment = .@"16" }, |
| 11988 | .extra_temps = .{ |
| 11989 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 11990 | .unused, |
| 11991 | .unused, |
| 11992 | .unused, |
| 11993 | .unused, |
| 11994 | .unused, |
| 11995 | .unused, |
| 11996 | .unused, |
| 11997 | .unused, |
| 11998 | }, |
| 11999 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12000 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12001 | .each = .{ .once = &.{ |
| 12002 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 12003 | } }, |
| 12004 | }, .{ |
| 12005 | .required_features = .{ .f16c, null, null, null }, |
| 12006 | .src_constraints = .{ |
| 12007 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 12008 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 12009 | .any, |
| 12010 | }, |
| 12011 | .patterns = &.{ |
| 12012 | .{ .src = .{ .mem, .mem, .none } }, |
| 12013 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 12014 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 12015 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12016 | }, |
| 12017 | .extra_temps = .{ |
| 12018 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 12019 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12020 | .unused, |
| 12021 | .unused, |
| 12022 | .unused, |
| 12023 | .unused, |
| 12024 | .unused, |
| 12025 | .unused, |
| 12026 | .unused, |
| 12027 | }, |
| 12028 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12029 | .each = .{ .once = &.{ |
| 12030 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 12031 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 12032 | .{ ._, .v_ps, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 12033 | .{ ._, .v_ps, .max, .dst0x, .tmp0x, .dst0x, ._ }, |
| 12034 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 12035 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 12036 | } }, |
| 12037 | }, .{ |
| 12038 | .required_features = .{ .f16c, null, null, null }, |
| 12039 | .src_constraints = .{ |
| 12040 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 12041 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 12042 | .any, |
| 12043 | }, |
| 12044 | .patterns = &.{ |
| 12045 | .{ .src = .{ .mem, .mem, .none } }, |
| 12046 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 12047 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 12048 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12049 | }, |
| 12050 | .extra_temps = .{ |
| 12051 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 12052 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12053 | .unused, |
| 12054 | .unused, |
| 12055 | .unused, |
| 12056 | .unused, |
| 12057 | .unused, |
| 12058 | .unused, |
| 12059 | .unused, |
| 12060 | }, |
| 12061 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12062 | .each = .{ .once = &.{ |
| 12063 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 12064 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 12065 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, |
| 12066 | .{ ._, .v_ps, .max, .dst0y, .tmp0y, .dst0y, ._ }, |
| 12067 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, |
| 12068 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 12069 | } }, |
| 12070 | }, .{ |
| 12071 | .required_features = .{ .f16c, null, null, null }, |
| 12072 | .src_constraints = .{ |
| 12073 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 12074 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 12075 | .any, |
| 12076 | }, |
| 12077 | .patterns = &.{ |
| 12078 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12079 | }, |
| 12080 | .extra_temps = .{ |
| 12081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12082 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12083 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12084 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12085 | .unused, |
| 12086 | .unused, |
| 12087 | .unused, |
| 12088 | .unused, |
| 12089 | .unused, |
| 12090 | }, |
| 12091 | .dst_temps = .{.mem}, |
| 12092 | .clobbers = .{ .eflags = true }, |
| 12093 | .each = .{ .once = &.{ |
| 12094 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12095 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 12096 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 12097 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 12098 | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 12099 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 12100 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_size), .tmp1y, .rm(.{}), ._ }, |
| 12101 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 12102 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12103 | } }, |
| 12104 | }, .{ |
| 12105 | .required_features = .{ .avx, null, null, null }, |
| 12106 | .src_constraints = .{ |
| 12107 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12108 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12109 | .any, |
| 12110 | }, |
| 12111 | .patterns = &.{ |
| 12112 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12113 | }, |
| 12114 | .call_frame = .{ .alignment = .@"16" }, |
| 12115 | .extra_temps = .{ |
| 12116 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12117 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 12118 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 12119 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 12120 | .unused, |
| 12121 | .unused, |
| 12122 | .unused, |
| 12123 | .unused, |
| 12124 | .unused, |
| 12125 | }, |
| 12126 | .dst_temps = .{.mem}, |
| 12127 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12128 | .each = .{ .once = &.{ |
| 12129 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12130 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 12131 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_size), .ui(0) }, |
| 12132 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0) }, |
| 12133 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 12134 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 12135 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 12136 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12137 | } }, |
| 12138 | }, .{ |
| 12139 | .required_features = .{ .sse4_1, null, null, null }, |
| 12140 | .src_constraints = .{ |
| 12141 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12142 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12143 | .any, |
| 12144 | }, |
| 12145 | .patterns = &.{ |
| 12146 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12147 | }, |
| 12148 | .call_frame = .{ .alignment = .@"16" }, |
| 12149 | .extra_temps = .{ |
| 12150 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12151 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 12152 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 12153 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 12154 | .unused, |
| 12155 | .unused, |
| 12156 | .unused, |
| 12157 | .unused, |
| 12158 | .unused, |
| 12159 | }, |
| 12160 | .dst_temps = .{.mem}, |
| 12161 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12162 | .each = .{ .once = &.{ |
| 12163 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12164 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 12165 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 12166 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 12167 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 12168 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 12169 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, |
| 12170 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 12171 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12172 | } }, |
| 12173 | }, .{ |
| 12174 | .required_features = .{ .sse2, null, null, null }, |
| 12175 | .src_constraints = .{ |
| 12176 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12177 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12178 | .any, |
| 12179 | }, |
| 12180 | .patterns = &.{ |
| 12181 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12182 | }, |
| 12183 | .call_frame = .{ .alignment = .@"16" }, |
| 12184 | .extra_temps = .{ |
| 12185 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12186 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 12187 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 12188 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 12189 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 12190 | .unused, |
| 12191 | .unused, |
| 12192 | .unused, |
| 12193 | .unused, |
| 12194 | }, |
| 12195 | .dst_temps = .{.mem}, |
| 12196 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12197 | .each = .{ .once = &.{ |
| 12198 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12199 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 12200 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 12201 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, |
| 12202 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, |
| 12203 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 12204 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 12205 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ }, |
| 12206 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 12207 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12208 | } }, |
| 12209 | }, .{ |
| 12210 | .required_features = .{ .sse, null, null, null }, |
| 12211 | .src_constraints = .{ |
| 12212 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12213 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 12214 | .any, |
| 12215 | }, |
| 12216 | .patterns = &.{ |
| 12217 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12218 | }, |
| 12219 | .call_frame = .{ .alignment = .@"16" }, |
| 12220 | .extra_temps = .{ |
| 12221 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12222 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 12223 | .{ .type = .f32, .kind = .mem }, |
| 12224 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 12225 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 12226 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, |
| 12227 | .unused, |
| 12228 | .unused, |
| 12229 | .unused, |
| 12230 | }, |
| 12231 | .dst_temps = .{.mem}, |
| 12232 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12233 | .each = .{ .once = &.{ |
| 12234 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12235 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 12236 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 12237 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 12238 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 12239 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 12240 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 12241 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 12242 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 12243 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 12244 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 12245 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 12246 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12247 | } }, |
| 12248 | }, .{ |
| 12249 | .required_features = .{ .avx, null, null, null }, |
| 12250 | .src_constraints = .{ |
| 12251 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 12252 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 12253 | .any, |
| 12254 | }, |
| 12255 | .patterns = &.{ |
| 12256 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12257 | }, |
| 12258 | .extra_temps = .{ |
| 12259 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 12260 | .unused, |
| 12261 | .unused, |
| 12262 | .unused, |
| 12263 | .unused, |
| 12264 | .unused, |
| 12265 | .unused, |
| 12266 | .unused, |
| 12267 | .unused, |
| 12268 | }, |
| 12269 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12270 | .each = .{ .once = &.{ |
| 12271 | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0d, .vp(.unord) }, |
| 12272 | .{ ._, .v_ss, .max, .dst0x, .src1x, .src0d, ._ }, |
| 12273 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 12274 | } }, |
| 12275 | }, .{ |
| 12276 | .required_features = .{ .sse4_1, null, null, null }, |
| 12277 | .src_constraints = .{ |
| 12278 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 12279 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 12280 | .any, |
| 12281 | }, |
| 12282 | .patterns = &.{ |
| 12283 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 12284 | }, |
| 12285 | .dst_temps = .{.{ .rc = .sse }}, |
| 12286 | .each = .{ .once = &.{ |
| 12287 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 12288 | .{ ._, ._ss, .max, .dst0x, .src0d, ._, ._ }, |
| 12289 | .{ ._, ._ss, .cmp, .src0x, .src0d, .sp(.unord), ._ }, |
| 12290 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 12291 | } }, |
| 12292 | }, .{ |
| 12293 | .required_features = .{ .sse, null, null, null }, |
| 12294 | .src_constraints = .{ |
| 12295 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 12296 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 12297 | .any, |
| 12298 | }, |
| 12299 | .patterns = &.{ |
| 12300 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 12301 | }, |
| 12302 | .extra_temps = .{ |
| 12303 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12304 | .unused, |
| 12305 | .unused, |
| 12306 | .unused, |
| 12307 | .unused, |
| 12308 | .unused, |
| 12309 | .unused, |
| 12310 | .unused, |
| 12311 | .unused, |
| 12312 | }, |
| 12313 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12314 | .each = .{ .once = &.{ |
| 12315 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 12316 | .{ ._, ._ss, .max, .tmp0x, .src0d, ._, ._ }, |
| 12317 | .{ ._, ._ss, .cmp, .dst0x, .src0d, .sp(.ord), ._ }, |
| 12318 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 12319 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 12320 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 12321 | } }, |
| 12322 | }, .{ |
| 12323 | .required_features = .{ .avx, null, null, null }, |
| 12324 | .src_constraints = .{ |
| 12325 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12326 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12327 | .any, |
| 12328 | }, |
| 12329 | .patterns = &.{ |
| 12330 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12331 | }, |
| 12332 | .extra_temps = .{ |
| 12333 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12334 | .unused, |
| 12335 | .unused, |
| 12336 | .unused, |
| 12337 | .unused, |
| 12338 | .unused, |
| 12339 | .unused, |
| 12340 | .unused, |
| 12341 | .unused, |
| 12342 | }, |
| 12343 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12344 | .each = .{ .once = &.{ |
| 12345 | .{ ._, .v_ps, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 12346 | .{ ._, .v_ps, .max, .dst0x, .src1x, .src0x, ._ }, |
| 12347 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 12348 | } }, |
| 12349 | }, .{ |
| 12350 | .required_features = .{ .sse4_1, null, null, null }, |
| 12351 | .src_constraints = .{ |
| 12352 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12353 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12354 | .any, |
| 12355 | }, |
| 12356 | .patterns = &.{ |
| 12357 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| 12358 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } }, |
| 12359 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 12360 | }, |
| 12361 | .dst_temps = .{.{ .rc = .sse }}, |
| 12362 | .each = .{ .once = &.{ |
| 12363 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 12364 | .{ ._, ._ps, .max, .dst0x, .src0x, ._, ._ }, |
| 12365 | .{ ._, ._ps, .cmp, .src0x, .src0x, .sp(.unord), ._ }, |
| 12366 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 12367 | } }, |
| 12368 | }, .{ |
| 12369 | .required_features = .{ .sse, null, null, null }, |
| 12370 | .src_constraints = .{ |
| 12371 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12372 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12373 | .any, |
| 12374 | }, |
| 12375 | .patterns = &.{ |
| 12376 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 12377 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 12378 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 12379 | }, |
| 12380 | .extra_temps = .{ |
| 12381 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12382 | .unused, |
| 12383 | .unused, |
| 12384 | .unused, |
| 12385 | .unused, |
| 12386 | .unused, |
| 12387 | .unused, |
| 12388 | .unused, |
| 12389 | .unused, |
| 12390 | }, |
| 12391 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12392 | .each = .{ .once = &.{ |
| 12393 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 12394 | .{ ._, ._ps, .max, .tmp0x, .src0x, ._, ._ }, |
| 12395 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .sp(.ord), ._ }, |
| 12396 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 12397 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 12398 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 12399 | } }, |
| 12400 | }, .{ |
| 12401 | .required_features = .{ .avx, null, null, null }, |
| 12402 | .src_constraints = .{ |
| 12403 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 12404 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 12405 | .any, |
| 12406 | }, |
| 12407 | .patterns = &.{ |
| 12408 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12409 | }, |
| 12410 | .extra_temps = .{ |
| 12411 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12412 | .unused, |
| 12413 | .unused, |
| 12414 | .unused, |
| 12415 | .unused, |
| 12416 | .unused, |
| 12417 | .unused, |
| 12418 | .unused, |
| 12419 | .unused, |
| 12420 | }, |
| 12421 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12422 | .each = .{ .once = &.{ |
| 12423 | .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 12424 | .{ ._, .v_ps, .max, .dst0y, .src1y, .src0y, ._ }, |
| 12425 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 12426 | } }, |
| 12427 | }, .{ |
| 12428 | .required_features = .{ .avx, null, null, null }, |
| 12429 | .src_constraints = .{ |
| 12430 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 12431 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 12432 | .any, |
| 12433 | }, |
| 12434 | .patterns = &.{ |
| 12435 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12436 | }, |
| 12437 | .extra_temps = .{ |
| 12438 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12439 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12440 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12441 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 12442 | .unused, |
| 12443 | .unused, |
| 12444 | .unused, |
| 12445 | .unused, |
| 12446 | .unused, |
| 12447 | }, |
| 12448 | .dst_temps = .{.mem}, |
| 12449 | .clobbers = .{ .eflags = true }, |
| 12450 | .each = .{ .once = &.{ |
| 12451 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12452 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 12453 | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 12454 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 12455 | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 12456 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 12457 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 12458 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 12459 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12460 | } }, |
| 12461 | }, .{ |
| 12462 | .required_features = .{ .sse4_1, null, null, null }, |
| 12463 | .src_constraints = .{ |
| 12464 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12465 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12466 | .any, |
| 12467 | }, |
| 12468 | .patterns = &.{ |
| 12469 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12470 | }, |
| 12471 | .extra_temps = .{ |
| 12472 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12473 | .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } }, |
| 12474 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12475 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12476 | .unused, |
| 12477 | .unused, |
| 12478 | .unused, |
| 12479 | .unused, |
| 12480 | .unused, |
| 12481 | }, |
| 12482 | .dst_temps = .{.mem}, |
| 12483 | .clobbers = .{ .eflags = true }, |
| 12484 | .each = .{ .once = &.{ |
| 12485 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12486 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 12487 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 12488 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 12489 | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 12490 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ }, |
| 12491 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 12492 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 12493 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 12494 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12495 | } }, |
| 12496 | }, .{ |
| 12497 | .required_features = .{ .sse, null, null, null }, |
| 12498 | .src_constraints = .{ |
| 12499 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12500 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 12501 | .any, |
| 12502 | }, |
| 12503 | .patterns = &.{ |
| 12504 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12505 | }, |
| 12506 | .extra_temps = .{ |
| 12507 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12508 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12509 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12510 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 12511 | .unused, |
| 12512 | .unused, |
| 12513 | .unused, |
| 12514 | .unused, |
| 12515 | .unused, |
| 12516 | }, |
| 12517 | .dst_temps = .{.mem}, |
| 12518 | .clobbers = .{ .eflags = true }, |
| 12519 | .each = .{ .once = &.{ |
| 12520 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12521 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 12522 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 12523 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 12524 | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 12525 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ }, |
| 12526 | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 12527 | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 12528 | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 12529 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 12530 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 12531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12532 | } }, |
| 12533 | }, .{ |
| 12534 | .required_features = .{ .avx, null, null, null }, |
| 12535 | .src_constraints = .{ |
| 12536 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12537 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12538 | .any, |
| 12539 | }, |
| 12540 | .patterns = &.{ |
| 12541 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12542 | }, |
| 12543 | .extra_temps = .{ |
| 12544 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 12545 | .unused, |
| 12546 | .unused, |
| 12547 | .unused, |
| 12548 | .unused, |
| 12549 | .unused, |
| 12550 | .unused, |
| 12551 | .unused, |
| 12552 | .unused, |
| 12553 | }, |
| 12554 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12555 | .each = .{ .once = &.{ |
| 12556 | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0q, .vp(.unord) }, |
| 12557 | .{ ._, .v_sd, .max, .dst0x, .src1x, .src0q, ._ }, |
| 12558 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 12559 | } }, |
| 12560 | }, .{ |
| 12561 | .required_features = .{ .sse4_1, null, null, null }, |
| 12562 | .src_constraints = .{ |
| 12563 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12564 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12565 | .any, |
| 12566 | }, |
| 12567 | .patterns = &.{ |
| 12568 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 12569 | }, |
| 12570 | .dst_temps = .{.{ .rc = .sse }}, |
| 12571 | .each = .{ .once = &.{ |
| 12572 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 12573 | .{ ._, ._sd, .max, .dst0x, .src0q, ._, ._ }, |
| 12574 | .{ ._, ._sd, .cmp, .src0x, .src0q, .sp(.unord), ._ }, |
| 12575 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 12576 | } }, |
| 12577 | }, .{ |
| 12578 | .required_features = .{ .sse2, null, null, null }, |
| 12579 | .src_constraints = .{ |
| 12580 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12581 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12582 | .any, |
| 12583 | }, |
| 12584 | .patterns = &.{ |
| 12585 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 12586 | }, |
| 12587 | .extra_temps = .{ |
| 12588 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12589 | .unused, |
| 12590 | .unused, |
| 12591 | .unused, |
| 12592 | .unused, |
| 12593 | .unused, |
| 12594 | .unused, |
| 12595 | .unused, |
| 12596 | .unused, |
| 12597 | }, |
| 12598 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12599 | .each = .{ .once = &.{ |
| 12600 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 12601 | .{ ._, ._sd, .max, .tmp0x, .src0q, ._, ._ }, |
| 12602 | .{ ._, ._sd, .cmp, .dst0x, .src0q, .sp(.ord), ._ }, |
| 12603 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 12604 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 12605 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 12606 | } }, |
| 12607 | }, .{ |
| 12608 | .required_features = .{ .sse, null, null, null }, |
| 12609 | .src_constraints = .{ |
| 12610 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12611 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12612 | .any, |
| 12613 | }, |
| 12614 | .patterns = &.{ |
| 12615 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 12616 | }, |
| 12617 | .call_frame = .{ .alignment = .@"16" }, |
| 12618 | .extra_temps = .{ |
| 12619 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, |
| 12620 | .unused, |
| 12621 | .unused, |
| 12622 | .unused, |
| 12623 | .unused, |
| 12624 | .unused, |
| 12625 | .unused, |
| 12626 | .unused, |
| 12627 | .unused, |
| 12628 | }, |
| 12629 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12630 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12631 | .each = .{ .once = &.{ |
| 12632 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 12633 | } }, |
| 12634 | }, .{ |
| 12635 | .required_features = .{ .avx, null, null, null }, |
| 12636 | .src_constraints = .{ |
| 12637 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12638 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12639 | .any, |
| 12640 | }, |
| 12641 | .patterns = &.{ |
| 12642 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12643 | }, |
| 12644 | .extra_temps = .{ |
| 12645 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12646 | .unused, |
| 12647 | .unused, |
| 12648 | .unused, |
| 12649 | .unused, |
| 12650 | .unused, |
| 12651 | .unused, |
| 12652 | .unused, |
| 12653 | .unused, |
| 12654 | }, |
| 12655 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12656 | .each = .{ .once = &.{ |
| 12657 | .{ ._, .v_pd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 12658 | .{ ._, .v_pd, .max, .dst0x, .src1x, .src0x, ._ }, |
| 12659 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 12660 | } }, |
| 12661 | }, .{ |
| 12662 | .required_features = .{ .sse4_1, null, null, null }, |
| 12663 | .src_constraints = .{ |
| 12664 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12665 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12666 | .any, |
| 12667 | }, |
| 12668 | .patterns = &.{ |
| 12669 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| 12670 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } }, |
| 12671 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 12672 | }, |
| 12673 | .dst_temps = .{.{ .rc = .sse }}, |
| 12674 | .each = .{ .once = &.{ |
| 12675 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 12676 | .{ ._, ._pd, .max, .dst0x, .src0x, ._, ._ }, |
| 12677 | .{ ._, ._pd, .cmp, .src0x, .src0x, .sp(.unord), ._ }, |
| 12678 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 12679 | } }, |
| 12680 | }, .{ |
| 12681 | .required_features = .{ .sse2, null, null, null }, |
| 12682 | .src_constraints = .{ |
| 12683 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12684 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12685 | .any, |
| 12686 | }, |
| 12687 | .patterns = &.{ |
| 12688 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 12689 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 12690 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 12691 | }, |
| 12692 | .extra_temps = .{ |
| 12693 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12694 | .unused, |
| 12695 | .unused, |
| 12696 | .unused, |
| 12697 | .unused, |
| 12698 | .unused, |
| 12699 | .unused, |
| 12700 | .unused, |
| 12701 | .unused, |
| 12702 | }, |
| 12703 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12704 | .each = .{ .once = &.{ |
| 12705 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 12706 | .{ ._, ._pd, .max, .tmp0x, .src0x, ._, ._ }, |
| 12707 | .{ ._, ._pd, .cmp, .dst0x, .src0x, .sp(.ord), ._ }, |
| 12708 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 12709 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 12710 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| 12711 | } }, |
| 12712 | }, .{ |
| 12713 | .required_features = .{ .avx, null, null, null }, |
| 12714 | .src_constraints = .{ |
| 12715 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 12716 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 12717 | .any, |
| 12718 | }, |
| 12719 | .patterns = &.{ |
| 12720 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 12721 | }, |
| 12722 | .extra_temps = .{ |
| 12723 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 12724 | .unused, |
| 12725 | .unused, |
| 12726 | .unused, |
| 12727 | .unused, |
| 12728 | .unused, |
| 12729 | .unused, |
| 12730 | .unused, |
| 12731 | .unused, |
| 12732 | }, |
| 12733 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 12734 | .each = .{ .once = &.{ |
| 12735 | .{ ._, .v_pd, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, |
| 12736 | .{ ._, .v_pd, .max, .dst0y, .src1y, .src0y, ._ }, |
| 12737 | .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, |
| 12738 | } }, |
| 12739 | }, .{ |
| 12740 | .required_features = .{ .avx, null, null, null }, |
| 12741 | .src_constraints = .{ |
| 12742 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 12743 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 12744 | .any, |
| 12745 | }, |
| 12746 | .patterns = &.{ |
| 12747 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12748 | }, |
| 12749 | .extra_temps = .{ |
| 12750 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12751 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 12752 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 12753 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 12754 | .unused, |
| 12755 | .unused, |
| 12756 | .unused, |
| 12757 | .unused, |
| 12758 | .unused, |
| 12759 | }, |
| 12760 | .dst_temps = .{.mem}, |
| 12761 | .clobbers = .{ .eflags = true }, |
| 12762 | .each = .{ .once = &.{ |
| 12763 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12764 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 12765 | .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, |
| 12766 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, |
| 12767 | .{ ._, .v_pd, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| 12768 | .{ ._, .v_pd, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, |
| 12769 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, |
| 12770 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 12771 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12772 | } }, |
| 12773 | }, .{ |
| 12774 | .required_features = .{ .sse4_1, null, null, null }, |
| 12775 | .src_constraints = .{ |
| 12776 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12777 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12778 | .any, |
| 12779 | }, |
| 12780 | .patterns = &.{ |
| 12781 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12782 | }, |
| 12783 | .extra_temps = .{ |
| 12784 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12785 | .{ .type = .vector_2_f64, .kind = .{ .reg = .xmm0 } }, |
| 12786 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12787 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12788 | .unused, |
| 12789 | .unused, |
| 12790 | .unused, |
| 12791 | .unused, |
| 12792 | .unused, |
| 12793 | }, |
| 12794 | .dst_temps = .{.mem}, |
| 12795 | .clobbers = .{ .eflags = true }, |
| 12796 | .each = .{ .once = &.{ |
| 12797 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12798 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 12799 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 12800 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 12801 | .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 12802 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ }, |
| 12803 | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 12804 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 12805 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 12806 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12807 | } }, |
| 12808 | }, .{ |
| 12809 | .required_features = .{ .sse2, null, null, null }, |
| 12810 | .src_constraints = .{ |
| 12811 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12812 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 12813 | .any, |
| 12814 | }, |
| 12815 | .patterns = &.{ |
| 12816 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12817 | }, |
| 12818 | .extra_temps = .{ |
| 12819 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12820 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12821 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12822 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 12823 | .unused, |
| 12824 | .unused, |
| 12825 | .unused, |
| 12826 | .unused, |
| 12827 | .unused, |
| 12828 | }, |
| 12829 | .dst_temps = .{.mem}, |
| 12830 | .clobbers = .{ .eflags = true }, |
| 12831 | .each = .{ .once = &.{ |
| 12832 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12833 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 12834 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 12835 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 12836 | .{ ._, ._pd, .max, .tmp3x, .tmp1x, ._, ._ }, |
| 12837 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ }, |
| 12838 | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 12839 | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 12840 | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| 12841 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 12842 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 12843 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12844 | } }, |
| 12845 | }, .{ |
| 12846 | .required_features = .{ .sse, null, null, null }, |
| 12847 | .src_constraints = .{ |
| 12848 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12849 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 12850 | .any, |
| 12851 | }, |
| 12852 | .patterns = &.{ |
| 12853 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 12854 | }, |
| 12855 | .call_frame = .{ .alignment = .@"16" }, |
| 12856 | .extra_temps = .{ |
| 12857 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 12858 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 12859 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 12860 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, |
| 12861 | .unused, |
| 12862 | .unused, |
| 12863 | .unused, |
| 12864 | .unused, |
| 12865 | .unused, |
| 12866 | }, |
| 12867 | .dst_temps = .{.mem}, |
| 12868 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 12869 | .each = .{ .once = &.{ |
| 12870 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 12871 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 12872 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 12873 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 12874 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 12875 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 12876 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 12877 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 12878 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 12879 | } }, |
| 12880 | }, .{ |
| 12881 | .required_features = .{ .x87, .cmov, null, null }, |
| 12882 | .src_constraints = .{ |
| 12883 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 12884 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 12885 | .any, |
| 12886 | }, |
| 12887 | .patterns = &.{ |
| 12888 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 12889 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 12890 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 12891 | }, |
| 12892 | .extra_temps = .{ |
| 12893 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 12894 | .unused, |
| 12895 | .unused, |
| 12896 | .unused, |
| 12897 | .unused, |
| 12898 | .unused, |
| 12899 | .unused, |
| 12900 | .unused, |
| 12901 | .unused, |
| 12902 | }, |
| 12903 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| 12904 | .clobbers = .{ .eflags = true }, |
| 12905 | .each = .{ .once = &.{ |
| 12906 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 12907 | .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ }, |
| 12908 | .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ }, |
| 12909 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 12910 | .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ }, |
| 12911 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 12912 | .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ }, |
| 12913 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 12914 | } }, |
| 12915 | }, .{ |
| 12916 | .required_features = .{ .sahf, .x87, null, null }, |
| 12917 | .src_constraints = .{ |
| 12918 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 12919 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 12920 | .any, |
| 12921 | }, |
| 12922 | .patterns = &.{ |
| 12923 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 12924 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 12925 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 12926 | }, |
| 12927 | .extra_temps = .{ |
| 12928 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 12929 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 12930 | .unused, |
| 12931 | .unused, |
| 12932 | .unused, |
| 12933 | .unused, |
| 12934 | .unused, |
| 12935 | .unused, |
| 12936 | .unused, |
| 12937 | }, |
| 12938 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| 12939 | .clobbers = .{ .eflags = true }, |
| 12940 | .each = .{ .once = &.{ |
| 12941 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 12942 | .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, |
| 12943 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 12944 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 12945 | .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, |
| 12946 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 12947 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| 12948 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 12949 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 12950 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 12951 | .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, |
| 12952 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| 12953 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 12954 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| 12955 | } }, |
| 12956 | }, .{ |
| 12957 | .required_features = .{ .x87, null, null, null }, |
| 12958 | .src_constraints = .{ |
| 12959 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 12960 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 12961 | .any, |
| 12962 | }, |
| 12963 | .patterns = &.{ |
| 12964 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 12965 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 12966 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 12967 | }, |
| 12968 | .extra_temps = .{ |
| 12969 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 12970 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 12971 | .unused, |
| 12972 | .unused, |
| 12973 | .unused, |
| 12974 | .unused, |
| 12975 | .unused, |
| 12976 | .unused, |
| 12977 | .unused, |
| 12978 | }, |
| 12979 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, |
| 12980 | .clobbers = .{ .eflags = true }, |
| 12981 | .each = .{ .once = &.{ |
| 12982 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 12983 | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| 12984 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 12985 | .{ ._, ._, .@"test", .tmp1b, .si(0b1_000_100), ._, ._ }, |
| 12986 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 12987 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 12988 | .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, |
| 12989 | .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, |
| 12990 | .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, |
| 12991 | .{ ._, ._, .@"test", .tmp1b, .si(0b0_000_001), ._, ._ }, |
| 12992 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 12993 | .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, |
| 12994 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 12995 | .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, |
| 12996 | } }, |
| 12997 | }, .{ |
| 12998 | .required_features = .{ .x87, .cmov, null, null }, |
| 12999 | .src_constraints = .{ |
| 13000 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 13001 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 13002 | .any, |
| 13003 | }, |
| 13004 | .patterns = &.{ |
| 13005 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13006 | }, |
| 13007 | .extra_temps = .{ |
| 13008 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13009 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 13010 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 13011 | .unused, |
| 13012 | .unused, |
| 13013 | .unused, |
| 13014 | .unused, |
| 13015 | .unused, |
| 13016 | .unused, |
| 13017 | }, |
| 13018 | .dst_temps = .{.mem}, |
| 13019 | .clobbers = .{ .eflags = true }, |
| 13020 | .each = .{ .once = &.{ |
| 13021 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 13022 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 13023 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 13024 | .{ ._, .f_, .ucomi, .tmp1t, .tmp1t, ._, ._ }, |
| 13025 | .{ ._, .f_u, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 13026 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 13027 | .{ ._, .f_, .ucomi, .tmp1t, .tmp2t, ._, ._ }, |
| 13028 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 13029 | .{ ._, .f_nb, .cmov, .tmp1t, .tmp2t, ._, ._ }, |
| 13030 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 13031 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 13032 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 13033 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13034 | } }, |
| 13035 | }, .{ |
| 13036 | .required_features = .{ .sahf, .x87, null, null }, |
| 13037 | .src_constraints = .{ |
| 13038 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 13039 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 13040 | .any, |
| 13041 | }, |
| 13042 | .patterns = &.{ |
| 13043 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13044 | }, |
| 13045 | .extra_temps = .{ |
| 13046 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13047 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 13048 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 13049 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 13050 | .unused, |
| 13051 | .unused, |
| 13052 | .unused, |
| 13053 | .unused, |
| 13054 | .unused, |
| 13055 | }, |
| 13056 | .dst_temps = .{.mem}, |
| 13057 | .clobbers = .{ .eflags = true }, |
| 13058 | .each = .{ .once = &.{ |
| 13059 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 13060 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 13061 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 13062 | .{ ._, .f_, .ucom, .tmp1t, ._, ._, ._ }, |
| 13063 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 13064 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 13065 | .{ ._, ._p, .j, .@"1f", ._, ._, ._ }, |
| 13066 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 13067 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 13068 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 13069 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 13070 | .{ ._, ._, .sahf, ._, ._, ._, ._ }, |
| 13071 | .{ ._, ._b, .j, .@"2f", ._, ._, ._ }, |
| 13072 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 13073 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 13074 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 13075 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 13076 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 13077 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13078 | } }, |
| 13079 | }, .{ |
| 13080 | .required_features = .{ .x87, null, null, null }, |
| 13081 | .src_constraints = .{ |
| 13082 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 13083 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 13084 | .any, |
| 13085 | }, |
| 13086 | .patterns = &.{ |
| 13087 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13088 | }, |
| 13089 | .extra_temps = .{ |
| 13090 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13091 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 13092 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 13093 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 13094 | .unused, |
| 13095 | .unused, |
| 13096 | .unused, |
| 13097 | .unused, |
| 13098 | .unused, |
| 13099 | }, |
| 13100 | .dst_temps = .{.mem}, |
| 13101 | .clobbers = .{ .eflags = true }, |
| 13102 | .each = .{ .once = &.{ |
| 13103 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 13104 | .{ .@"0:", .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 13105 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 13106 | .{ ._, .f_, .xam, ._, ._, ._, ._ }, |
| 13107 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 13108 | .{ ._, ._, .@"test", .tmp3b, .si(0b1_000_100), ._, ._ }, |
| 13109 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| 13110 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 13111 | .{ ._, .f_, .ucom, .tmp2t, ._, ._, ._ }, |
| 13112 | .{ ._, .fn_sw, .st, .tmp3w, ._, ._, ._ }, |
| 13113 | .{ ._, .f_, .xch, .tmp2t, ._, ._, ._ }, |
| 13114 | .{ ._, ._, .@"test", .tmp3b, .si(0b0_000_001), ._, ._ }, |
| 13115 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| 13116 | .{ .@"1:", .f_p, .st, .tmp1t, ._, ._, ._ }, |
| 13117 | .{ ._, .f_, .ld, .tmp2t, ._, ._, ._ }, |
| 13118 | .{ .@"2:", .f_p, .st, .memia(.dst0t, .tmp0, .add_size), ._, ._, ._ }, |
| 13119 | .{ ._, .f_p, .st, .tmp2t, ._, ._, ._ }, |
| 13120 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 13121 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13122 | } }, |
| 13123 | }, .{ |
| 13124 | .required_features = .{ .sse, null, null, null }, |
| 13125 | .src_constraints = .{ |
| 13126 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13127 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13128 | .any, |
| 13129 | }, |
| 13130 | .patterns = &.{ |
| 13131 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 13132 | }, |
| 13133 | .call_frame = .{ .alignment = .@"16" }, |
| 13134 | .extra_temps = .{ |
| 13135 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 13136 | .unused, |
| 13137 | .unused, |
| 13138 | .unused, |
| 13139 | .unused, |
| 13140 | .unused, |
| 13141 | .unused, |
| 13142 | .unused, |
| 13143 | .unused, |
| 13144 | }, |
| 13145 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13146 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 13147 | .each = .{ .once = &.{ |
| 13148 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 13149 | } }, |
| 13150 | }, .{ |
| 13151 | .required_features = .{ .avx, null, null, null }, |
| 13152 | .src_constraints = .{ |
| 13153 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13154 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13155 | .any, |
| 13156 | }, |
| 13157 | .patterns = &.{ |
| 13158 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13159 | }, |
| 13160 | .call_frame = .{ .alignment = .@"16" }, |
| 13161 | .extra_temps = .{ |
| 13162 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13163 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 13164 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 13165 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 13166 | .unused, |
| 13167 | .unused, |
| 13168 | .unused, |
| 13169 | .unused, |
| 13170 | .unused, |
| 13171 | }, |
| 13172 | .dst_temps = .{.mem}, |
| 13173 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 13174 | .each = .{ .once = &.{ |
| 13175 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 13176 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 13177 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 13178 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 13179 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 13180 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 13181 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13182 | } }, |
| 13183 | }, .{ |
| 13184 | .required_features = .{ .sse2, null, null, null }, |
| 13185 | .src_constraints = .{ |
| 13186 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13187 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13188 | .any, |
| 13189 | }, |
| 13190 | .patterns = &.{ |
| 13191 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13192 | }, |
| 13193 | .call_frame = .{ .alignment = .@"16" }, |
| 13194 | .extra_temps = .{ |
| 13195 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13196 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 13197 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 13198 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 13199 | .unused, |
| 13200 | .unused, |
| 13201 | .unused, |
| 13202 | .unused, |
| 13203 | .unused, |
| 13204 | }, |
| 13205 | .dst_temps = .{.mem}, |
| 13206 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 13207 | .each = .{ .once = &.{ |
| 13208 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 13209 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 13210 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 13211 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 13212 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 13213 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 13214 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13215 | } }, |
| 13216 | }, .{ |
| 13217 | .required_features = .{ .sse, null, null, null }, |
| 13218 | .src_constraints = .{ |
| 13219 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13220 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 13221 | .any, |
| 13222 | }, |
| 13223 | .patterns = &.{ |
| 13224 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13225 | }, |
| 13226 | .call_frame = .{ .alignment = .@"16" }, |
| 13227 | .extra_temps = .{ |
| 13228 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13229 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 13230 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 13231 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, |
| 13232 | .unused, |
| 13233 | .unused, |
| 13234 | .unused, |
| 13235 | .unused, |
| 13236 | .unused, |
| 13237 | }, |
| 13238 | .dst_temps = .{.mem}, |
| 13239 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 13240 | .each = .{ .once = &.{ |
| 13241 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 13242 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 13243 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 13244 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 13245 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, |
| 13246 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 13247 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13248 | } }, |
| 13249 | } }) catch |err| switch (err) { |
| 13250 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 13251 | @tagName(air_tag), |
| 13252 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 13253 | ops[0].tracking(cg), |
| 13254 | ops[1].tracking(cg), |
| 13255 | }), |
| 13256 | else => |e| return e, |
| 13257 | }; |
| 13258 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 13259 | }, |
| 13260 | .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else { |
| 13261 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 13262 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 13263 | var res: [1]Temp = undefined; |
| 13264 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 13265 | .required_features = .{ .cmov, null, null, null }, |
| 13266 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 13267 | .patterns = &.{ |
| 13268 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13269 | }, |
| 13270 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13271 | .clobbers = .{ .eflags = true }, |
| 13272 | .each = .{ .once = &.{ |
| 13273 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 13274 | .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ }, |
| 13275 | } }, |
| 13276 | }, .{ |
| 13277 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 13278 | .patterns = &.{ |
| 13279 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13280 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13281 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13282 | }, |
| 13283 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13284 | .clobbers = .{ .eflags = true }, |
| 13285 | .each = .{ .once = &.{ |
| 13286 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 13287 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 13288 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 13289 | } }, |
| 13290 | }, .{ |
| 13291 | .required_features = .{ .cmov, null, null, null }, |
| 13292 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 13293 | .patterns = &.{ |
| 13294 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13295 | }, |
| 13296 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13297 | .clobbers = .{ .eflags = true }, |
| 13298 | .each = .{ .once = &.{ |
| 13299 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 13300 | .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ }, |
| 13301 | } }, |
| 13302 | }, .{ |
| 13303 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 13304 | .patterns = &.{ |
| 13305 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13306 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13307 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13308 | }, |
| 13309 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13310 | .clobbers = .{ .eflags = true }, |
| 13311 | .each = .{ .once = &.{ |
| 13312 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 13313 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 13314 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, |
| 13315 | } }, |
| 13316 | }, .{ |
| 13317 | .required_features = .{ .cmov, null, null, null }, |
| 13318 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 13319 | .patterns = &.{ |
| 13320 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13321 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13322 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13323 | }, |
| 13324 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13325 | .clobbers = .{ .eflags = true }, |
| 13326 | .each = .{ .once = &.{ |
| 13327 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 13328 | .{ ._, ._ge, .cmov, .dst0w, .src1w, ._, ._ }, |
| 13329 | } }, |
| 13330 | }, .{ |
| 13331 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 13332 | .patterns = &.{ |
| 13333 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13334 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13335 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13336 | }, |
| 13337 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13338 | .clobbers = .{ .eflags = true }, |
| 13339 | .each = .{ .once = &.{ |
| 13340 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 13341 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 13342 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 13343 | } }, |
| 13344 | }, .{ |
| 13345 | .required_features = .{ .cmov, null, null, null }, |
| 13346 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 13347 | .patterns = &.{ |
| 13348 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13349 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13350 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13351 | }, |
| 13352 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13353 | .clobbers = .{ .eflags = true }, |
| 13354 | .each = .{ .once = &.{ |
| 13355 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 13356 | .{ ._, ._ae, .cmov, .dst0w, .src1w, ._, ._ }, |
| 13357 | } }, |
| 13358 | }, .{ |
| 13359 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 13360 | .patterns = &.{ |
| 13361 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13362 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13363 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13364 | }, |
| 13365 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13366 | .clobbers = .{ .eflags = true }, |
| 13367 | .each = .{ .once = &.{ |
| 13368 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 13369 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 13370 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, |
| 13371 | } }, |
| 13372 | }, .{ |
| 13373 | .required_features = .{ .cmov, null, null, null }, |
| 13374 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 13375 | .patterns = &.{ |
| 13376 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13377 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13378 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13379 | }, |
| 13380 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13381 | .clobbers = .{ .eflags = true }, |
| 13382 | .each = .{ .once = &.{ |
| 13383 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 13384 | .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ }, |
| 13385 | } }, |
| 13386 | }, .{ |
| 13387 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 13388 | .patterns = &.{ |
| 13389 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13390 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13391 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13392 | }, |
| 13393 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13394 | .clobbers = .{ .eflags = true }, |
| 13395 | .each = .{ .once = &.{ |
| 13396 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 13397 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 13398 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 13399 | } }, |
| 13400 | }, .{ |
| 13401 | .required_features = .{ .cmov, null, null, null }, |
| 13402 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 13403 | .patterns = &.{ |
| 13404 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13405 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13406 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13407 | }, |
| 13408 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13409 | .clobbers = .{ .eflags = true }, |
| 13410 | .each = .{ .once = &.{ |
| 13411 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 13412 | .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ }, |
| 13413 | } }, |
| 13414 | }, .{ |
| 13415 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 13416 | .patterns = &.{ |
| 13417 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13418 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13419 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13420 | }, |
| 13421 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13422 | .clobbers = .{ .eflags = true }, |
| 13423 | .each = .{ .once = &.{ |
| 13424 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 13425 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 13426 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, |
| 13427 | } }, |
| 13428 | }, .{ |
| 13429 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 13430 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 13431 | .patterns = &.{ |
| 13432 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13433 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13434 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13435 | }, |
| 13436 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13437 | .clobbers = .{ .eflags = true }, |
| 13438 | .each = .{ .once = &.{ |
| 13439 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 13440 | .{ ._, ._ge, .cmov, .dst0q, .src1q, ._, ._ }, |
| 13441 | } }, |
| 13442 | }, .{ |
| 13443 | .required_features = .{ .@"64bit", null, null, null }, |
| 13444 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 13445 | .patterns = &.{ |
| 13446 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13447 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13448 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13449 | }, |
| 13450 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13451 | .clobbers = .{ .eflags = true }, |
| 13452 | .each = .{ .once = &.{ |
| 13453 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 13454 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 13455 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 13456 | } }, |
| 13457 | }, .{ |
| 13458 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 13459 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 13460 | .patterns = &.{ |
| 13461 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13462 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13463 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13464 | }, |
| 13465 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13466 | .clobbers = .{ .eflags = true }, |
| 13467 | .each = .{ .once = &.{ |
| 13468 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 13469 | .{ ._, ._ae, .cmov, .dst0q, .src1q, ._, ._ }, |
| 13470 | } }, |
| 13471 | }, .{ |
| 13472 | .required_features = .{ .@"64bit", null, null, null }, |
| 13473 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 13474 | .patterns = &.{ |
| 13475 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 13476 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 13477 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 13478 | }, |
| 13479 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13480 | .clobbers = .{ .eflags = true }, |
| 13481 | .each = .{ .once = &.{ |
| 13482 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, |
| 13483 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 13484 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, |
| 13485 | } }, |
| 13486 | }, .{ |
| 13487 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 13488 | .src_constraints = .{ .any_signed_int, .any_signed_int, .any }, |
| 13489 | .patterns = &.{ |
| 13490 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13491 | }, |
| 13492 | .extra_temps = .{ |
| 13493 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 13494 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 13495 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 13496 | .unused, |
| 13497 | .unused, |
| 13498 | .unused, |
| 13499 | .unused, |
| 13500 | .unused, |
| 13501 | .unused, |
| 13502 | }, |
| 13503 | .dst_temps = .{.mem}, |
| 13504 | .clobbers = .{ .eflags = true }, |
| 13505 | .each = .{ .once = &.{ |
| 13506 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 13507 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 13508 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 13509 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 13510 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 13511 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 13512 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 13513 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 13514 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 13515 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 13516 | .{ ._, ._ge, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 13517 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 13518 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 13519 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 13520 | } }, |
| 13521 | }, .{ |
| 13522 | .required_features = .{ .@"64bit", null, null, null }, |
| 13523 | .src_constraints = .{ .any_signed_int, .any_signed_int, .any }, |
| 13524 | .patterns = &.{ |
| 13525 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13526 | }, |
| 13527 | .extra_temps = .{ |
| 13528 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 13529 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 13530 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 13531 | .unused, |
| 13532 | .unused, |
| 13533 | .unused, |
| 13534 | .unused, |
| 13535 | .unused, |
| 13536 | .unused, |
| 13537 | }, |
| 13538 | .dst_temps = .{.mem}, |
| 13539 | .clobbers = .{ .eflags = true }, |
| 13540 | .each = .{ .once = &.{ |
| 13541 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 13542 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 13543 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 13544 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 13545 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 13546 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 13547 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 13548 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 13549 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 13550 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, |
| 13551 | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 13552 | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 13553 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 13554 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 13555 | } }, |
| 13556 | }, .{ |
| 13557 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 13558 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any }, |
| 13559 | .patterns = &.{ |
| 13560 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13561 | }, |
| 13562 | .extra_temps = .{ |
| 13563 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 13564 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 13565 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 13566 | .unused, |
| 13567 | .unused, |
| 13568 | .unused, |
| 13569 | .unused, |
| 13570 | .unused, |
| 13571 | .unused, |
| 13572 | }, |
| 13573 | .dst_temps = .{.mem}, |
| 13574 | .clobbers = .{ .eflags = true }, |
| 13575 | .each = .{ .once = &.{ |
| 13576 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 13577 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 13578 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 13579 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 13580 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 13581 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 13582 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 13583 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| 13584 | .{ ._, ._ae, .cmov, .tmp0p, .tmp1p, ._, ._ }, |
| 13585 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 13586 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 13587 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 13588 | } }, |
| 13589 | }, .{ |
| 13590 | .required_features = .{ .@"64bit", null, null, null }, |
| 13591 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int, .any }, |
| 13592 | .patterns = &.{ |
| 13593 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13594 | }, |
| 13595 | .extra_temps = .{ |
| 13596 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, |
| 13597 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 13598 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 13599 | .unused, |
| 13600 | .unused, |
| 13601 | .unused, |
| 13602 | .unused, |
| 13603 | .unused, |
| 13604 | .unused, |
| 13605 | }, |
| 13606 | .dst_temps = .{.mem}, |
| 13607 | .clobbers = .{ .eflags = true }, |
| 13608 | .each = .{ .once = &.{ |
| 13609 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 13610 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 13611 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 13612 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 13613 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 13614 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 13615 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 13616 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, |
| 13617 | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, |
| 13618 | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 13619 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 13620 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 13621 | } }, |
| 13622 | }, .{ |
| 13623 | .required_features = .{ .avx, null, null, null }, |
| 13624 | .src_constraints = .{ |
| 13625 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13626 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13627 | .any, |
| 13628 | }, |
| 13629 | .patterns = &.{ |
| 13630 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 13631 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 13632 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 13633 | }, |
| 13634 | .dst_temps = .{.{ .rc = .sse }}, |
| 13635 | .each = .{ .once = &.{ |
| 13636 | .{ ._, .vp_b, .mins, .dst0x, .src0x, .src1x, ._ }, |
| 13637 | } }, |
| 13638 | }, .{ |
| 13639 | .required_features = .{ .sse4_1, null, null, null }, |
| 13640 | .src_constraints = .{ |
| 13641 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13642 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13643 | .any, |
| 13644 | }, |
| 13645 | .patterns = &.{ |
| 13646 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 13647 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 13648 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 13649 | }, |
| 13650 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13651 | .each = .{ .once = &.{ |
| 13652 | .{ ._, .p_b, .mins, .dst0x, .src1x, ._, ._ }, |
| 13653 | } }, |
| 13654 | }, .{ |
| 13655 | .required_features = .{ .sse2, null, null, null }, |
| 13656 | .src_constraints = .{ |
| 13657 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13658 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13659 | .any, |
| 13660 | }, |
| 13661 | .patterns = &.{ |
| 13662 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 13663 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 13664 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 13665 | }, |
| 13666 | .dst_temps = .{.{ .rc = .sse }}, |
| 13667 | .each = .{ .once = &.{ |
| 13668 | .{ ._, ._dqa, .mov, .dst0x, .src1x, ._, ._ }, |
| 13669 | .{ ._, .p_b, .cmpgt, .dst0x, .src0x, ._, ._ }, |
| 13670 | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, |
| 13671 | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, |
| 13672 | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, |
| 13673 | } }, |
| 13674 | }, .{ |
| 13675 | .required_features = .{ .avx2, null, null, null }, |
| 13676 | .src_constraints = .{ |
| 13677 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 13678 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 13679 | .any, |
| 13680 | }, |
| 13681 | .patterns = &.{ |
| 13682 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 13683 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 13684 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 13685 | }, |
| 13686 | .dst_temps = .{.{ .rc = .sse }}, |
| 13687 | .each = .{ .once = &.{ |
| 13688 | .{ ._, .vp_b, .mins, .dst0y, .src0y, .src1y, ._ }, |
| 13689 | } }, |
| 13690 | }, .{ |
| 13691 | .required_features = .{ .avx2, null, null, null }, |
| 13692 | .src_constraints = .{ |
| 13693 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 13694 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| 13695 | .any, |
| 13696 | }, |
| 13697 | .patterns = &.{ |
| 13698 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 13699 | }, |
| 13700 | .extra_temps = .{ |
| 13701 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 13702 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 13703 | .unused, |
| 13704 | .unused, |
| 13705 | .unused, |
| 13706 | .unused, |
| 13707 | .unused, |
| 13708 | .unused, |
| 13709 | .unused, |
| 13710 | }, |
| 13711 | .dst_temps = .{.mem}, |
| 13712 | .clobbers = .{ .eflags = true }, |
| 13713 | .each = .{ .once = &.{ |
| 7113 | 13714 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 7114 | 13715 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 7115 | 13716 | .{ ._, .vp_b, .mins, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, |
| ... | ... | @@ -7122,9 +13723,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7122 | 13723 | .src_constraints = .{ |
| 7123 | 13724 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7124 | 13725 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13726 | .any, |
| 7125 | 13727 | }, |
| 7126 | 13728 | .patterns = &.{ |
| 7127 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13729 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7128 | 13730 | }, |
| 7129 | 13731 | .extra_temps = .{ |
| 7130 | 13732 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7152,9 +13754,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7152 | 13754 | .src_constraints = .{ |
| 7153 | 13755 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7154 | 13756 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13757 | .any, |
| 7155 | 13758 | }, |
| 7156 | 13759 | .patterns = &.{ |
| 7157 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13760 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7158 | 13761 | }, |
| 7159 | 13762 | .extra_temps = .{ |
| 7160 | 13763 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7182,9 +13785,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7182 | 13785 | .src_constraints = .{ |
| 7183 | 13786 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7184 | 13787 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 13788 | .any, |
| 7185 | 13789 | }, |
| 7186 | 13790 | .patterns = &.{ |
| 7187 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13791 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7188 | 13792 | }, |
| 7189 | 13793 | .extra_temps = .{ |
| 7190 | 13794 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7216,9 +13820,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7216 | 13820 | .src_constraints = .{ |
| 7217 | 13821 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7218 | 13822 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 13823 | .any, |
| 7219 | 13824 | }, |
| 7220 | 13825 | .patterns = &.{ |
| 7221 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13826 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7222 | 13827 | }, |
| 7223 | 13828 | .extra_temps = .{ |
| 7224 | 13829 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7248,9 +13853,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7248 | 13853 | .src_constraints = .{ |
| 7249 | 13854 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7250 | 13855 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 13856 | .any, |
| 7251 | 13857 | }, |
| 7252 | 13858 | .patterns = &.{ |
| 7253 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13859 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7254 | 13860 | }, |
| 7255 | 13861 | .extra_temps = .{ |
| 7256 | 13862 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7280,9 +13886,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7280 | 13886 | .src_constraints = .{ |
| 7281 | 13887 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7282 | 13888 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 13889 | .any, |
| 7283 | 13890 | }, |
| 7284 | 13891 | .patterns = &.{ |
| 7285 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13892 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7286 | 13893 | }, |
| 7287 | 13894 | .extra_temps = .{ |
| 7288 | 13895 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7311,9 +13918,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7311 | 13918 | .src_constraints = .{ |
| 7312 | 13919 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7313 | 13920 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 13921 | .any, |
| 7314 | 13922 | }, |
| 7315 | 13923 | .patterns = &.{ |
| 7316 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 13924 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7317 | 13925 | }, |
| 7318 | 13926 | .extra_temps = .{ |
| 7319 | 13927 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7343,11 +13951,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7343 | 13951 | .src_constraints = .{ |
| 7344 | 13952 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 7345 | 13953 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 13954 | .any, |
| 7346 | 13955 | }, |
| 7347 | 13956 | .patterns = &.{ |
| 7348 | | .{ .src = .{ .to_mut_mmx, .mem } }, |
| 7349 | | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, |
| 7350 | | .{ .src = .{ .to_mut_mmx, .to_mmx } }, |
| 13957 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 13958 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 13959 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 7351 | 13960 | }, |
| 7352 | 13961 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7353 | 13962 | .each = .{ .once = &.{ |
| ... | ... | @@ -7358,11 +13967,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7358 | 13967 | .src_constraints = .{ |
| 7359 | 13968 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7360 | 13969 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 13970 | .any, |
| 7361 | 13971 | }, |
| 7362 | 13972 | .patterns = &.{ |
| 7363 | | .{ .src = .{ .to_sse, .mem } }, |
| 7364 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7365 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 13973 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 13974 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 13975 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7366 | 13976 | }, |
| 7367 | 13977 | .dst_temps = .{.{ .rc = .sse }}, |
| 7368 | 13978 | .each = .{ .once = &.{ |
| ... | ... | @@ -7373,11 +13983,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7373 | 13983 | .src_constraints = .{ |
| 7374 | 13984 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7375 | 13985 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 13986 | .any, |
| 7376 | 13987 | }, |
| 7377 | 13988 | .patterns = &.{ |
| 7378 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 7379 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 7380 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 13989 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 13990 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 13991 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7381 | 13992 | }, |
| 7382 | 13993 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7383 | 13994 | .each = .{ .once = &.{ |
| ... | ... | @@ -7388,11 +13999,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7388 | 13999 | .src_constraints = .{ |
| 7389 | 14000 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 7390 | 14001 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 14002 | .any, |
| 7391 | 14003 | }, |
| 7392 | 14004 | .patterns = &.{ |
| 7393 | | .{ .src = .{ .to_sse, .mem } }, |
| 7394 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7395 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14005 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14006 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14007 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7396 | 14008 | }, |
| 7397 | 14009 | .dst_temps = .{.{ .rc = .sse }}, |
| 7398 | 14010 | .each = .{ .once = &.{ |
| ... | ... | @@ -7403,9 +14015,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7403 | 14015 | .src_constraints = .{ |
| 7404 | 14016 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 7405 | 14017 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 14018 | .any, |
| 7406 | 14019 | }, |
| 7407 | 14020 | .patterns = &.{ |
| 7408 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14021 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7409 | 14022 | }, |
| 7410 | 14023 | .extra_temps = .{ |
| 7411 | 14024 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7433,9 +14046,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7433 | 14046 | .src_constraints = .{ |
| 7434 | 14047 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7435 | 14048 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 14049 | .any, |
| 7436 | 14050 | }, |
| 7437 | 14051 | .patterns = &.{ |
| 7438 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14052 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7439 | 14053 | }, |
| 7440 | 14054 | .extra_temps = .{ |
| 7441 | 14055 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7463,9 +14077,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7463 | 14077 | .src_constraints = .{ |
| 7464 | 14078 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7465 | 14079 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 14080 | .any, |
| 7466 | 14081 | }, |
| 7467 | 14082 | .patterns = &.{ |
| 7468 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14083 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7469 | 14084 | }, |
| 7470 | 14085 | .extra_temps = .{ |
| 7471 | 14086 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7493,9 +14108,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7493 | 14108 | .src_constraints = .{ |
| 7494 | 14109 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7495 | 14110 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 14111 | .any, |
| 7496 | 14112 | }, |
| 7497 | 14113 | .patterns = &.{ |
| 7498 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14114 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7499 | 14115 | }, |
| 7500 | 14116 | .extra_temps = .{ |
| 7501 | 14117 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7525,9 +14141,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7525 | 14141 | .src_constraints = .{ |
| 7526 | 14142 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7527 | 14143 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 14144 | .any, |
| 7528 | 14145 | }, |
| 7529 | 14146 | .patterns = &.{ |
| 7530 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14147 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7531 | 14148 | }, |
| 7532 | 14149 | .extra_temps = .{ |
| 7533 | 14150 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7557,9 +14174,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7557 | 14174 | .src_constraints = .{ |
| 7558 | 14175 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7559 | 14176 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 14177 | .any, |
| 7560 | 14178 | }, |
| 7561 | 14179 | .patterns = &.{ |
| 7562 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14180 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7563 | 14181 | }, |
| 7564 | 14182 | .extra_temps = .{ |
| 7565 | 14183 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7588,9 +14206,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7588 | 14206 | .src_constraints = .{ |
| 7589 | 14207 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7590 | 14208 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 14209 | .any, |
| 7591 | 14210 | }, |
| 7592 | 14211 | .patterns = &.{ |
| 7593 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14212 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7594 | 14213 | }, |
| 7595 | 14214 | .extra_temps = .{ |
| 7596 | 14215 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7620,11 +14239,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7620 | 14239 | .src_constraints = .{ |
| 7621 | 14240 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 7622 | 14241 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 14242 | .any, |
| 7623 | 14243 | }, |
| 7624 | 14244 | .patterns = &.{ |
| 7625 | | .{ .src = .{ .to_mut_mmx, .mem } }, |
| 7626 | | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, |
| 7627 | | .{ .src = .{ .to_mut_mmx, .to_mmx } }, |
| 14245 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 14246 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 14247 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 7628 | 14248 | }, |
| 7629 | 14249 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7630 | 14250 | .each = .{ .once = &.{ |
| ... | ... | @@ -7635,11 +14255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7635 | 14255 | .src_constraints = .{ |
| 7636 | 14256 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7637 | 14257 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 14258 | .any, |
| 7638 | 14259 | }, |
| 7639 | 14260 | .patterns = &.{ |
| 7640 | | .{ .src = .{ .to_sse, .mem } }, |
| 7641 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7642 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14261 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14262 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14263 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7643 | 14264 | }, |
| 7644 | 14265 | .dst_temps = .{.{ .rc = .sse }}, |
| 7645 | 14266 | .each = .{ .once = &.{ |
| ... | ... | @@ -7650,11 +14271,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7650 | 14271 | .src_constraints = .{ |
| 7651 | 14272 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7652 | 14273 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 14274 | .any, |
| 7653 | 14275 | }, |
| 7654 | 14276 | .patterns = &.{ |
| 7655 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 7656 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 7657 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 14277 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 14278 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 14279 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7658 | 14280 | }, |
| 7659 | 14281 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7660 | 14282 | .each = .{ .once = &.{ |
| ... | ... | @@ -7665,11 +14287,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7665 | 14287 | .src_constraints = .{ |
| 7666 | 14288 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 7667 | 14289 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 14290 | .any, |
| 7668 | 14291 | }, |
| 7669 | 14292 | .patterns = &.{ |
| 7670 | | .{ .src = .{ .to_sse, .mem } }, |
| 7671 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7672 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14293 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14294 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14295 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7673 | 14296 | }, |
| 7674 | 14297 | .dst_temps = .{.{ .rc = .sse }}, |
| 7675 | 14298 | .each = .{ .once = &.{ |
| ... | ... | @@ -7680,9 +14303,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7680 | 14303 | .src_constraints = .{ |
| 7681 | 14304 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 7682 | 14305 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 14306 | .any, |
| 7683 | 14307 | }, |
| 7684 | 14308 | .patterns = &.{ |
| 7685 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14309 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7686 | 14310 | }, |
| 7687 | 14311 | .extra_temps = .{ |
| 7688 | 14312 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7710,9 +14334,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7710 | 14334 | .src_constraints = .{ |
| 7711 | 14335 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7712 | 14336 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 14337 | .any, |
| 7713 | 14338 | }, |
| 7714 | 14339 | .patterns = &.{ |
| 7715 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14340 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7716 | 14341 | }, |
| 7717 | 14342 | .extra_temps = .{ |
| 7718 | 14343 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7740,9 +14365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7740 | 14365 | .src_constraints = .{ |
| 7741 | 14366 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7742 | 14367 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 14368 | .any, |
| 7743 | 14369 | }, |
| 7744 | 14370 | .patterns = &.{ |
| 7745 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14371 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7746 | 14372 | }, |
| 7747 | 14373 | .extra_temps = .{ |
| 7748 | 14374 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7770,9 +14396,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7770 | 14396 | .src_constraints = .{ |
| 7771 | 14397 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 7772 | 14398 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 14399 | .any, |
| 7773 | 14400 | }, |
| 7774 | 14401 | .patterns = &.{ |
| 7775 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14402 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7776 | 14403 | }, |
| 7777 | 14404 | .extra_temps = .{ |
| 7778 | 14405 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7800,9 +14427,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7800 | 14427 | .src_constraints = .{ |
| 7801 | 14428 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 7802 | 14429 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 14430 | .any, |
| 7803 | 14431 | }, |
| 7804 | 14432 | .patterns = &.{ |
| 7805 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14433 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7806 | 14434 | }, |
| 7807 | 14435 | .extra_temps = .{ |
| 7808 | 14436 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7832,11 +14460,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7832 | 14460 | .src_constraints = .{ |
| 7833 | 14461 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7834 | 14462 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 14463 | .any, |
| 7835 | 14464 | }, |
| 7836 | 14465 | .patterns = &.{ |
| 7837 | | .{ .src = .{ .to_sse, .mem } }, |
| 7838 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7839 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14466 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14467 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14468 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7840 | 14469 | }, |
| 7841 | 14470 | .dst_temps = .{.{ .rc = .sse }}, |
| 7842 | 14471 | .each = .{ .once = &.{ |
| ... | ... | @@ -7847,11 +14476,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7847 | 14476 | .src_constraints = .{ |
| 7848 | 14477 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7849 | 14478 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 14479 | .any, |
| 7850 | 14480 | }, |
| 7851 | 14481 | .patterns = &.{ |
| 7852 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 7853 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 7854 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 14482 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 14483 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 14484 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7855 | 14485 | }, |
| 7856 | 14486 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7857 | 14487 | .each = .{ .once = &.{ |
| ... | ... | @@ -7862,11 +14492,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7862 | 14492 | .src_constraints = .{ |
| 7863 | 14493 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7864 | 14494 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 14495 | .any, |
| 7865 | 14496 | }, |
| 7866 | 14497 | .patterns = &.{ |
| 7867 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 7868 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 7869 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 14498 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 14499 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 14500 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7870 | 14501 | }, |
| 7871 | 14502 | .dst_temps = .{.{ .rc = .sse }}, |
| 7872 | 14503 | .each = .{ .once = &.{ |
| ... | ... | @@ -7879,11 +14510,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7879 | 14510 | .src_constraints = .{ |
| 7880 | 14511 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 7881 | 14512 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 14513 | .any, |
| 7882 | 14514 | }, |
| 7883 | 14515 | .patterns = &.{ |
| 7884 | | .{ .src = .{ .to_sse, .mem } }, |
| 7885 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 7886 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14516 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14517 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14518 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7887 | 14519 | }, |
| 7888 | 14520 | .dst_temps = .{.{ .rc = .sse }}, |
| 7889 | 14521 | .each = .{ .once = &.{ |
| ... | ... | @@ -7894,9 +14526,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7894 | 14526 | .src_constraints = .{ |
| 7895 | 14527 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 7896 | 14528 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 14529 | .any, |
| 7897 | 14530 | }, |
| 7898 | 14531 | .patterns = &.{ |
| 7899 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14532 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7900 | 14533 | }, |
| 7901 | 14534 | .extra_temps = .{ |
| 7902 | 14535 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7924,9 +14557,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7924 | 14557 | .src_constraints = .{ |
| 7925 | 14558 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7926 | 14559 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 14560 | .any, |
| 7927 | 14561 | }, |
| 7928 | 14562 | .patterns = &.{ |
| 7929 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14563 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7930 | 14564 | }, |
| 7931 | 14565 | .extra_temps = .{ |
| 7932 | 14566 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7954,9 +14588,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7954 | 14588 | .src_constraints = .{ |
| 7955 | 14589 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7956 | 14590 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 14591 | .any, |
| 7957 | 14592 | }, |
| 7958 | 14593 | .patterns = &.{ |
| 7959 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14594 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7960 | 14595 | }, |
| 7961 | 14596 | .extra_temps = .{ |
| 7962 | 14597 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -7984,9 +14619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7984 | 14619 | .src_constraints = .{ |
| 7985 | 14620 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7986 | 14621 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 14622 | .any, |
| 7987 | 14623 | }, |
| 7988 | 14624 | .patterns = &.{ |
| 7989 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14625 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7990 | 14626 | }, |
| 7991 | 14627 | .extra_temps = .{ |
| 7992 | 14628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8016,9 +14652,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8016 | 14652 | .src_constraints = .{ |
| 8017 | 14653 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 8018 | 14654 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 14655 | .any, |
| 8019 | 14656 | }, |
| 8020 | 14657 | .patterns = &.{ |
| 8021 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14658 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8022 | 14659 | }, |
| 8023 | 14660 | .extra_temps = .{ |
| 8024 | 14661 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8046,9 +14683,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8046 | 14683 | .src_constraints = .{ |
| 8047 | 14684 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 8048 | 14685 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 14686 | .any, |
| 8049 | 14687 | }, |
| 8050 | 14688 | .patterns = &.{ |
| 8051 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14689 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8052 | 14690 | }, |
| 8053 | 14691 | .extra_temps = .{ |
| 8054 | 14692 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8078,11 +14716,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8078 | 14716 | .src_constraints = .{ |
| 8079 | 14717 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8080 | 14718 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 14719 | .any, |
| 8081 | 14720 | }, |
| 8082 | 14721 | .patterns = &.{ |
| 8083 | | .{ .src = .{ .to_sse, .mem } }, |
| 8084 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8085 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14722 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14723 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14724 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8086 | 14725 | }, |
| 8087 | 14726 | .dst_temps = .{.{ .rc = .sse }}, |
| 8088 | 14727 | .each = .{ .once = &.{ |
| ... | ... | @@ -8093,11 +14732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8093 | 14732 | .src_constraints = .{ |
| 8094 | 14733 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8095 | 14734 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 14735 | .any, |
| 8096 | 14736 | }, |
| 8097 | 14737 | .patterns = &.{ |
| 8098 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 8099 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 8100 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 14738 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 14739 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 14740 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8101 | 14741 | }, |
| 8102 | 14742 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8103 | 14743 | .each = .{ .once = &.{ |
| ... | ... | @@ -8108,11 +14748,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8108 | 14748 | .src_constraints = .{ |
| 8109 | 14749 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8110 | 14750 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 14751 | .any, |
| 8111 | 14752 | }, |
| 8112 | 14753 | .patterns = &.{ |
| 8113 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 8114 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 8115 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 14754 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 14755 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 14756 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8116 | 14757 | }, |
| 8117 | 14758 | .dst_temps = .{.{ .rc = .sse }}, |
| 8118 | 14759 | .each = .{ .once = &.{ |
| ... | ... | @@ -8127,11 +14768,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8127 | 14768 | .src_constraints = .{ |
| 8128 | 14769 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 8129 | 14770 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 14771 | .any, |
| 8130 | 14772 | }, |
| 8131 | 14773 | .patterns = &.{ |
| 8132 | | .{ .src = .{ .to_sse, .mem } }, |
| 8133 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8134 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14774 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14775 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14776 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8135 | 14777 | }, |
| 8136 | 14778 | .dst_temps = .{.{ .rc = .sse }}, |
| 8137 | 14779 | .each = .{ .once = &.{ |
| ... | ... | @@ -8142,9 +14784,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8142 | 14784 | .src_constraints = .{ |
| 8143 | 14785 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 8144 | 14786 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 14787 | .any, |
| 8145 | 14788 | }, |
| 8146 | 14789 | .patterns = &.{ |
| 8147 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14790 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8148 | 14791 | }, |
| 8149 | 14792 | .extra_temps = .{ |
| 8150 | 14793 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8172,9 +14815,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8172 | 14815 | .src_constraints = .{ |
| 8173 | 14816 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8174 | 14817 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 14818 | .any, |
| 8175 | 14819 | }, |
| 8176 | 14820 | .patterns = &.{ |
| 8177 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14821 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8178 | 14822 | }, |
| 8179 | 14823 | .extra_temps = .{ |
| 8180 | 14824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8202,9 +14846,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8202 | 14846 | .src_constraints = .{ |
| 8203 | 14847 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8204 | 14848 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 14849 | .any, |
| 8205 | 14850 | }, |
| 8206 | 14851 | .patterns = &.{ |
| 8207 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14852 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8208 | 14853 | }, |
| 8209 | 14854 | .extra_temps = .{ |
| 8210 | 14855 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8232,9 +14877,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8232 | 14877 | .src_constraints = .{ |
| 8233 | 14878 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8234 | 14879 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 14880 | .any, |
| 8235 | 14881 | }, |
| 8236 | 14882 | .patterns = &.{ |
| 8237 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8238 | 14884 | }, |
| 8239 | 14885 | .extra_temps = .{ |
| 8240 | 14886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8266,9 +14912,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8266 | 14912 | .src_constraints = .{ |
| 8267 | 14913 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8268 | 14914 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 14915 | .any, |
| 8269 | 14916 | }, |
| 8270 | 14917 | .patterns = &.{ |
| 8271 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14918 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8272 | 14919 | }, |
| 8273 | 14920 | .extra_temps = .{ |
| 8274 | 14921 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8296,9 +14943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8296 | 14943 | .src_constraints = .{ |
| 8297 | 14944 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8298 | 14945 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 14946 | .any, |
| 8299 | 14947 | }, |
| 8300 | 14948 | .patterns = &.{ |
| 8301 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 14949 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8302 | 14950 | }, |
| 8303 | 14951 | .extra_temps = .{ |
| 8304 | 14952 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8328,11 +14976,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8328 | 14976 | .src_constraints = .{ |
| 8329 | 14977 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8330 | 14978 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 14979 | .any, |
| 8331 | 14980 | }, |
| 8332 | 14981 | .patterns = &.{ |
| 8333 | | .{ .src = .{ .to_sse, .mem } }, |
| 8334 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8335 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 14982 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 14983 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 14984 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8336 | 14985 | }, |
| 8337 | 14986 | .dst_temps = .{.{ .rc = .sse }}, |
| 8338 | 14987 | .each = .{ .once = &.{ |
| ... | ... | @@ -8343,11 +14992,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8343 | 14992 | .src_constraints = .{ |
| 8344 | 14993 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8345 | 14994 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 14995 | .any, |
| 8346 | 14996 | }, |
| 8347 | 14997 | .patterns = &.{ |
| 8348 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 8349 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 8350 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 14998 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 14999 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 15000 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8351 | 15001 | }, |
| 8352 | 15002 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8353 | 15003 | .each = .{ .once = &.{ |
| ... | ... | @@ -8358,11 +15008,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8358 | 15008 | .src_constraints = .{ |
| 8359 | 15009 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8360 | 15010 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 15011 | .any, |
| 8361 | 15012 | }, |
| 8362 | 15013 | .patterns = &.{ |
| 8363 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 8364 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 8365 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 15014 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 15015 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 15016 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8366 | 15017 | }, |
| 8367 | 15018 | .extra_temps = .{ |
| 8368 | 15019 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8392,11 +15043,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8392 | 15043 | .src_constraints = .{ |
| 8393 | 15044 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 8394 | 15045 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 15046 | .any, |
| 8395 | 15047 | }, |
| 8396 | 15048 | .patterns = &.{ |
| 8397 | | .{ .src = .{ .to_sse, .mem } }, |
| 8398 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8399 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15049 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 15050 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 15051 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8400 | 15052 | }, |
| 8401 | 15053 | .dst_temps = .{.{ .rc = .sse }}, |
| 8402 | 15054 | .each = .{ .once = &.{ |
| ... | ... | @@ -8407,9 +15059,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8407 | 15059 | .src_constraints = .{ |
| 8408 | 15060 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 8409 | 15061 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 15062 | .any, |
| 8410 | 15063 | }, |
| 8411 | 15064 | .patterns = &.{ |
| 8412 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15065 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8413 | 15066 | }, |
| 8414 | 15067 | .extra_temps = .{ |
| 8415 | 15068 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8437,9 +15090,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8437 | 15090 | .src_constraints = .{ |
| 8438 | 15091 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8439 | 15092 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 15093 | .any, |
| 8440 | 15094 | }, |
| 8441 | 15095 | .patterns = &.{ |
| 8442 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15096 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8443 | 15097 | }, |
| 8444 | 15098 | .extra_temps = .{ |
| 8445 | 15099 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8467,9 +15121,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8467 | 15121 | .src_constraints = .{ |
| 8468 | 15122 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8469 | 15123 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 15124 | .any, |
| 8470 | 15125 | }, |
| 8471 | 15126 | .patterns = &.{ |
| 8472 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15127 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8473 | 15128 | }, |
| 8474 | 15129 | .extra_temps = .{ |
| 8475 | 15130 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8497,9 +15152,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8497 | 15152 | .src_constraints = .{ |
| 8498 | 15153 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8499 | 15154 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 15155 | .any, |
| 8500 | 15156 | }, |
| 8501 | 15157 | .patterns = &.{ |
| 8502 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15158 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8503 | 15159 | }, |
| 8504 | 15160 | .extra_temps = .{ |
| 8505 | 15161 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8537,9 +15193,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8537 | 15193 | .src_constraints = .{ |
| 8538 | 15194 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8539 | 15195 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 15196 | .any, |
| 8540 | 15197 | }, |
| 8541 | 15198 | .patterns = &.{ |
| 8542 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15199 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8543 | 15200 | }, |
| 8544 | 15201 | .extra_temps = .{ |
| 8545 | 15202 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8567,9 +15224,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8567 | 15224 | .src_constraints = .{ |
| 8568 | 15225 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8569 | 15226 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 15227 | .any, |
| 8570 | 15228 | }, |
| 8571 | 15229 | .patterns = &.{ |
| 8572 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15230 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8573 | 15231 | }, |
| 8574 | 15232 | .extra_temps = .{ |
| 8575 | 15233 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8599,11 +15257,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8599 | 15257 | .src_constraints = .{ |
| 8600 | 15258 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8601 | 15259 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 15260 | .any, |
| 8602 | 15261 | }, |
| 8603 | 15262 | .patterns = &.{ |
| 8604 | | .{ .src = .{ .to_sse, .mem } }, |
| 8605 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8606 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15263 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 15264 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 15265 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8607 | 15266 | }, |
| 8608 | 15267 | .dst_temps = .{.{ .rc = .sse }}, |
| 8609 | 15268 | .each = .{ .once = &.{ |
| ... | ... | @@ -8615,11 +15274,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8615 | 15274 | .src_constraints = .{ |
| 8616 | 15275 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8617 | 15276 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 15277 | .any, |
| 8618 | 15278 | }, |
| 8619 | 15279 | .patterns = &.{ |
| 8620 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 8621 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 8622 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 15280 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 15281 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 15282 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8623 | 15283 | }, |
| 8624 | 15284 | .extra_temps = .{ |
| 8625 | 15285 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| ... | ... | @@ -8643,11 +15303,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8643 | 15303 | .src_constraints = .{ |
| 8644 | 15304 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 8645 | 15305 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 15306 | .any, |
| 8646 | 15307 | }, |
| 8647 | 15308 | .patterns = &.{ |
| 8648 | | .{ .src = .{ .to_sse, .mem } }, |
| 8649 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8650 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15309 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 15310 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 15311 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8651 | 15312 | }, |
| 8652 | 15313 | .dst_temps = .{.{ .rc = .sse }}, |
| 8653 | 15314 | .each = .{ .once = &.{ |
| ... | ... | @@ -8659,9 +15320,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8659 | 15320 | .src_constraints = .{ |
| 8660 | 15321 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 8661 | 15322 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 15323 | .any, |
| 8662 | 15324 | }, |
| 8663 | 15325 | .patterns = &.{ |
| 8664 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15326 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8665 | 15327 | }, |
| 8666 | 15328 | .extra_temps = .{ |
| 8667 | 15329 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8691,9 +15353,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8691 | 15353 | .src_constraints = .{ |
| 8692 | 15354 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8693 | 15355 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 15356 | .any, |
| 8694 | 15357 | }, |
| 8695 | 15358 | .patterns = &.{ |
| 8696 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15359 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8697 | 15360 | }, |
| 8698 | 15361 | .extra_temps = .{ |
| 8699 | 15362 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8723,9 +15386,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8723 | 15386 | .src_constraints = .{ |
| 8724 | 15387 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8725 | 15388 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 15389 | .any, |
| 8726 | 15390 | }, |
| 8727 | 15391 | .patterns = &.{ |
| 8728 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15392 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8729 | 15393 | }, |
| 8730 | 15394 | .extra_temps = .{ |
| 8731 | 15395 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8756,9 +15420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8756 | 15420 | .src_constraints = .{ |
| 8757 | 15421 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 8758 | 15422 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 15423 | .any, |
| 8759 | 15424 | }, |
| 8760 | 15425 | .patterns = &.{ |
| 8761 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15426 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8762 | 15427 | }, |
| 8763 | 15428 | .extra_temps = .{ |
| 8764 | 15429 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8787,9 +15452,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8787 | 15452 | .src_constraints = .{ |
| 8788 | 15453 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 8789 | 15454 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 15455 | .any, |
| 8790 | 15456 | }, |
| 8791 | 15457 | .patterns = &.{ |
| 8792 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15458 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8793 | 15459 | }, |
| 8794 | 15460 | .extra_temps = .{ |
| 8795 | 15461 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8819,11 +15485,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8819 | 15485 | .src_constraints = .{ |
| 8820 | 15486 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8821 | 15487 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 15488 | .any, |
| 8822 | 15489 | }, |
| 8823 | 15490 | .patterns = &.{ |
| 8824 | | .{ .src = .{ .to_sse, .mem } }, |
| 8825 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8826 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15491 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 15492 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 15493 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8827 | 15494 | }, |
| 8828 | 15495 | .extra_temps = .{ |
| 8829 | 15496 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8850,11 +15517,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8850 | 15517 | .src_constraints = .{ |
| 8851 | 15518 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8852 | 15519 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 15520 | .any, |
| 8853 | 15521 | }, |
| 8854 | 15522 | .patterns = &.{ |
| 8855 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 8856 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 8857 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 15523 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 15524 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 15525 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8858 | 15526 | }, |
| 8859 | 15527 | .extra_temps = .{ |
| 8860 | 15528 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8882,11 +15550,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8882 | 15550 | .src_constraints = .{ |
| 8883 | 15551 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 8884 | 15552 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 15553 | .any, |
| 8885 | 15554 | }, |
| 8886 | 15555 | .patterns = &.{ |
| 8887 | | .{ .src = .{ .to_sse, .mem } }, |
| 8888 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 8889 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15556 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 15557 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 15558 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8890 | 15559 | }, |
| 8891 | 15560 | .extra_temps = .{ |
| 8892 | 15561 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8913,9 +15582,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8913 | 15582 | .src_constraints = .{ |
| 8914 | 15583 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 8915 | 15584 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 15585 | .any, |
| 8916 | 15586 | }, |
| 8917 | 15587 | .patterns = &.{ |
| 8918 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15588 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8919 | 15589 | }, |
| 8920 | 15590 | .extra_temps = .{ |
| 8921 | 15591 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8949,9 +15619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8949 | 15619 | .src_constraints = .{ |
| 8950 | 15620 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8951 | 15621 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 15622 | .any, |
| 8952 | 15623 | }, |
| 8953 | 15624 | .patterns = &.{ |
| 8954 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15625 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8955 | 15626 | }, |
| 8956 | 15627 | .extra_temps = .{ |
| 8957 | 15628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -8985,9 +15656,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8985 | 15656 | .src_constraints = .{ |
| 8986 | 15657 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8987 | 15658 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 15659 | .any, |
| 8988 | 15660 | }, |
| 8989 | 15661 | .patterns = &.{ |
| 8990 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15662 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8991 | 15663 | }, |
| 8992 | 15664 | .extra_temps = .{ |
| 8993 | 15665 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9023,9 +15695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9023 | 15695 | .src_constraints = .{ |
| 9024 | 15696 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 9025 | 15697 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 15698 | .any, |
| 9026 | 15699 | }, |
| 9027 | 15700 | .patterns = &.{ |
| 9028 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15701 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9029 | 15702 | }, |
| 9030 | 15703 | .extra_temps = .{ |
| 9031 | 15704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9054,9 +15727,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9054 | 15727 | .src_constraints = .{ |
| 9055 | 15728 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 9056 | 15729 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 15730 | .any, |
| 9057 | 15731 | }, |
| 9058 | 15732 | .patterns = &.{ |
| 9059 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15733 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9060 | 15734 | }, |
| 9061 | 15735 | .extra_temps = .{ |
| 9062 | 15736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9083,9 +15757,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9083 | 15757 | } }, |
| 9084 | 15758 | }, .{ |
| 9085 | 15759 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 9086 | | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int }, |
| 15760 | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any }, |
| 9087 | 15761 | .patterns = &.{ |
| 9088 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15762 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9089 | 15763 | }, |
| 9090 | 15764 | .extra_temps = .{ |
| 9091 | 15765 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9122,9 +15796,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9122 | 15796 | } }, |
| 9123 | 15797 | }, .{ |
| 9124 | 15798 | .required_features = .{ .@"64bit", null, null, null }, |
| 9125 | | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int }, |
| 15799 | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int, .any }, |
| 9126 | 15800 | .patterns = &.{ |
| 9127 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15801 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9128 | 15802 | }, |
| 9129 | 15803 | .extra_temps = .{ |
| 9130 | 15804 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9161,9 +15835,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9161 | 15835 | } }, |
| 9162 | 15836 | }, .{ |
| 9163 | 15837 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 9164 | | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int }, |
| 15838 | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any }, |
| 9165 | 15839 | .patterns = &.{ |
| 9166 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15840 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9167 | 15841 | }, |
| 9168 | 15842 | .extra_temps = .{ |
| 9169 | 15843 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9198,9 +15872,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9198 | 15872 | } }, |
| 9199 | 15873 | }, .{ |
| 9200 | 15874 | .required_features = .{ .@"64bit", null, null, null }, |
| 9201 | | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int }, |
| 15875 | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int, .any }, |
| 9202 | 15876 | .patterns = &.{ |
| 9203 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 15877 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9204 | 15878 | }, |
| 9205 | 15879 | .extra_temps = .{ |
| 9206 | 15880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9238,9 +15912,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9238 | 15912 | .src_constraints = .{ |
| 9239 | 15913 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 9240 | 15914 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 15915 | .any, |
| 9241 | 15916 | }, |
| 9242 | 15917 | .patterns = &.{ |
| 9243 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15918 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9244 | 15919 | }, |
| 9245 | 15920 | .extra_temps = .{ |
| 9246 | 15921 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| ... | ... | @@ -9257,8 +15932,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9257 | 15932 | .each = .{ .once = &.{ |
| 9258 | 15933 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 9259 | 15934 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 9260 | | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, |
| 9261 | | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, |
| 15935 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0d, .vp(.unord) }, |
| 15936 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0d, ._ }, |
| 9262 | 15937 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 9263 | 15938 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 9264 | 15939 | } }, |
| ... | ... | @@ -9267,9 +15942,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9267 | 15942 | .src_constraints = .{ |
| 9268 | 15943 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 9269 | 15944 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 15945 | .any, |
| 9270 | 15946 | }, |
| 9271 | 15947 | .patterns = &.{ |
| 9272 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 15948 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 9273 | 15949 | }, |
| 9274 | 15950 | .call_frame = .{ .alignment = .@"16" }, |
| 9275 | 15951 | .extra_temps = .{ |
| ... | ... | @@ -9293,16 +15969,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9293 | 15969 | .src_constraints = .{ |
| 9294 | 15970 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 9295 | 15971 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 15972 | .any, |
| 9296 | 15973 | }, |
| 9297 | 15974 | .patterns = &.{ |
| 9298 | | .{ .src = .{ .mem, .mem } }, |
| 9299 | | .{ .src = .{ .to_sse, .mem } }, |
| 9300 | | .{ .src = .{ .mem, .to_sse } }, |
| 9301 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 15975 | .{ .src = .{ .mem, .mem, .none } }, |
| 15976 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 15977 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 15978 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9302 | 15979 | }, |
| 9303 | 15980 | .extra_temps = .{ |
| 9304 | | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9305 | | .{ .type = .vector_4_f16, .kind = .{ .rc = .sse } }, |
| 15981 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 15982 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9306 | 15983 | .unused, |
| 9307 | 15984 | .unused, |
| 9308 | 15985 | .unused, |
| ... | ... | @@ -9325,16 +16002,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9325 | 16002 | .src_constraints = .{ |
| 9326 | 16003 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 9327 | 16004 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 16005 | .any, |
| 9328 | 16006 | }, |
| 9329 | 16007 | .patterns = &.{ |
| 9330 | | .{ .src = .{ .mem, .mem } }, |
| 9331 | | .{ .src = .{ .to_sse, .mem } }, |
| 9332 | | .{ .src = .{ .mem, .to_sse } }, |
| 9333 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16008 | .{ .src = .{ .mem, .mem, .none } }, |
| 16009 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 16010 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 16011 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9334 | 16012 | }, |
| 9335 | 16013 | .extra_temps = .{ |
| 9336 | | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9337 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 16014 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 16015 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9338 | 16016 | .unused, |
| 9339 | 16017 | .unused, |
| 9340 | 16018 | .unused, |
| ... | ... | @@ -9350,22 +16028,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9350 | 16028 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, |
| 9351 | 16029 | .{ ._, .v_ps, .min, .dst0y, .tmp0y, .dst0y, ._ }, |
| 9352 | 16030 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, |
| 9353 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0y, .rm(.{}), ._ }, |
| 16031 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 9354 | 16032 | } }, |
| 9355 | 16033 | }, .{ |
| 9356 | 16034 | .required_features = .{ .f16c, null, null, null }, |
| 9357 | 16035 | .src_constraints = .{ |
| 9358 | 16036 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 9359 | 16037 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 16038 | .any, |
| 9360 | 16039 | }, |
| 9361 | 16040 | .patterns = &.{ |
| 9362 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16041 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9363 | 16042 | }, |
| 9364 | 16043 | .extra_temps = .{ |
| 9365 | 16044 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9366 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 9367 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 9368 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 16045 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 16046 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 16047 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9369 | 16048 | .unused, |
| 9370 | 16049 | .unused, |
| 9371 | 16050 | .unused, |
| ... | ... | @@ -9390,9 +16069,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9390 | 16069 | .src_constraints = .{ |
| 9391 | 16070 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9392 | 16071 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 16072 | .any, |
| 9393 | 16073 | }, |
| 9394 | 16074 | .patterns = &.{ |
| 9395 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16075 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9396 | 16076 | }, |
| 9397 | 16077 | .call_frame = .{ .alignment = .@"16" }, |
| 9398 | 16078 | .extra_temps = .{ |
| ... | ... | @@ -9423,9 +16103,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9423 | 16103 | .src_constraints = .{ |
| 9424 | 16104 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9425 | 16105 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 16106 | .any, |
| 9426 | 16107 | }, |
| 9427 | 16108 | .patterns = &.{ |
| 9428 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16109 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9429 | 16110 | }, |
| 9430 | 16111 | .call_frame = .{ .alignment = .@"16" }, |
| 9431 | 16112 | .extra_temps = .{ |
| ... | ... | @@ -9457,9 +16138,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9457 | 16138 | .src_constraints = .{ |
| 9458 | 16139 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9459 | 16140 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 16141 | .any, |
| 9460 | 16142 | }, |
| 9461 | 16143 | .patterns = &.{ |
| 9462 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16144 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9463 | 16145 | }, |
| 9464 | 16146 | .call_frame = .{ .alignment = .@"16" }, |
| 9465 | 16147 | .extra_temps = .{ |
| ... | ... | @@ -9492,9 +16174,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9492 | 16174 | .src_constraints = .{ |
| 9493 | 16175 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9494 | 16176 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 16177 | .any, |
| 9495 | 16178 | }, |
| 9496 | 16179 | .patterns = &.{ |
| 9497 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16180 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9498 | 16181 | }, |
| 9499 | 16182 | .call_frame = .{ .alignment = .@"16" }, |
| 9500 | 16183 | .extra_temps = .{ |
| ... | ... | @@ -9530,9 +16213,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9530 | 16213 | .src_constraints = .{ |
| 9531 | 16214 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 9532 | 16215 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 16216 | .any, |
| 9533 | 16217 | }, |
| 9534 | 16218 | .patterns = &.{ |
| 9535 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16219 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9536 | 16220 | }, |
| 9537 | 16221 | .extra_temps = .{ |
| 9538 | 16222 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9547,8 +16231,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9547 | 16231 | }, |
| 9548 | 16232 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9549 | 16233 | .each = .{ .once = &.{ |
| 9550 | | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 9551 | | .{ ._, .v_ss, .min, .dst0x, .src1x, .src0x, ._ }, |
| 16234 | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0d, .vp(.unord) }, |
| 16235 | .{ ._, .v_ss, .min, .dst0x, .src1x, .src0d, ._ }, |
| 9552 | 16236 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 9553 | 16237 | } }, |
| 9554 | 16238 | }, .{ |
| ... | ... | @@ -9556,15 +16240,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9556 | 16240 | .src_constraints = .{ |
| 9557 | 16241 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 9558 | 16242 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 16243 | .any, |
| 9559 | 16244 | }, |
| 9560 | 16245 | .patterns = &.{ |
| 9561 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 16246 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9562 | 16247 | }, |
| 9563 | 16248 | .dst_temps = .{.{ .rc = .sse }}, |
| 9564 | 16249 | .each = .{ .once = &.{ |
| 9565 | 16250 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 9566 | | .{ ._, ._ss, .min, .dst0x, .src0x, ._, ._ }, |
| 9567 | | .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 16251 | .{ ._, ._ss, .min, .dst0x, .src0d, ._, ._ }, |
| 16252 | .{ ._, ._ss, .cmp, .src0x, .src0d, .sp(.unord), ._ }, |
| 9568 | 16253 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 9569 | 16254 | } }, |
| 9570 | 16255 | }, .{ |
| ... | ... | @@ -9572,9 +16257,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9572 | 16257 | .src_constraints = .{ |
| 9573 | 16258 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 9574 | 16259 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 16260 | .any, |
| 9575 | 16261 | }, |
| 9576 | 16262 | .patterns = &.{ |
| 9577 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 16263 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9578 | 16264 | }, |
| 9579 | 16265 | .extra_temps = .{ |
| 9580 | 16266 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9590,8 +16276,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9590 | 16276 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9591 | 16277 | .each = .{ .once = &.{ |
| 9592 | 16278 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9593 | | .{ ._, ._ss, .min, .tmp0x, .src0x, ._, ._ }, |
| 9594 | | .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 16279 | .{ ._, ._ss, .min, .tmp0x, .src0d, ._, ._ }, |
| 16280 | .{ ._, ._ss, .cmp, .dst0x, .src0d, .sp(.ord), ._ }, |
| 9595 | 16281 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9596 | 16282 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 9597 | 16283 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | ... | @@ -9601,9 +16287,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9601 | 16287 | .src_constraints = .{ |
| 9602 | 16288 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9603 | 16289 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 16290 | .any, |
| 9604 | 16291 | }, |
| 9605 | 16292 | .patterns = &.{ |
| 9606 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16293 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9607 | 16294 | }, |
| 9608 | 16295 | .extra_temps = .{ |
| 9609 | 16296 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9627,17 +16314,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9627 | 16314 | .src_constraints = .{ |
| 9628 | 16315 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9629 | 16316 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 16317 | .any, |
| 9630 | 16318 | }, |
| 9631 | 16319 | .patterns = &.{ |
| 9632 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 9633 | | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 9634 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 16320 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| 16321 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } }, |
| 16322 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9635 | 16323 | }, |
| 9636 | 16324 | .dst_temps = .{.{ .rc = .sse }}, |
| 9637 | 16325 | .each = .{ .once = &.{ |
| 9638 | 16326 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 9639 | 16327 | .{ ._, ._ps, .min, .dst0x, .src0x, ._, ._ }, |
| 9640 | | .{ ._, ._ps, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 16328 | .{ ._, ._ps, .cmp, .src0x, .src0x, .sp(.unord), ._ }, |
| 9641 | 16329 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 9642 | 16330 | } }, |
| 9643 | 16331 | }, .{ |
| ... | ... | @@ -9645,11 +16333,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9645 | 16333 | .src_constraints = .{ |
| 9646 | 16334 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9647 | 16335 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 16336 | .any, |
| 9648 | 16337 | }, |
| 9649 | 16338 | .patterns = &.{ |
| 9650 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 9651 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 9652 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 16339 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 16340 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 16341 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9653 | 16342 | }, |
| 9654 | 16343 | .extra_temps = .{ |
| 9655 | 16344 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9666,7 +16355,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9666 | 16355 | .each = .{ .once = &.{ |
| 9667 | 16356 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9668 | 16357 | .{ ._, ._ps, .min, .tmp0x, .src0x, ._, ._ }, |
| 9669 | | .{ ._, ._ps, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 16358 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .sp(.ord), ._ }, |
| 9670 | 16359 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9671 | 16360 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 9672 | 16361 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | ... | @@ -9676,9 +16365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9676 | 16365 | .src_constraints = .{ |
| 9677 | 16366 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9678 | 16367 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 16368 | .any, |
| 9679 | 16369 | }, |
| 9680 | 16370 | .patterns = &.{ |
| 9681 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16371 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9682 | 16372 | }, |
| 9683 | 16373 | .extra_temps = .{ |
| 9684 | 16374 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9702,9 +16392,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9702 | 16392 | .src_constraints = .{ |
| 9703 | 16393 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9704 | 16394 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 16395 | .any, |
| 9705 | 16396 | }, |
| 9706 | 16397 | .patterns = &.{ |
| 9707 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16398 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9708 | 16399 | }, |
| 9709 | 16400 | .extra_temps = .{ |
| 9710 | 16401 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9735,9 +16426,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9735 | 16426 | .src_constraints = .{ |
| 9736 | 16427 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9737 | 16428 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 16429 | .any, |
| 9738 | 16430 | }, |
| 9739 | 16431 | .patterns = &.{ |
| 9740 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16432 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9741 | 16433 | }, |
| 9742 | 16434 | .extra_temps = .{ |
| 9743 | 16435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9758,7 +16450,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9758 | 16450 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9759 | 16451 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 9760 | 16452 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 9761 | | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 16453 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ }, |
| 9762 | 16454 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 9763 | 16455 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 9764 | 16456 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| ... | ... | @@ -9769,9 +16461,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9769 | 16461 | .src_constraints = .{ |
| 9770 | 16462 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9771 | 16463 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 16464 | .any, |
| 9772 | 16465 | }, |
| 9773 | 16466 | .patterns = &.{ |
| 9774 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16467 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9775 | 16468 | }, |
| 9776 | 16469 | .extra_temps = .{ |
| 9777 | 16470 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -9792,7 +16485,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9792 | 16485 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9793 | 16486 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 9794 | 16487 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 9795 | | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 16488 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ }, |
| 9796 | 16489 | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 9797 | 16490 | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 9798 | 16491 | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| ... | ... | @@ -9805,9 +16498,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9805 | 16498 | .src_constraints = .{ |
| 9806 | 16499 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9807 | 16500 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 16501 | .any, |
| 9808 | 16502 | }, |
| 9809 | 16503 | .patterns = &.{ |
| 9810 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16504 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9811 | 16505 | }, |
| 9812 | 16506 | .extra_temps = .{ |
| 9813 | 16507 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9822,8 +16516,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9822 | 16516 | }, |
| 9823 | 16517 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9824 | 16518 | .each = .{ .once = &.{ |
| 9825 | | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, |
| 9826 | | .{ ._, .v_sd, .min, .dst0x, .src1x, .src0x, ._ }, |
| 16519 | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0q, .vp(.unord) }, |
| 16520 | .{ ._, .v_sd, .min, .dst0x, .src1x, .src0q, ._ }, |
| 9827 | 16521 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, |
| 9828 | 16522 | } }, |
| 9829 | 16523 | }, .{ |
| ... | ... | @@ -9831,15 +16525,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9831 | 16525 | .src_constraints = .{ |
| 9832 | 16526 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9833 | 16527 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 16528 | .any, |
| 9834 | 16529 | }, |
| 9835 | 16530 | .patterns = &.{ |
| 9836 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 16531 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9837 | 16532 | }, |
| 9838 | 16533 | .dst_temps = .{.{ .rc = .sse }}, |
| 9839 | 16534 | .each = .{ .once = &.{ |
| 9840 | 16535 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 9841 | | .{ ._, ._sd, .min, .dst0x, .src0x, ._, ._ }, |
| 9842 | | .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 16536 | .{ ._, ._sd, .min, .dst0x, .src0q, ._, ._ }, |
| 16537 | .{ ._, ._sd, .cmp, .src0x, .src0q, .sp(.unord), ._ }, |
| 9843 | 16538 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 9844 | 16539 | } }, |
| 9845 | 16540 | }, .{ |
| ... | ... | @@ -9847,9 +16542,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9847 | 16542 | .src_constraints = .{ |
| 9848 | 16543 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9849 | 16544 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 16545 | .any, |
| 9850 | 16546 | }, |
| 9851 | 16547 | .patterns = &.{ |
| 9852 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 16548 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9853 | 16549 | }, |
| 9854 | 16550 | .extra_temps = .{ |
| 9855 | 16551 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9865,8 +16561,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9865 | 16561 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9866 | 16562 | .each = .{ .once = &.{ |
| 9867 | 16563 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9868 | | .{ ._, ._sd, .min, .tmp0x, .src0x, ._, ._ }, |
| 9869 | | .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 16564 | .{ ._, ._sd, .min, .tmp0x, .src0q, ._, ._ }, |
| 16565 | .{ ._, ._sd, .cmp, .dst0x, .src0q, .sp(.ord), ._ }, |
| 9870 | 16566 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9871 | 16567 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 9872 | 16568 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | ... | @@ -9876,9 +16572,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9876 | 16572 | .src_constraints = .{ |
| 9877 | 16573 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9878 | 16574 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 16575 | .any, |
| 9879 | 16576 | }, |
| 9880 | 16577 | .patterns = &.{ |
| 9881 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 16578 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 9882 | 16579 | }, |
| 9883 | 16580 | .call_frame = .{ .alignment = .@"16" }, |
| 9884 | 16581 | .extra_temps = .{ |
| ... | ... | @@ -9902,9 +16599,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9902 | 16599 | .src_constraints = .{ |
| 9903 | 16600 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9904 | 16601 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 16602 | .any, |
| 9905 | 16603 | }, |
| 9906 | 16604 | .patterns = &.{ |
| 9907 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16605 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9908 | 16606 | }, |
| 9909 | 16607 | .extra_temps = .{ |
| 9910 | 16608 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9928,17 +16626,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9928 | 16626 | .src_constraints = .{ |
| 9929 | 16627 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9930 | 16628 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 16629 | .any, |
| 9931 | 16630 | }, |
| 9932 | 16631 | .patterns = &.{ |
| 9933 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, |
| 9934 | | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, |
| 9935 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, |
| 16632 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| 16633 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } }, |
| 16634 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9936 | 16635 | }, |
| 9937 | 16636 | .dst_temps = .{.{ .rc = .sse }}, |
| 9938 | 16637 | .each = .{ .once = &.{ |
| 9939 | 16638 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 9940 | 16639 | .{ ._, ._pd, .min, .dst0x, .src0x, ._, ._ }, |
| 9941 | | .{ ._, ._pd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, |
| 16640 | .{ ._, ._pd, .cmp, .src0x, .src0x, .sp(.unord), ._ }, |
| 9942 | 16641 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, |
| 9943 | 16642 | } }, |
| 9944 | 16643 | }, .{ |
| ... | ... | @@ -9946,11 +16645,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9946 | 16645 | .src_constraints = .{ |
| 9947 | 16646 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9948 | 16647 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 16648 | .any, |
| 9949 | 16649 | }, |
| 9950 | 16650 | .patterns = &.{ |
| 9951 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 9952 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 9953 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 16651 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 16652 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 16653 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9954 | 16654 | }, |
| 9955 | 16655 | .extra_temps = .{ |
| 9956 | 16656 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -9967,7 +16667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9967 | 16667 | .each = .{ .once = &.{ |
| 9968 | 16668 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9969 | 16669 | .{ ._, ._pd, .min, .tmp0x, .src0x, ._, ._ }, |
| 9970 | | .{ ._, ._pd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, |
| 16670 | .{ ._, ._pd, .cmp, .dst0x, .src0x, .sp(.ord), ._ }, |
| 9971 | 16671 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9972 | 16672 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 9973 | 16673 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | ... | @@ -9977,9 +16677,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9977 | 16677 | .src_constraints = .{ |
| 9978 | 16678 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 9979 | 16679 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 16680 | .any, |
| 9980 | 16681 | }, |
| 9981 | 16682 | .patterns = &.{ |
| 9982 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 16683 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9983 | 16684 | }, |
| 9984 | 16685 | .extra_temps = .{ |
| 9985 | 16686 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -10003,9 +16704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10003 | 16704 | .src_constraints = .{ |
| 10004 | 16705 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 10005 | 16706 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 16707 | .any, |
| 10006 | 16708 | }, |
| 10007 | 16709 | .patterns = &.{ |
| 10008 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16710 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10009 | 16711 | }, |
| 10010 | 16712 | .extra_temps = .{ |
| 10011 | 16713 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10036,9 +16738,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10036 | 16738 | .src_constraints = .{ |
| 10037 | 16739 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10038 | 16740 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 16741 | .any, |
| 10039 | 16742 | }, |
| 10040 | 16743 | .patterns = &.{ |
| 10041 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16744 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10042 | 16745 | }, |
| 10043 | 16746 | .extra_temps = .{ |
| 10044 | 16747 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10059,7 +16762,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10059 | 16762 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10060 | 16763 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 10061 | 16764 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 10062 | | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, |
| 16765 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ }, |
| 10063 | 16766 | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 10064 | 16767 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 10065 | 16768 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| ... | ... | @@ -10070,9 +16773,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10070 | 16773 | .src_constraints = .{ |
| 10071 | 16774 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10072 | 16775 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 16776 | .any, |
| 10073 | 16777 | }, |
| 10074 | 16778 | .patterns = &.{ |
| 10075 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16779 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10076 | 16780 | }, |
| 10077 | 16781 | .extra_temps = .{ |
| 10078 | 16782 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10093,7 +16797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10093 | 16797 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10094 | 16798 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 10095 | 16799 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 10096 | | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, |
| 16800 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ }, |
| 10097 | 16801 | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 10098 | 16802 | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 10099 | 16803 | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| ... | ... | @@ -10106,9 +16810,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10106 | 16810 | .src_constraints = .{ |
| 10107 | 16811 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 10108 | 16812 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 16813 | .any, |
| 10109 | 16814 | }, |
| 10110 | 16815 | .patterns = &.{ |
| 10111 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16816 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10112 | 16817 | }, |
| 10113 | 16818 | .call_frame = .{ .alignment = .@"16" }, |
| 10114 | 16819 | .extra_temps = .{ |
| ... | ... | @@ -10140,11 +16845,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10140 | 16845 | .src_constraints = .{ |
| 10141 | 16846 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10142 | 16847 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 16848 | .any, |
| 10143 | 16849 | }, |
| 10144 | 16850 | .patterns = &.{ |
| 10145 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 10146 | | .{ .src = .{ .mem, .to_x87 } }, |
| 10147 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 16851 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 16852 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 16853 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 10148 | 16854 | }, |
| 10149 | 16855 | .extra_temps = .{ |
| 10150 | 16856 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | ... | @@ -10172,11 +16878,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10172 | 16878 | .src_constraints = .{ |
| 10173 | 16879 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10174 | 16880 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 16881 | .any, |
| 10175 | 16882 | }, |
| 10176 | 16883 | .patterns = &.{ |
| 10177 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 10178 | | .{ .src = .{ .mem, .to_x87 } }, |
| 10179 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 16884 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 16885 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 16886 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 10180 | 16887 | }, |
| 10181 | 16888 | .extra_temps = .{ |
| 10182 | 16889 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | ... | @@ -10210,11 +16917,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10210 | 16917 | .src_constraints = .{ |
| 10211 | 16918 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10212 | 16919 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 16920 | .any, |
| 10213 | 16921 | }, |
| 10214 | 16922 | .patterns = &.{ |
| 10215 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 10216 | | .{ .src = .{ .mem, .to_x87 } }, |
| 10217 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 16923 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 16924 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 16925 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 10218 | 16926 | }, |
| 10219 | 16927 | .extra_temps = .{ |
| 10220 | 16928 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | ... | @@ -10248,9 +16956,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10248 | 16956 | .src_constraints = .{ |
| 10249 | 16957 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10250 | 16958 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 16959 | .any, |
| 10251 | 16960 | }, |
| 10252 | 16961 | .patterns = &.{ |
| 10253 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16962 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10254 | 16963 | }, |
| 10255 | 16964 | .extra_temps = .{ |
| 10256 | 16965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10283,9 +16992,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10283 | 16992 | .src_constraints = .{ |
| 10284 | 16993 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10285 | 16994 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 16995 | .any, |
| 10286 | 16996 | }, |
| 10287 | 16997 | .patterns = &.{ |
| 10288 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 16998 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10289 | 16999 | }, |
| 10290 | 17000 | .extra_temps = .{ |
| 10291 | 17001 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10324,9 +17034,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10324 | 17034 | .src_constraints = .{ |
| 10325 | 17035 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10326 | 17036 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 17037 | .any, |
| 10327 | 17038 | }, |
| 10328 | 17039 | .patterns = &.{ |
| 10329 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17040 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10330 | 17041 | }, |
| 10331 | 17042 | .extra_temps = .{ |
| 10332 | 17043 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10365,9 +17076,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10365 | 17076 | .src_constraints = .{ |
| 10366 | 17077 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10367 | 17078 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 17079 | .any, |
| 10368 | 17080 | }, |
| 10369 | 17081 | .patterns = &.{ |
| 10370 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 17082 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 10371 | 17083 | }, |
| 10372 | 17084 | .call_frame = .{ .alignment = .@"16" }, |
| 10373 | 17085 | .extra_temps = .{ |
| ... | ... | @@ -10391,9 +17103,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10391 | 17103 | .src_constraints = .{ |
| 10392 | 17104 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10393 | 17105 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 17106 | .any, |
| 10394 | 17107 | }, |
| 10395 | 17108 | .patterns = &.{ |
| 10396 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17109 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10397 | 17110 | }, |
| 10398 | 17111 | .call_frame = .{ .alignment = .@"16" }, |
| 10399 | 17112 | .extra_temps = .{ |
| ... | ... | @@ -10423,9 +17136,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10423 | 17136 | .src_constraints = .{ |
| 10424 | 17137 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10425 | 17138 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 17139 | .any, |
| 10426 | 17140 | }, |
| 10427 | 17141 | .patterns = &.{ |
| 10428 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17142 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10429 | 17143 | }, |
| 10430 | 17144 | .call_frame = .{ .alignment = .@"16" }, |
| 10431 | 17145 | .extra_temps = .{ |
| ... | ... | @@ -10455,9 +17169,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10455 | 17169 | .src_constraints = .{ |
| 10456 | 17170 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10457 | 17171 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 17172 | .any, |
| 10458 | 17173 | }, |
| 10459 | 17174 | .patterns = &.{ |
| 10460 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17175 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10461 | 17176 | }, |
| 10462 | 17177 | .call_frame = .{ .alignment = .@"16" }, |
| 10463 | 17178 | .extra_temps = .{ |
| ... | ... | @@ -10529,17 +17244,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10529 | 17244 | })) { |
| 10530 | 17245 | else => unreachable, |
| 10531 | 17246 | inline .@"and", .@"or", .xor => |mir_tag| comptime &.{ .{ |
| 10532 | | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte } }, |
| 17247 | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte }, .any }, |
| 10533 | 17248 | .patterns = &.{ |
| 10534 | | .{ .src = .{ .mut_mem, .imm8 } }, |
| 10535 | | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10536 | | .{ .src = .{ .to_mut_gpr, .imm8 } }, |
| 10537 | | .{ .src = .{ .imm8, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10538 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 10539 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10540 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 10541 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10542 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 17249 | .{ .src = .{ .mut_mem, .imm8, .none } }, |
| 17250 | .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17251 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 17252 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17253 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 17254 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17255 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 17256 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17257 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10543 | 17258 | }, |
| 10544 | 17259 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10545 | 17260 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10547,17 +17262,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10547 | 17262 | .{ ._, ._, mir_tag, .dst0b, .src1b, ._, ._ }, |
| 10548 | 17263 | } }, |
| 10549 | 17264 | }, .{ |
| 10550 | | .src_constraints = .{ .{ .size = .word }, .{ .size = .word } }, |
| 17265 | .src_constraints = .{ .{ .size = .word }, .{ .size = .word }, .any }, |
| 10551 | 17266 | .patterns = &.{ |
| 10552 | | .{ .src = .{ .mut_mem, .imm16 } }, |
| 10553 | | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10554 | | .{ .src = .{ .to_mut_gpr, .imm16 } }, |
| 10555 | | .{ .src = .{ .imm16, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10556 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 10557 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10558 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 10559 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10560 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 17267 | .{ .src = .{ .mut_mem, .imm16, .none } }, |
| 17268 | .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17269 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 17270 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17271 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 17272 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17273 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 17274 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17275 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10561 | 17276 | }, |
| 10562 | 17277 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10563 | 17278 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10565,17 +17280,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10565 | 17280 | .{ ._, ._, mir_tag, .dst0w, .src1w, ._, ._ }, |
| 10566 | 17281 | } }, |
| 10567 | 17282 | }, .{ |
| 10568 | | .src_constraints = .{ .{ .size = .dword }, .{ .size = .dword } }, |
| 17283 | .src_constraints = .{ .{ .size = .dword }, .{ .size = .dword }, .any }, |
| 10569 | 17284 | .patterns = &.{ |
| 10570 | | .{ .src = .{ .mut_mem, .imm32 } }, |
| 10571 | | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10572 | | .{ .src = .{ .to_mut_gpr, .imm32 } }, |
| 10573 | | .{ .src = .{ .imm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10574 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 10575 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10576 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 10577 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10578 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 17285 | .{ .src = .{ .mut_mem, .imm32, .none } }, |
| 17286 | .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17287 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 17288 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17289 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 17290 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17291 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 17292 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17293 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10579 | 17294 | }, |
| 10580 | 17295 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10581 | 17296 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10584,17 +17299,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10584 | 17299 | } }, |
| 10585 | 17300 | }, .{ |
| 10586 | 17301 | .required_features = .{ .@"64bit", null, null, null }, |
| 10587 | | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword } }, |
| 17302 | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword }, .any }, |
| 10588 | 17303 | .patterns = &.{ |
| 10589 | | .{ .src = .{ .mut_mem, .simm32 } }, |
| 10590 | | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10591 | | .{ .src = .{ .to_mut_gpr, .simm32 } }, |
| 10592 | | .{ .src = .{ .simm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10593 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 10594 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 10595 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 10596 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 10597 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 17304 | .{ .src = .{ .mut_mem, .simm32, .none } }, |
| 17305 | .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17306 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 17307 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17308 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 17309 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 17310 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 17311 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 17312 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10598 | 17313 | }, |
| 10599 | 17314 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10600 | 17315 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10603,11 +17318,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10603 | 17318 | } }, |
| 10604 | 17319 | }, .{ |
| 10605 | 17320 | .required_features = .{ .mmx, null, null, null }, |
| 10606 | | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword } }, |
| 17321 | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword }, .any }, |
| 10607 | 17322 | .patterns = &.{ |
| 10608 | | .{ .src = .{ .to_mut_mm, .mem } }, |
| 10609 | | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 10610 | | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 17323 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 17324 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 17325 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 10611 | 17326 | }, |
| 10612 | 17327 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10613 | 17328 | .each = .{ .once = &.{ |
| ... | ... | @@ -10615,11 +17330,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10615 | 17330 | } }, |
| 10616 | 17331 | }, .{ |
| 10617 | 17332 | .required_features = .{ .avx, null, null, null }, |
| 10618 | | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword } }, |
| 17333 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any }, |
| 10619 | 17334 | .patterns = &.{ |
| 10620 | | .{ .src = .{ .to_xmm, .mem } }, |
| 10621 | | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 10622 | | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 17335 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 17336 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 17337 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 10623 | 17338 | }, |
| 10624 | 17339 | .dst_temps = .{.{ .rc = .sse }}, |
| 10625 | 17340 | .each = .{ .once = &.{ |
| ... | ... | @@ -10627,11 +17342,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10627 | 17342 | } }, |
| 10628 | 17343 | }, .{ |
| 10629 | 17344 | .required_features = .{ .sse2, null, null, null }, |
| 10630 | | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword } }, |
| 17345 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any }, |
| 10631 | 17346 | .patterns = &.{ |
| 10632 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 10633 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 10634 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 17347 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 17348 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 17349 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 10635 | 17350 | }, |
| 10636 | 17351 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10637 | 17352 | .each = .{ .once = &.{ |
| ... | ... | @@ -10639,11 +17354,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10639 | 17354 | } }, |
| 10640 | 17355 | }, .{ |
| 10641 | 17356 | .required_features = .{ .sse, null, null, null }, |
| 10642 | | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword } }, |
| 17357 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any }, |
| 10643 | 17358 | .patterns = &.{ |
| 10644 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 10645 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 10646 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 17359 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 17360 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 17361 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 10647 | 17362 | }, |
| 10648 | 17363 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10649 | 17364 | .each = .{ .once = &.{ |
| ... | ... | @@ -10651,11 +17366,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10651 | 17366 | } }, |
| 10652 | 17367 | }, .{ |
| 10653 | 17368 | .required_features = .{ .avx2, null, null, null }, |
| 10654 | | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword } }, |
| 17369 | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword }, .any }, |
| 10655 | 17370 | .patterns = &.{ |
| 10656 | | .{ .src = .{ .to_ymm, .mem } }, |
| 10657 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 10658 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 17371 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 17372 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 17373 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 10659 | 17374 | }, |
| 10660 | 17375 | .dst_temps = .{.{ .rc = .sse }}, |
| 10661 | 17376 | .each = .{ .once = &.{ |
| ... | ... | @@ -10663,11 +17378,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10663 | 17378 | } }, |
| 10664 | 17379 | }, .{ |
| 10665 | 17380 | .required_features = .{ .avx, null, null, null }, |
| 10666 | | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword } }, |
| 17381 | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword }, .any }, |
| 10667 | 17382 | .patterns = &.{ |
| 10668 | | .{ .src = .{ .to_ymm, .mem } }, |
| 10669 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 10670 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 17383 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 17384 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 17385 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 10671 | 17386 | }, |
| 10672 | 17387 | .dst_temps = .{.{ .rc = .sse }}, |
| 10673 | 17388 | .each = .{ .once = &.{ |
| ... | ... | @@ -10675,9 +17390,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10675 | 17390 | } }, |
| 10676 | 17391 | }, .{ |
| 10677 | 17392 | .required_features = .{ .avx2, null, null, null }, |
| 10678 | | .src_constraints = .{ .{ .multiple_size = .yword }, .{ .multiple_size = .yword } }, |
| 17393 | .src_constraints = .{ .{ .multiple_size = .yword }, .{ .multiple_size = .yword }, .any }, |
| 10679 | 17394 | .patterns = &.{ |
| 10680 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17395 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10681 | 17396 | }, |
| 10682 | 17397 | .extra_temps = .{ |
| 10683 | 17398 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10702,9 +17417,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10702 | 17417 | } }, |
| 10703 | 17418 | }, .{ |
| 10704 | 17419 | .required_features = .{ .avx, null, null, null }, |
| 10705 | | .src_constraints = .{ .{ .multiple_size = .yword }, .{ .multiple_size = .yword } }, |
| 17420 | .src_constraints = .{ .{ .multiple_size = .yword }, .{ .multiple_size = .yword }, .any }, |
| 10706 | 17421 | .patterns = &.{ |
| 10707 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17422 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10708 | 17423 | }, |
| 10709 | 17424 | .extra_temps = .{ |
| 10710 | 17425 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10729,9 +17444,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10729 | 17444 | } }, |
| 10730 | 17445 | }, .{ |
| 10731 | 17446 | .required_features = .{ .avx, null, null, null }, |
| 10732 | | .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword } }, |
| 17447 | .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword }, .any }, |
| 10733 | 17448 | .patterns = &.{ |
| 10734 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17449 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10735 | 17450 | }, |
| 10736 | 17451 | .extra_temps = .{ |
| 10737 | 17452 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10756,9 +17471,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10756 | 17471 | } }, |
| 10757 | 17472 | }, .{ |
| 10758 | 17473 | .required_features = .{ .sse2, null, null, null }, |
| 10759 | | .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword } }, |
| 17474 | .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword }, .any }, |
| 10760 | 17475 | .patterns = &.{ |
| 10761 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17476 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10762 | 17477 | }, |
| 10763 | 17478 | .extra_temps = .{ |
| 10764 | 17479 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10783,9 +17498,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10783 | 17498 | } }, |
| 10784 | 17499 | }, .{ |
| 10785 | 17500 | .required_features = .{ .sse, null, null, null }, |
| 10786 | | .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword } }, |
| 17501 | .src_constraints = .{ .{ .multiple_size = .xword }, .{ .multiple_size = .xword }, .any }, |
| 10787 | 17502 | .patterns = &.{ |
| 10788 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17503 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10789 | 17504 | }, |
| 10790 | 17505 | .extra_temps = .{ |
| 10791 | 17506 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10810,9 +17525,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10810 | 17525 | } }, |
| 10811 | 17526 | }, .{ |
| 10812 | 17527 | .required_features = .{ .mmx, null, null, null }, |
| 10813 | | .src_constraints = .{ .{ .multiple_size = .qword }, .{ .multiple_size = .qword } }, |
| 17528 | .src_constraints = .{ .{ .multiple_size = .qword }, .{ .multiple_size = .qword }, .any }, |
| 10814 | 17529 | .patterns = &.{ |
| 10815 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17530 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10816 | 17531 | }, |
| 10817 | 17532 | .extra_temps = .{ |
| 10818 | 17533 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10836,9 +17551,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10836 | 17551 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 10837 | 17552 | } }, |
| 10838 | 17553 | }, .{ |
| 10839 | | .src_constraints = .{ .{ .multiple_size = .qword }, .{ .multiple_size = .qword } }, |
| 17554 | .src_constraints = .{ .{ .multiple_size = .qword }, .{ .multiple_size = .qword }, .any }, |
| 10840 | 17555 | .patterns = &.{ |
| 10841 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 17556 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10842 | 17557 | }, |
| 10843 | 17558 | .extra_temps = .{ |
| 10844 | 17559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10878,20 +17593,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10878 | 17593 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 10879 | 17594 | var res: [1]Temp = undefined; |
| 10880 | 17595 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 10881 | | .src_constraints = .{ .{ .signed_or_exact_int = .byte }, .any }, |
| 17596 | .src_constraints = .{ .{ .signed_or_exact_int = .byte }, .any, .any }, |
| 10882 | 17597 | .patterns = &.{ |
| 10883 | | .{ .src = .{ .mut_mem, .none } }, |
| 10884 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17598 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17599 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10885 | 17600 | }, |
| 10886 | 17601 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10887 | 17602 | .each = .{ .once = &.{ |
| 10888 | 17603 | .{ ._, ._, .not, .dst0b, ._, ._, ._ }, |
| 10889 | 17604 | } }, |
| 10890 | 17605 | }, .{ |
| 10891 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| 17606 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 10892 | 17607 | .patterns = &.{ |
| 10893 | | .{ .src = .{ .mut_mem, .none } }, |
| 10894 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17608 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17609 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10895 | 17610 | }, |
| 10896 | 17611 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10897 | 17612 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10899,20 +17614,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10899 | 17614 | .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_umax), ._, ._ }, |
| 10900 | 17615 | } }, |
| 10901 | 17616 | }, .{ |
| 10902 | | .src_constraints = .{ .{ .signed_or_exact_int = .word }, .any }, |
| 17617 | .src_constraints = .{ .{ .signed_or_exact_int = .word }, .any, .any }, |
| 10903 | 17618 | .patterns = &.{ |
| 10904 | | .{ .src = .{ .mut_mem, .none } }, |
| 10905 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17619 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17620 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10906 | 17621 | }, |
| 10907 | 17622 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10908 | 17623 | .each = .{ .once = &.{ |
| 10909 | 17624 | .{ ._, ._, .not, .dst0w, ._, ._, ._ }, |
| 10910 | 17625 | } }, |
| 10911 | 17626 | }, .{ |
| 10912 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| 17627 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 10913 | 17628 | .patterns = &.{ |
| 10914 | | .{ .src = .{ .mut_mem, .none } }, |
| 10915 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17629 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17630 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10916 | 17631 | }, |
| 10917 | 17632 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10918 | 17633 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10920,20 +17635,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10920 | 17635 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_umax), ._, ._ }, |
| 10921 | 17636 | } }, |
| 10922 | 17637 | }, .{ |
| 10923 | | .src_constraints = .{ .{ .signed_or_exact_int = .dword }, .any }, |
| 17638 | .src_constraints = .{ .{ .signed_or_exact_int = .dword }, .any, .any }, |
| 10924 | 17639 | .patterns = &.{ |
| 10925 | | .{ .src = .{ .mut_mem, .none } }, |
| 10926 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17640 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17641 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10927 | 17642 | }, |
| 10928 | 17643 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10929 | 17644 | .each = .{ .once = &.{ |
| 10930 | 17645 | .{ ._, ._, .not, .dst0d, ._, ._, ._ }, |
| 10931 | 17646 | } }, |
| 10932 | 17647 | }, .{ |
| 10933 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| 17648 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 10934 | 17649 | .patterns = &.{ |
| 10935 | | .{ .src = .{ .mut_mem, .none } }, |
| 10936 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17650 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17651 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10937 | 17652 | }, |
| 10938 | 17653 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10939 | 17654 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -10942,10 +17657,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10942 | 17657 | } }, |
| 10943 | 17658 | }, .{ |
| 10944 | 17659 | .required_features = .{ .@"64bit", null, null, null }, |
| 10945 | | .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any }, |
| 17660 | .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any, .any }, |
| 10946 | 17661 | .patterns = &.{ |
| 10947 | | .{ .src = .{ .mut_mem, .none } }, |
| 10948 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 17662 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 17663 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10949 | 17664 | }, |
| 10950 | 17665 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10951 | 17666 | .each = .{ .once = &.{ |
| ... | ... | @@ -10953,10 +17668,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10953 | 17668 | } }, |
| 10954 | 17669 | }, .{ |
| 10955 | 17670 | .required_features = .{ .@"64bit", null, null, null }, |
| 10956 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 17671 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 10957 | 17672 | .patterns = &.{ |
| 10958 | | .{ .src = .{ .mem, .none } }, |
| 10959 | | .{ .src = .{ .to_gpr, .none } }, |
| 17673 | .{ .src = .{ .mem, .none, .none } }, |
| 17674 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 10960 | 17675 | }, |
| 10961 | 17676 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 10962 | 17677 | .each = .{ .once = &.{ |
| ... | ... | @@ -10965,10 +17680,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10965 | 17680 | } }, |
| 10966 | 17681 | }, .{ |
| 10967 | 17682 | .required_features = .{ .mmx, null, null, null }, |
| 10968 | | .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any }, |
| 17683 | .src_constraints = .{ .{ .signed_or_exact_int = .qword }, .any, .any }, |
| 10969 | 17684 | .patterns = &.{ |
| 10970 | | .{ .src = .{ .mem, .none } }, |
| 10971 | | .{ .src = .{ .to_mm, .none } }, |
| 17685 | .{ .src = .{ .mem, .none, .none } }, |
| 17686 | .{ .src = .{ .to_mm, .none, .none } }, |
| 10972 | 17687 | }, |
| 10973 | 17688 | .dst_temps = .{.{ .rc = .mmx }}, |
| 10974 | 17689 | .each = .{ .once = &.{ |
| ... | ... | @@ -10977,9 +17692,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10977 | 17692 | } }, |
| 10978 | 17693 | }, .{ |
| 10979 | 17694 | .required_features = .{ .mmx, null, null, null }, |
| 10980 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 17695 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 10981 | 17696 | .patterns = &.{ |
| 10982 | | .{ .src = .{ .to_mut_mm, .none } }, |
| 17697 | .{ .src = .{ .to_mut_mm, .none, .none } }, |
| 10983 | 17698 | }, |
| 10984 | 17699 | .extra_temps = .{ |
| 10985 | 17700 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -10999,10 +17714,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10999 | 17714 | } }, |
| 11000 | 17715 | }, .{ |
| 11001 | 17716 | .required_features = .{ .avx, null, null, null }, |
| 11002 | | .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any }, |
| 17717 | .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any, .any }, |
| 11003 | 17718 | .patterns = &.{ |
| 11004 | | .{ .src = .{ .mem, .none } }, |
| 11005 | | .{ .src = .{ .to_xmm, .none } }, |
| 17719 | .{ .src = .{ .mem, .none, .none } }, |
| 17720 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11006 | 17721 | }, |
| 11007 | 17722 | .dst_temps = .{.{ .rc = .sse }}, |
| 11008 | 17723 | .each = .{ .once = &.{ |
| ... | ... | @@ -11011,9 +17726,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11011 | 17726 | } }, |
| 11012 | 17727 | }, .{ |
| 11013 | 17728 | .required_features = .{ .avx, null, null, null }, |
| 11014 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .any }, |
| 17729 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 11015 | 17730 | .patterns = &.{ |
| 11016 | | .{ .src = .{ .to_xmm, .none } }, |
| 17731 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11017 | 17732 | }, |
| 11018 | 17733 | .extra_temps = .{ |
| 11019 | 17734 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11033,10 +17748,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11033 | 17748 | } }, |
| 11034 | 17749 | }, .{ |
| 11035 | 17750 | .required_features = .{ .sse2, null, null, null }, |
| 11036 | | .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any }, |
| 17751 | .src_constraints = .{ .{ .signed_or_exact_int = .xword }, .any, .any }, |
| 11037 | 17752 | .patterns = &.{ |
| 11038 | | .{ .src = .{ .mem, .none } }, |
| 11039 | | .{ .src = .{ .to_xmm, .none } }, |
| 17753 | .{ .src = .{ .mem, .none, .none } }, |
| 17754 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11040 | 17755 | }, |
| 11041 | 17756 | .dst_temps = .{.{ .rc = .sse }}, |
| 11042 | 17757 | .each = .{ .once = &.{ |
| ... | ... | @@ -11045,9 +17760,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11045 | 17760 | } }, |
| 11046 | 17761 | }, .{ |
| 11047 | 17762 | .required_features = .{ .sse2, null, null, null }, |
| 11048 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .any }, |
| 17763 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 11049 | 17764 | .patterns = &.{ |
| 11050 | | .{ .src = .{ .to_mut_xmm, .none } }, |
| 17765 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11051 | 17766 | }, |
| 11052 | 17767 | .extra_temps = .{ |
| 11053 | 17768 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11067,9 +17782,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11067 | 17782 | } }, |
| 11068 | 17783 | }, .{ |
| 11069 | 17784 | .required_features = .{ .sse, null, null, null }, |
| 11070 | | .src_constraints = .{ .{ .int = .xword }, .any }, |
| 17785 | .src_constraints = .{ .{ .int = .xword }, .any, .any }, |
| 11071 | 17786 | .patterns = &.{ |
| 11072 | | .{ .src = .{ .to_mut_xmm, .none } }, |
| 17787 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11073 | 17788 | }, |
| 11074 | 17789 | .extra_temps = .{ |
| 11075 | 17790 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11089,10 +17804,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11089 | 17804 | } }, |
| 11090 | 17805 | }, .{ |
| 11091 | 17806 | .required_features = .{ .avx2, null, null, null }, |
| 11092 | | .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any }, |
| 17807 | .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any, .any }, |
| 11093 | 17808 | .patterns = &.{ |
| 11094 | | .{ .src = .{ .mem, .none } }, |
| 11095 | | .{ .src = .{ .to_ymm, .none } }, |
| 17809 | .{ .src = .{ .mem, .none, .none } }, |
| 17810 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11096 | 17811 | }, |
| 11097 | 17812 | .dst_temps = .{.{ .rc = .sse }}, |
| 11098 | 17813 | .each = .{ .once = &.{ |
| ... | ... | @@ -11101,9 +17816,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11101 | 17816 | } }, |
| 11102 | 17817 | }, .{ |
| 11103 | 17818 | .required_features = .{ .avx2, null, null, null }, |
| 11104 | | .src_constraints = .{ .{ .unsigned_int = .yword }, .any }, |
| 17819 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any, .any }, |
| 11105 | 17820 | .patterns = &.{ |
| 11106 | | .{ .src = .{ .to_ymm, .none } }, |
| 17821 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11107 | 17822 | }, |
| 11108 | 17823 | .extra_temps = .{ |
| 11109 | 17824 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11123,10 +17838,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11123 | 17838 | } }, |
| 11124 | 17839 | }, .{ |
| 11125 | 17840 | .required_features = .{ .avx, null, null, null }, |
| 11126 | | .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any }, |
| 17841 | .src_constraints = .{ .{ .signed_or_exact_int = .yword }, .any, .any }, |
| 11127 | 17842 | .patterns = &.{ |
| 11128 | | .{ .src = .{ .mem, .none } }, |
| 11129 | | .{ .src = .{ .to_ymm, .none } }, |
| 17843 | .{ .src = .{ .mem, .none, .none } }, |
| 17844 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11130 | 17845 | }, |
| 11131 | 17846 | .dst_temps = .{.{ .rc = .sse }}, |
| 11132 | 17847 | .each = .{ .once = &.{ |
| ... | ... | @@ -11135,9 +17850,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11135 | 17850 | } }, |
| 11136 | 17851 | }, .{ |
| 11137 | 17852 | .required_features = .{ .avx, null, null, null }, |
| 11138 | | .src_constraints = .{ .{ .unsigned_int = .yword }, .any }, |
| 17853 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any, .any }, |
| 11139 | 17854 | .patterns = &.{ |
| 11140 | | .{ .src = .{ .to_ymm, .none } }, |
| 17855 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11141 | 17856 | }, |
| 11142 | 17857 | .extra_temps = .{ |
| 11143 | 17858 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11157,9 +17872,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11157 | 17872 | } }, |
| 11158 | 17873 | }, .{ |
| 11159 | 17874 | .required_features = .{ .avx2, null, null, null }, |
| 11160 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any }, |
| 17875 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| 11161 | 17876 | .patterns = &.{ |
| 11162 | | .{ .src = .{ .to_mem, .none } }, |
| 17877 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11163 | 17878 | }, |
| 11164 | 17879 | .extra_temps = .{ |
| 11165 | 17880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11186,9 +17901,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11186 | 17901 | } }, |
| 11187 | 17902 | }, .{ |
| 11188 | 17903 | .required_features = .{ .avx2, null, null, null }, |
| 11189 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 17904 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 11190 | 17905 | .patterns = &.{ |
| 11191 | | .{ .src = .{ .to_mem, .none } }, |
| 17906 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11192 | 17907 | }, |
| 11193 | 17908 | .extra_temps = .{ |
| 11194 | 17909 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11213,9 +17928,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11213 | 17928 | } }, |
| 11214 | 17929 | }, .{ |
| 11215 | 17930 | .required_features = .{ .avx, null, null, null }, |
| 11216 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any }, |
| 17931 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| 11217 | 17932 | .patterns = &.{ |
| 11218 | | .{ .src = .{ .to_mem, .none } }, |
| 17933 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11219 | 17934 | }, |
| 11220 | 17935 | .extra_temps = .{ |
| 11221 | 17936 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11242,9 +17957,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11242 | 17957 | } }, |
| 11243 | 17958 | }, .{ |
| 11244 | 17959 | .required_features = .{ .avx, null, null, null }, |
| 11245 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 17960 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 11246 | 17961 | .patterns = &.{ |
| 11247 | | .{ .src = .{ .to_mem, .none } }, |
| 17962 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11248 | 17963 | }, |
| 11249 | 17964 | .extra_temps = .{ |
| 11250 | 17965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11269,9 +17984,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11269 | 17984 | } }, |
| 11270 | 17985 | }, .{ |
| 11271 | 17986 | .required_features = .{ .avx, null, null, null }, |
| 11272 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 17987 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 11273 | 17988 | .patterns = &.{ |
| 11274 | | .{ .src = .{ .to_mem, .none } }, |
| 17989 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11275 | 17990 | }, |
| 11276 | 17991 | .extra_temps = .{ |
| 11277 | 17992 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11296,9 +18011,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11296 | 18011 | } }, |
| 11297 | 18012 | }, .{ |
| 11298 | 18013 | .required_features = .{ .sse2, null, null, null }, |
| 11299 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 18014 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 11300 | 18015 | .patterns = &.{ |
| 11301 | | .{ .src = .{ .to_mem, .none } }, |
| 18016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11302 | 18017 | }, |
| 11303 | 18018 | .extra_temps = .{ |
| 11304 | 18019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11324,9 +18039,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11324 | 18039 | } }, |
| 11325 | 18040 | }, .{ |
| 11326 | 18041 | .required_features = .{ .@"64bit", null, null, null }, |
| 11327 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 18042 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 11328 | 18043 | .patterns = &.{ |
| 11329 | | .{ .src = .{ .mut_mem, .none } }, |
| 18044 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11330 | 18045 | }, |
| 11331 | 18046 | .extra_temps = .{ |
| 11332 | 18047 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11350,9 +18065,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11350 | 18065 | } }, |
| 11351 | 18066 | }, .{ |
| 11352 | 18067 | .required_features = .{ .@"64bit", null, null, null }, |
| 11353 | | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 18068 | .src_constraints = .{ .{ .signed_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 11354 | 18069 | .patterns = &.{ |
| 11355 | | .{ .src = .{ .to_mem, .none } }, |
| 18070 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11356 | 18071 | }, |
| 11357 | 18072 | .extra_temps = .{ |
| 11358 | 18073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11377,9 +18092,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11377 | 18092 | } }, |
| 11378 | 18093 | }, .{ |
| 11379 | 18094 | .required_features = .{ .@"64bit", null, null, null }, |
| 11380 | | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 18095 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 11381 | 18096 | .patterns = &.{ |
| 11382 | | .{ .src = .{ .mut_mem, .none } }, |
| 18097 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11383 | 18098 | }, |
| 11384 | 18099 | .extra_temps = .{ |
| 11385 | 18100 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11404,9 +18119,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11404 | 18119 | } }, |
| 11405 | 18120 | }, .{ |
| 11406 | 18121 | .required_features = .{ .@"64bit", null, null, null }, |
| 11407 | | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 18122 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 11408 | 18123 | .patterns = &.{ |
| 11409 | | .{ .src = .{ .to_mem, .none } }, |
| 18124 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11410 | 18125 | }, |
| 11411 | 18126 | .extra_temps = .{ |
| 11412 | 18127 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11436,9 +18151,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11436 | 18151 | } }, |
| 11437 | 18152 | }, .{ |
| 11438 | 18153 | .required_features = .{ .@"64bit", null, null, null }, |
| 11439 | | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 18154 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 11440 | 18155 | .patterns = &.{ |
| 11441 | | .{ .src = .{ .mut_mem, .none } }, |
| 18156 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11442 | 18157 | }, |
| 11443 | 18158 | .extra_temps = .{ |
| 11444 | 18159 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11463,9 +18178,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11463 | 18178 | } }, |
| 11464 | 18179 | }, .{ |
| 11465 | 18180 | .required_features = .{ .@"64bit", null, null, null }, |
| 11466 | | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 18181 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 11467 | 18182 | .patterns = &.{ |
| 11468 | | .{ .src = .{ .to_mem, .none } }, |
| 18183 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11469 | 18184 | }, |
| 11470 | 18185 | .extra_temps = .{ |
| 11471 | 18186 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11491,9 +18206,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11491 | 18206 | } }, |
| 11492 | 18207 | }, .{ |
| 11493 | 18208 | .required_features = .{ .@"64bit", null, null, null }, |
| 11494 | | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 18209 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 11495 | 18210 | .patterns = &.{ |
| 11496 | | .{ .src = .{ .mut_mem, .none } }, |
| 18211 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11497 | 18212 | }, |
| 11498 | 18213 | .extra_temps = .{ |
| 11499 | 18214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11517,9 +18232,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11517 | 18232 | } }, |
| 11518 | 18233 | }, .{ |
| 11519 | 18234 | .required_features = .{ .@"64bit", null, null, null }, |
| 11520 | | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 18235 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 11521 | 18236 | .patterns = &.{ |
| 11522 | | .{ .src = .{ .to_mem, .none } }, |
| 18237 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11523 | 18238 | }, |
| 11524 | 18239 | .extra_temps = .{ |
| 11525 | 18240 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11548,9 +18263,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11548 | 18263 | } }, |
| 11549 | 18264 | }, .{ |
| 11550 | 18265 | .required_features = .{ .@"64bit", null, null, null }, |
| 11551 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 18266 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 11552 | 18267 | .patterns = &.{ |
| 11553 | | .{ .src = .{ .mut_mem, .none } }, |
| 18268 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11554 | 18269 | }, |
| 11555 | 18270 | .extra_temps = .{ |
| 11556 | 18271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11575,9 +18290,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11575 | 18290 | } }, |
| 11576 | 18291 | }, .{ |
| 11577 | 18292 | .required_features = .{ .@"64bit", null, null, null }, |
| 11578 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 18293 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 11579 | 18294 | .patterns = &.{ |
| 11580 | | .{ .src = .{ .to_mem, .none } }, |
| 18295 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11581 | 18296 | }, |
| 11582 | 18297 | .extra_temps = .{ |
| 11583 | 18298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11607,9 +18322,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11607 | 18322 | } }, |
| 11608 | 18323 | }, .{ |
| 11609 | 18324 | .required_features = .{ .@"64bit", null, null, null }, |
| 11610 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 18325 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 11611 | 18326 | .patterns = &.{ |
| 11612 | | .{ .src = .{ .mut_mem, .none } }, |
| 18327 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11613 | 18328 | }, |
| 11614 | 18329 | .extra_temps = .{ |
| 11615 | 18330 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11633,9 +18348,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11633 | 18348 | } }, |
| 11634 | 18349 | }, .{ |
| 11635 | 18350 | .required_features = .{ .@"64bit", null, null, null }, |
| 11636 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 18351 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 11637 | 18352 | .patterns = &.{ |
| 11638 | | .{ .src = .{ .to_mem, .none } }, |
| 18353 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11639 | 18354 | }, |
| 11640 | 18355 | .extra_temps = .{ |
| 11641 | 18356 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11664,9 +18379,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11664 | 18379 | } }, |
| 11665 | 18380 | }, .{ |
| 11666 | 18381 | .required_features = .{ .@"64bit", null, null, null }, |
| 11667 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 18382 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 11668 | 18383 | .patterns = &.{ |
| 11669 | | .{ .src = .{ .mut_mem, .none } }, |
| 18384 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11670 | 18385 | }, |
| 11671 | 18386 | .extra_temps = .{ |
| 11672 | 18387 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11692,9 +18407,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11692 | 18407 | } }, |
| 11693 | 18408 | }, .{ |
| 11694 | 18409 | .required_features = .{ .@"64bit", null, null, null }, |
| 11695 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 18410 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 11696 | 18411 | .patterns = &.{ |
| 11697 | | .{ .src = .{ .to_mem, .none } }, |
| 18412 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11698 | 18413 | }, |
| 11699 | 18414 | .extra_temps = .{ |
| 11700 | 18415 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11723,9 +18438,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11723 | 18438 | } }, |
| 11724 | 18439 | }, .{ |
| 11725 | 18440 | .required_features = .{ .@"64bit", null, null, null }, |
| 11726 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 18441 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 11727 | 18442 | .patterns = &.{ |
| 11728 | | .{ .src = .{ .mut_mem, .none } }, |
| 18443 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11729 | 18444 | }, |
| 11730 | 18445 | .extra_temps = .{ |
| 11731 | 18446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11750,9 +18465,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11750 | 18465 | } }, |
| 11751 | 18466 | }, .{ |
| 11752 | 18467 | .required_features = .{ .@"64bit", null, null, null }, |
| 11753 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 18468 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 11754 | 18469 | .patterns = &.{ |
| 11755 | | .{ .src = .{ .to_mem, .none } }, |
| 18470 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11756 | 18471 | }, |
| 11757 | 18472 | .extra_temps = .{ |
| 11758 | 18473 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11780,10 +18495,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11780 | 18495 | } }, |
| 11781 | 18496 | }, .{ |
| 11782 | 18497 | .required_features = .{ .mmx, null, null, null }, |
| 11783 | | .src_constraints = .{ .{ .signed_int_or_full_vec = .qword }, .any }, |
| 18498 | .src_constraints = .{ .{ .signed_int_or_full_vec = .qword }, .any, .any }, |
| 11784 | 18499 | .patterns = &.{ |
| 11785 | | .{ .src = .{ .mem, .none } }, |
| 11786 | | .{ .src = .{ .to_mm, .none } }, |
| 18500 | .{ .src = .{ .mem, .none, .none } }, |
| 18501 | .{ .src = .{ .to_mm, .none, .none } }, |
| 11787 | 18502 | }, |
| 11788 | 18503 | .dst_temps = .{.{ .rc = .mmx }}, |
| 11789 | 18504 | .each = .{ .once = &.{ |
| ... | ... | @@ -11792,9 +18507,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11792 | 18507 | } }, |
| 11793 | 18508 | }, .{ |
| 11794 | 18509 | .required_features = .{ .mmx, null, null, null }, |
| 11795 | | .src_constraints = .{ .{ .unsigned_int_vec = .qword }, .any }, |
| 18510 | .src_constraints = .{ .{ .unsigned_int_vec = .qword }, .any, .any }, |
| 11796 | 18511 | .patterns = &.{ |
| 11797 | | .{ .src = .{ .to_mut_mm, .none } }, |
| 18512 | .{ .src = .{ .to_mut_mm, .none, .none } }, |
| 11798 | 18513 | }, |
| 11799 | 18514 | .extra_temps = .{ |
| 11800 | 18515 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11814,10 +18529,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11814 | 18529 | } }, |
| 11815 | 18530 | }, .{ |
| 11816 | 18531 | .required_features = .{ .avx, null, null, null }, |
| 11817 | | .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any }, |
| 18532 | .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any, .any }, |
| 11818 | 18533 | .patterns = &.{ |
| 11819 | | .{ .src = .{ .mem, .none } }, |
| 11820 | | .{ .src = .{ .to_xmm, .none } }, |
| 18534 | .{ .src = .{ .mem, .none, .none } }, |
| 18535 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11821 | 18536 | }, |
| 11822 | 18537 | .dst_temps = .{.{ .rc = .sse }}, |
| 11823 | 18538 | .each = .{ .once = &.{ |
| ... | ... | @@ -11826,9 +18541,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11826 | 18541 | } }, |
| 11827 | 18542 | }, .{ |
| 11828 | 18543 | .required_features = .{ .avx, null, null, null }, |
| 11829 | | .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any }, |
| 18544 | .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any, .any }, |
| 11830 | 18545 | .patterns = &.{ |
| 11831 | | .{ .src = .{ .to_xmm, .none } }, |
| 18546 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11832 | 18547 | }, |
| 11833 | 18548 | .extra_temps = .{ |
| 11834 | 18549 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11848,10 +18563,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11848 | 18563 | } }, |
| 11849 | 18564 | }, .{ |
| 11850 | 18565 | .required_features = .{ .sse2, null, null, null }, |
| 11851 | | .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any }, |
| 18566 | .src_constraints = .{ .{ .signed_int_or_full_vec = .xword }, .any, .any }, |
| 11852 | 18567 | .patterns = &.{ |
| 11853 | | .{ .src = .{ .mem, .none } }, |
| 11854 | | .{ .src = .{ .to_xmm, .none } }, |
| 18568 | .{ .src = .{ .mem, .none, .none } }, |
| 18569 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11855 | 18570 | }, |
| 11856 | 18571 | .dst_temps = .{.{ .rc = .sse }}, |
| 11857 | 18572 | .each = .{ .once = &.{ |
| ... | ... | @@ -11860,9 +18575,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11860 | 18575 | } }, |
| 11861 | 18576 | }, .{ |
| 11862 | 18577 | .required_features = .{ .sse2, null, null, null }, |
| 11863 | | .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any }, |
| 18578 | .src_constraints = .{ .{ .unsigned_int_vec = .xword }, .any, .any }, |
| 11864 | 18579 | .patterns = &.{ |
| 11865 | | .{ .src = .{ .to_mut_xmm, .none } }, |
| 18580 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11866 | 18581 | }, |
| 11867 | 18582 | .extra_temps = .{ |
| 11868 | 18583 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11882,9 +18597,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11882 | 18597 | } }, |
| 11883 | 18598 | }, .{ |
| 11884 | 18599 | .required_features = .{ .sse, null, null, null }, |
| 11885 | | .src_constraints = .{ .{ .vec = .xword }, .any }, |
| 18600 | .src_constraints = .{ .{ .vec = .xword }, .any, .any }, |
| 11886 | 18601 | .patterns = &.{ |
| 11887 | | .{ .src = .{ .to_mut_xmm, .none } }, |
| 18602 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11888 | 18603 | }, |
| 11889 | 18604 | .extra_temps = .{ |
| 11890 | 18605 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11904,10 +18619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11904 | 18619 | } }, |
| 11905 | 18620 | }, .{ |
| 11906 | 18621 | .required_features = .{ .avx2, null, null, null }, |
| 11907 | | .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any }, |
| 18622 | .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any, .any }, |
| 11908 | 18623 | .patterns = &.{ |
| 11909 | | .{ .src = .{ .mem, .none } }, |
| 11910 | | .{ .src = .{ .to_ymm, .none } }, |
| 18624 | .{ .src = .{ .mem, .none, .none } }, |
| 18625 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11911 | 18626 | }, |
| 11912 | 18627 | .dst_temps = .{.{ .rc = .sse }}, |
| 11913 | 18628 | .each = .{ .once = &.{ |
| ... | ... | @@ -11916,9 +18631,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11916 | 18631 | } }, |
| 11917 | 18632 | }, .{ |
| 11918 | 18633 | .required_features = .{ .avx2, null, null, null }, |
| 11919 | | .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any }, |
| 18634 | .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any, .any }, |
| 11920 | 18635 | .patterns = &.{ |
| 11921 | | .{ .src = .{ .to_ymm, .none } }, |
| 18636 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11922 | 18637 | }, |
| 11923 | 18638 | .extra_temps = .{ |
| 11924 | 18639 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11938,10 +18653,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11938 | 18653 | } }, |
| 11939 | 18654 | }, .{ |
| 11940 | 18655 | .required_features = .{ .avx, null, null, null }, |
| 11941 | | .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any }, |
| 18656 | .src_constraints = .{ .{ .signed_int_or_full_vec = .yword }, .any, .any }, |
| 11942 | 18657 | .patterns = &.{ |
| 11943 | | .{ .src = .{ .mem, .none } }, |
| 11944 | | .{ .src = .{ .to_ymm, .none } }, |
| 18658 | .{ .src = .{ .mem, .none, .none } }, |
| 18659 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11945 | 18660 | }, |
| 11946 | 18661 | .dst_temps = .{.{ .rc = .sse }}, |
| 11947 | 18662 | .each = .{ .once = &.{ |
| ... | ... | @@ -11950,9 +18665,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11950 | 18665 | } }, |
| 11951 | 18666 | }, .{ |
| 11952 | 18667 | .required_features = .{ .avx, null, null, null }, |
| 11953 | | .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any }, |
| 18668 | .src_constraints = .{ .{ .unsigned_int_vec = .yword }, .any, .any }, |
| 11954 | 18669 | .patterns = &.{ |
| 11955 | | .{ .src = .{ .to_ymm, .none } }, |
| 18670 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11956 | 18671 | }, |
| 11957 | 18672 | .extra_temps = .{ |
| 11958 | 18673 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11973,7 +18688,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11973 | 18688 | }, .{ |
| 11974 | 18689 | .required_features = .{ .@"64bit", null, null, null }, |
| 11975 | 18690 | .patterns = &.{ |
| 11976 | | .{ .src = .{ .to_mem, .none } }, |
| 18691 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11977 | 18692 | }, |
| 11978 | 18693 | .extra_temps = .{ |
| 11979 | 18694 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -11999,7 +18714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11999 | 18714 | } }, |
| 12000 | 18715 | }, .{ |
| 12001 | 18716 | .patterns = &.{ |
| 12002 | | .{ .src = .{ .to_mem, .none } }, |
| 18717 | .{ .src = .{ .to_mem, .none, .none } }, |
| 12003 | 18718 | }, |
| 12004 | 18719 | .extra_temps = .{ |
| 12005 | 18720 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12089,10 +18804,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12089 | 18804 | var res: [1]Temp = undefined; |
| 12090 | 18805 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 12091 | 18806 | .required_features = .{ .slow_incdec, null, null, null }, |
| 12092 | | .src_constraints = .{ .{ .exact_signed_int = 1 }, .any }, |
| 18807 | .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any }, |
| 12093 | 18808 | .patterns = &.{ |
| 12094 | | .{ .src = .{ .mut_mem, .none } }, |
| 12095 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18809 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 18810 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12096 | 18811 | }, |
| 12097 | 18812 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12098 | 18813 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12100,10 +18815,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12100 | 18815 | .{ ._, ._, .add, .dst0b, .si(1), ._, ._ }, |
| 12101 | 18816 | } }, |
| 12102 | 18817 | }, .{ |
| 12103 | | .src_constraints = .{ .{ .exact_signed_int = 1 }, .any }, |
| 18818 | .src_constraints = .{ .{ .exact_signed_int = 1 }, .any, .any }, |
| 12104 | 18819 | .patterns = &.{ |
| 12105 | | .{ .src = .{ .mut_mem, .none } }, |
| 12106 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18820 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 18821 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12107 | 18822 | }, |
| 12108 | 18823 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12109 | 18824 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12111,10 +18826,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12111 | 18826 | .{ ._, ._c, .in, .dst0b, ._, ._, ._ }, |
| 12112 | 18827 | } }, |
| 12113 | 18828 | }, .{ |
| 12114 | | .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .any }, |
| 18829 | .src_constraints = .{ .{ .exact_unsigned_int = 1 }, .any, .any }, |
| 12115 | 18830 | .patterns = &.{ |
| 12116 | | .{ .src = .{ .mut_mem, .none } }, |
| 12117 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18831 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 18832 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12118 | 18833 | }, |
| 12119 | 18834 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12120 | 18835 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12123,10 +18838,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12123 | 18838 | } }, |
| 12124 | 18839 | }, .{ |
| 12125 | 18840 | .required_features = .{ .lzcnt, null, null, null }, |
| 12126 | | .src_constraints = .{ .{ .unsigned_or_exact_int = .byte }, .any }, |
| 18841 | .src_constraints = .{ .{ .unsigned_or_exact_int = .byte }, .any, .any }, |
| 12127 | 18842 | .patterns = &.{ |
| 12128 | | .{ .src = .{ .mem, .none } }, |
| 12129 | | .{ .src = .{ .to_gpr, .none } }, |
| 18843 | .{ .src = .{ .mem, .none, .none } }, |
| 18844 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12130 | 18845 | }, |
| 12131 | 18846 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12132 | 18847 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12137,10 +18852,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12137 | 18852 | } }, |
| 12138 | 18853 | }, .{ |
| 12139 | 18854 | .required_features = .{ .lzcnt, null, null, null }, |
| 12140 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 18855 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 12141 | 18856 | .patterns = &.{ |
| 12142 | | .{ .src = .{ .mem, .none } }, |
| 12143 | | .{ .src = .{ .to_gpr, .none } }, |
| 18857 | .{ .src = .{ .mem, .none, .none } }, |
| 18858 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12144 | 18859 | }, |
| 12145 | 18860 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12146 | 18861 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12152,9 +18867,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12152 | 18867 | } }, |
| 12153 | 18868 | }, .{ |
| 12154 | 18869 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| 12155 | | .src_constraints = .{ .{ .exact_int = 16 }, .any }, |
| 18870 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| 12156 | 18871 | .patterns = &.{ |
| 12157 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18872 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12158 | 18873 | }, |
| 12159 | 18874 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12160 | 18875 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12163,10 +18878,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12163 | 18878 | } }, |
| 12164 | 18879 | }, .{ |
| 12165 | 18880 | .required_features = .{ .lzcnt, null, null, null }, |
| 12166 | | .src_constraints = .{ .{ .exact_int = 16 }, .any }, |
| 18881 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| 12167 | 18882 | .patterns = &.{ |
| 12168 | | .{ .src = .{ .mem, .none } }, |
| 12169 | | .{ .src = .{ .to_gpr, .none } }, |
| 18883 | .{ .src = .{ .mem, .none, .none } }, |
| 18884 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12170 | 18885 | }, |
| 12171 | 18886 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12172 | 18887 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12175,9 +18890,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12175 | 18890 | } }, |
| 12176 | 18891 | }, .{ |
| 12177 | 18892 | .required_features = .{ .lzcnt, null, null, null }, |
| 12178 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 18893 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 12179 | 18894 | .patterns = &.{ |
| 12180 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18895 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12181 | 18896 | }, |
| 12182 | 18897 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12183 | 18898 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12188,9 +18903,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12188 | 18903 | } }, |
| 12189 | 18904 | }, .{ |
| 12190 | 18905 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| 12191 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| 18906 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12192 | 18907 | .patterns = &.{ |
| 12193 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18908 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12194 | 18909 | }, |
| 12195 | 18910 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12196 | 18911 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12200,10 +18915,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12200 | 18915 | } }, |
| 12201 | 18916 | }, .{ |
| 12202 | 18917 | .required_features = .{ .lzcnt, null, null, null }, |
| 12203 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| 18918 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12204 | 18919 | .patterns = &.{ |
| 12205 | | .{ .src = .{ .mem, .none } }, |
| 12206 | | .{ .src = .{ .to_gpr, .none } }, |
| 18920 | .{ .src = .{ .mem, .none, .none } }, |
| 18921 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12207 | 18922 | }, |
| 12208 | 18923 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12209 | 18924 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12213,9 +18928,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12213 | 18928 | } }, |
| 12214 | 18929 | }, .{ |
| 12215 | 18930 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| 12216 | | .src_constraints = .{ .{ .exact_int = 32 }, .any }, |
| 18931 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| 12217 | 18932 | .patterns = &.{ |
| 12218 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18933 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12219 | 18934 | }, |
| 12220 | 18935 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12221 | 18936 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12224,10 +18939,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12224 | 18939 | } }, |
| 12225 | 18940 | }, .{ |
| 12226 | 18941 | .required_features = .{ .lzcnt, null, null, null }, |
| 12227 | | .src_constraints = .{ .{ .exact_int = 32 }, .any }, |
| 18942 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| 12228 | 18943 | .patterns = &.{ |
| 12229 | | .{ .src = .{ .mem, .none } }, |
| 12230 | | .{ .src = .{ .to_gpr, .none } }, |
| 18944 | .{ .src = .{ .mem, .none, .none } }, |
| 18945 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12231 | 18946 | }, |
| 12232 | 18947 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12233 | 18948 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12236,9 +18951,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12236 | 18951 | } }, |
| 12237 | 18952 | }, .{ |
| 12238 | 18953 | .required_features = .{ .lzcnt, null, null, null }, |
| 12239 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 18954 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 12240 | 18955 | .patterns = &.{ |
| 12241 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18956 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12242 | 18957 | }, |
| 12243 | 18958 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12244 | 18959 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12249,9 +18964,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12249 | 18964 | } }, |
| 12250 | 18965 | }, .{ |
| 12251 | 18966 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, |
| 12252 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| 18967 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12253 | 18968 | .patterns = &.{ |
| 12254 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18969 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12255 | 18970 | }, |
| 12256 | 18971 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12257 | 18972 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12261,10 +18976,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12261 | 18976 | } }, |
| 12262 | 18977 | }, .{ |
| 12263 | 18978 | .required_features = .{ .lzcnt, null, null, null }, |
| 12264 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| 18979 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12265 | 18980 | .patterns = &.{ |
| 12266 | | .{ .src = .{ .mem, .none } }, |
| 12267 | | .{ .src = .{ .to_gpr, .none } }, |
| 18981 | .{ .src = .{ .mem, .none, .none } }, |
| 18982 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12268 | 18983 | }, |
| 12269 | 18984 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12270 | 18985 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12274,9 +18989,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12274 | 18989 | } }, |
| 12275 | 18990 | }, .{ |
| 12276 | 18991 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 12277 | | .src_constraints = .{ .{ .exact_int = 64 }, .any }, |
| 18992 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| 12278 | 18993 | .patterns = &.{ |
| 12279 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 18994 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12280 | 18995 | }, |
| 12281 | 18996 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12282 | 18997 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12285,10 +19000,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12285 | 19000 | } }, |
| 12286 | 19001 | }, .{ |
| 12287 | 19002 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 12288 | | .src_constraints = .{ .{ .exact_int = 64 }, .any }, |
| 19003 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| 12289 | 19004 | .patterns = &.{ |
| 12290 | | .{ .src = .{ .mem, .none } }, |
| 12291 | | .{ .src = .{ .to_gpr, .none } }, |
| 19005 | .{ .src = .{ .mem, .none, .none } }, |
| 19006 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12292 | 19007 | }, |
| 12293 | 19008 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12294 | 19009 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12297,10 +19012,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12297 | 19012 | } }, |
| 12298 | 19013 | }, .{ |
| 12299 | 19014 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 12300 | | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| 19015 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 12301 | 19016 | .patterns = &.{ |
| 12302 | | .{ .src = .{ .mem, .none } }, |
| 12303 | | .{ .src = .{ .to_gpr, .none } }, |
| 19017 | .{ .src = .{ .mem, .none, .none } }, |
| 19018 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12304 | 19019 | }, |
| 12305 | 19020 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12306 | 19021 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12312,9 +19027,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12312 | 19027 | } }, |
| 12313 | 19028 | }, .{ |
| 12314 | 19029 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 12315 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 19030 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 12316 | 19031 | .patterns = &.{ |
| 12317 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19032 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12318 | 19033 | }, |
| 12319 | 19034 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12320 | 19035 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12324,10 +19039,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12324 | 19039 | } }, |
| 12325 | 19040 | }, .{ |
| 12326 | 19041 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 12327 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 19042 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 12328 | 19043 | .patterns = &.{ |
| 12329 | | .{ .src = .{ .mem, .none } }, |
| 12330 | | .{ .src = .{ .to_gpr, .none } }, |
| 19044 | .{ .src = .{ .mem, .none, .none } }, |
| 19045 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12331 | 19046 | }, |
| 12332 | 19047 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12333 | 19048 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12337,10 +19052,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12337 | 19052 | } }, |
| 12338 | 19053 | }, .{ |
| 12339 | 19054 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12340 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any }, |
| 19055 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any, .any }, |
| 12341 | 19056 | .patterns = &.{ |
| 12342 | | .{ .src = .{ .mem, .none } }, |
| 12343 | | .{ .src = .{ .to_gpr, .none } }, |
| 19057 | .{ .src = .{ .mem, .none, .none } }, |
| 19058 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12344 | 19059 | }, |
| 12345 | 19060 | .extra_temps = .{ |
| 12346 | 19061 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12364,10 +19079,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12364 | 19079 | } }, |
| 12365 | 19080 | }, .{ |
| 12366 | 19081 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12367 | | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any }, |
| 19082 | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any, .any }, |
| 12368 | 19083 | .patterns = &.{ |
| 12369 | | .{ .src = .{ .mem, .none } }, |
| 12370 | | .{ .src = .{ .to_gpr, .none } }, |
| 19084 | .{ .src = .{ .mem, .none, .none } }, |
| 19085 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12371 | 19086 | }, |
| 12372 | 19087 | .extra_temps = .{ |
| 12373 | 19088 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12392,10 +19107,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12392 | 19107 | } }, |
| 12393 | 19108 | }, .{ |
| 12394 | 19109 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12395 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 19110 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 12396 | 19111 | .patterns = &.{ |
| 12397 | | .{ .src = .{ .mem, .none } }, |
| 12398 | | .{ .src = .{ .to_gpr, .none } }, |
| 19112 | .{ .src = .{ .mem, .none, .none } }, |
| 19113 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12399 | 19114 | }, |
| 12400 | 19115 | .extra_temps = .{ |
| 12401 | 19116 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12421,10 +19136,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12421 | 19136 | } }, |
| 12422 | 19137 | }, .{ |
| 12423 | 19138 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12424 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| 19139 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 12425 | 19140 | .patterns = &.{ |
| 12426 | | .{ .src = .{ .mem, .none } }, |
| 12427 | | .{ .src = .{ .to_gpr, .none } }, |
| 19141 | .{ .src = .{ .mem, .none, .none } }, |
| 19142 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12428 | 19143 | }, |
| 12429 | 19144 | .extra_temps = .{ |
| 12430 | 19145 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12449,10 +19164,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12449 | 19164 | } }, |
| 12450 | 19165 | }, .{ |
| 12451 | 19166 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12452 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any }, |
| 19167 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any, .any }, |
| 12453 | 19168 | .patterns = &.{ |
| 12454 | | .{ .src = .{ .mem, .none } }, |
| 12455 | | .{ .src = .{ .to_gpr, .none } }, |
| 19169 | .{ .src = .{ .mem, .none, .none } }, |
| 19170 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12456 | 19171 | }, |
| 12457 | 19172 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12458 | 19173 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12465,10 +19180,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12465 | 19180 | } }, |
| 12466 | 19181 | }, .{ |
| 12467 | 19182 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12468 | | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any }, |
| 19183 | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any, .any }, |
| 12469 | 19184 | .patterns = &.{ |
| 12470 | | .{ .src = .{ .mem, .none } }, |
| 12471 | | .{ .src = .{ .to_gpr, .none } }, |
| 19185 | .{ .src = .{ .mem, .none, .none } }, |
| 19186 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12472 | 19187 | }, |
| 12473 | 19188 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12474 | 19189 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12482,10 +19197,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12482 | 19197 | } }, |
| 12483 | 19198 | }, .{ |
| 12484 | 19199 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12485 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 19200 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 12486 | 19201 | .patterns = &.{ |
| 12487 | | .{ .src = .{ .mem, .none } }, |
| 12488 | | .{ .src = .{ .to_gpr, .none } }, |
| 19202 | .{ .src = .{ .mem, .none, .none } }, |
| 19203 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12489 | 19204 | }, |
| 12490 | 19205 | .extra_temps = .{ |
| 12491 | 19206 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12511,10 +19226,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12511 | 19226 | } }, |
| 12512 | 19227 | }, .{ |
| 12513 | 19228 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12514 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| 19229 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 12515 | 19230 | .patterns = &.{ |
| 12516 | | .{ .src = .{ .mem, .none } }, |
| 12517 | | .{ .src = .{ .to_gpr, .none } }, |
| 19231 | .{ .src = .{ .mem, .none, .none } }, |
| 19232 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12518 | 19233 | }, |
| 12519 | 19234 | .extra_temps = .{ |
| 12520 | 19235 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12538,10 +19253,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12538 | 19253 | .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ }, |
| 12539 | 19254 | } }, |
| 12540 | 19255 | }, .{ |
| 12541 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any }, |
| 19256 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .byte }, .any, .any }, |
| 12542 | 19257 | .patterns = &.{ |
| 12543 | | .{ .src = .{ .mem, .none } }, |
| 12544 | | .{ .src = .{ .to_gpr, .none } }, |
| 19258 | .{ .src = .{ .mem, .none, .none } }, |
| 19259 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12545 | 19260 | }, |
| 12546 | 19261 | .extra_temps = .{ |
| 12547 | 19262 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12563,10 +19278,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12563 | 19278 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| 12564 | 19279 | } }, |
| 12565 | 19280 | }, .{ |
| 12566 | | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any }, |
| 19281 | .src_constraints = .{ .{ .signed_po2_int = .byte }, .any, .any }, |
| 12567 | 19282 | .patterns = &.{ |
| 12568 | | .{ .src = .{ .mem, .none } }, |
| 12569 | | .{ .src = .{ .to_gpr, .none } }, |
| 19283 | .{ .src = .{ .mem, .none, .none } }, |
| 19284 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12570 | 19285 | }, |
| 12571 | 19286 | .extra_temps = .{ |
| 12572 | 19287 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12589,10 +19304,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12589 | 19304 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| 12590 | 19305 | } }, |
| 12591 | 19306 | }, .{ |
| 12592 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 19307 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 12593 | 19308 | .patterns = &.{ |
| 12594 | | .{ .src = .{ .mem, .none } }, |
| 12595 | | .{ .src = .{ .to_gpr, .none } }, |
| 19309 | .{ .src = .{ .mem, .none, .none } }, |
| 19310 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12596 | 19311 | }, |
| 12597 | 19312 | .extra_temps = .{ |
| 12598 | 19313 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12616,10 +19331,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12616 | 19331 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| 12617 | 19332 | } }, |
| 12618 | 19333 | }, .{ |
| 12619 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, |
| 19334 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 12620 | 19335 | .patterns = &.{ |
| 12621 | | .{ .src = .{ .mem, .none } }, |
| 12622 | | .{ .src = .{ .to_gpr, .none } }, |
| 19336 | .{ .src = .{ .mem, .none, .none } }, |
| 19337 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12623 | 19338 | }, |
| 12624 | 19339 | .extra_temps = .{ |
| 12625 | 19340 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12643,9 +19358,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12643 | 19358 | } }, |
| 12644 | 19359 | }, .{ |
| 12645 | 19360 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12646 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any }, |
| 19361 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any, .any }, |
| 12647 | 19362 | .patterns = &.{ |
| 12648 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19363 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12649 | 19364 | }, |
| 12650 | 19365 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12651 | 19366 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12657,9 +19372,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12657 | 19372 | } }, |
| 12658 | 19373 | }, .{ |
| 12659 | 19374 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12660 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 19375 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 12661 | 19376 | .patterns = &.{ |
| 12662 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19377 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12663 | 19378 | }, |
| 12664 | 19379 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12665 | 19380 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12673,9 +19388,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12673 | 19388 | } }, |
| 12674 | 19389 | }, .{ |
| 12675 | 19390 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12676 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| 19391 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12677 | 19392 | .patterns = &.{ |
| 12678 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19393 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12679 | 19394 | }, |
| 12680 | 19395 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12681 | 19396 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12688,9 +19403,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12688 | 19403 | } }, |
| 12689 | 19404 | }, .{ |
| 12690 | 19405 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12691 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any }, |
| 19406 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any, .any }, |
| 12692 | 19407 | .patterns = &.{ |
| 12693 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19408 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12694 | 19409 | }, |
| 12695 | 19410 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12696 | 19411 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12702,9 +19417,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12702 | 19417 | } }, |
| 12703 | 19418 | }, .{ |
| 12704 | 19419 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12705 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 19420 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 12706 | 19421 | .patterns = &.{ |
| 12707 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19422 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12708 | 19423 | }, |
| 12709 | 19424 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12710 | 19425 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12718,9 +19433,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12718 | 19433 | } }, |
| 12719 | 19434 | }, .{ |
| 12720 | 19435 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12721 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| 19436 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12722 | 19437 | .patterns = &.{ |
| 12723 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19438 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12724 | 19439 | }, |
| 12725 | 19440 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12726 | 19441 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12732,10 +19447,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12732 | 19447 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| 12733 | 19448 | } }, |
| 12734 | 19449 | }, .{ |
| 12735 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any }, |
| 19450 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .word }, .any, .any }, |
| 12736 | 19451 | .patterns = &.{ |
| 12737 | | .{ .src = .{ .mem, .none } }, |
| 12738 | | .{ .src = .{ .to_gpr, .none } }, |
| 19452 | .{ .src = .{ .mem, .none, .none } }, |
| 19453 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12739 | 19454 | }, |
| 12740 | 19455 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12741 | 19456 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12745,9 +19460,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12745 | 19460 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| 12746 | 19461 | } }, |
| 12747 | 19462 | }, .{ |
| 12748 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 19463 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 12749 | 19464 | .patterns = &.{ |
| 12750 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19465 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12751 | 19466 | }, |
| 12752 | 19467 | .extra_temps = .{ |
| 12753 | 19468 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12770,10 +19485,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12770 | 19485 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| 12771 | 19486 | } }, |
| 12772 | 19487 | }, .{ |
| 12773 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, |
| 19488 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12774 | 19489 | .patterns = &.{ |
| 12775 | | .{ .src = .{ .mem, .none } }, |
| 12776 | | .{ .src = .{ .to_gpr, .none } }, |
| 19490 | .{ .src = .{ .mem, .none, .none } }, |
| 19491 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12777 | 19492 | }, |
| 12778 | 19493 | .extra_temps = .{ |
| 12779 | 19494 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12796,9 +19511,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12796 | 19511 | } }, |
| 12797 | 19512 | }, .{ |
| 12798 | 19513 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12799 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any }, |
| 19514 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any, .any }, |
| 12800 | 19515 | .patterns = &.{ |
| 12801 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19516 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12802 | 19517 | }, |
| 12803 | 19518 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12804 | 19519 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12810,9 +19525,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12810 | 19525 | } }, |
| 12811 | 19526 | }, .{ |
| 12812 | 19527 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12813 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 19528 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 12814 | 19529 | .patterns = &.{ |
| 12815 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19530 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12816 | 19531 | }, |
| 12817 | 19532 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12818 | 19533 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12826,9 +19541,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12826 | 19541 | } }, |
| 12827 | 19542 | }, .{ |
| 12828 | 19543 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 12829 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| 19544 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12830 | 19545 | .patterns = &.{ |
| 12831 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19546 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12832 | 19547 | }, |
| 12833 | 19548 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12834 | 19549 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12841,9 +19556,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12841 | 19556 | } }, |
| 12842 | 19557 | }, .{ |
| 12843 | 19558 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12844 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any }, |
| 19559 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any, .any }, |
| 12845 | 19560 | .patterns = &.{ |
| 12846 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19561 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12847 | 19562 | }, |
| 12848 | 19563 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12849 | 19564 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12855,9 +19570,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12855 | 19570 | } }, |
| 12856 | 19571 | }, .{ |
| 12857 | 19572 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12858 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 19573 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 12859 | 19574 | .patterns = &.{ |
| 12860 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19575 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12861 | 19576 | }, |
| 12862 | 19577 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12863 | 19578 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12871,9 +19586,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12871 | 19586 | } }, |
| 12872 | 19587 | }, .{ |
| 12873 | 19588 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 12874 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| 19589 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12875 | 19590 | .patterns = &.{ |
| 12876 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19591 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12877 | 19592 | }, |
| 12878 | 19593 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12879 | 19594 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12885,10 +19600,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12885 | 19600 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, |
| 12886 | 19601 | } }, |
| 12887 | 19602 | }, .{ |
| 12888 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any }, |
| 19603 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .dword }, .any, .any }, |
| 12889 | 19604 | .patterns = &.{ |
| 12890 | | .{ .src = .{ .mem, .none } }, |
| 12891 | | .{ .src = .{ .to_gpr, .none } }, |
| 19605 | .{ .src = .{ .mem, .none, .none } }, |
| 19606 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12892 | 19607 | }, |
| 12893 | 19608 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12894 | 19609 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12898,9 +19613,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12898 | 19613 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, |
| 12899 | 19614 | } }, |
| 12900 | 19615 | }, .{ |
| 12901 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 19616 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 12902 | 19617 | .patterns = &.{ |
| 12903 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19618 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12904 | 19619 | }, |
| 12905 | 19620 | .extra_temps = .{ |
| 12906 | 19621 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12923,10 +19638,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12923 | 19638 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| 12924 | 19639 | } }, |
| 12925 | 19640 | }, .{ |
| 12926 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, |
| 19641 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12927 | 19642 | .patterns = &.{ |
| 12928 | | .{ .src = .{ .mem, .none } }, |
| 12929 | | .{ .src = .{ .to_gpr, .none } }, |
| 19643 | .{ .src = .{ .mem, .none, .none } }, |
| 19644 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12930 | 19645 | }, |
| 12931 | 19646 | .extra_temps = .{ |
| 12932 | 19647 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12949,9 +19664,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12949 | 19664 | } }, |
| 12950 | 19665 | }, .{ |
| 12951 | 19666 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| 12952 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any }, |
| 19667 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any, .any }, |
| 12953 | 19668 | .patterns = &.{ |
| 12954 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19669 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12955 | 19670 | }, |
| 12956 | 19671 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12957 | 19672 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -12963,10 +19678,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12963 | 19678 | } }, |
| 12964 | 19679 | }, .{ |
| 12965 | 19680 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| 12966 | | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| 19681 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 12967 | 19682 | .patterns = &.{ |
| 12968 | | .{ .src = .{ .mem, .none } }, |
| 12969 | | .{ .src = .{ .to_gpr, .none } }, |
| 19683 | .{ .src = .{ .mem, .none, .none } }, |
| 19684 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12970 | 19685 | }, |
| 12971 | 19686 | .extra_temps = .{ |
| 12972 | 19687 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -12992,9 +19707,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12992 | 19707 | } }, |
| 12993 | 19708 | }, .{ |
| 12994 | 19709 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| 12995 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 19710 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 12996 | 19711 | .patterns = &.{ |
| 12997 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19712 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12998 | 19713 | }, |
| 12999 | 19714 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 13000 | 19715 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -13007,9 +19722,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13007 | 19722 | } }, |
| 13008 | 19723 | }, .{ |
| 13009 | 19724 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| 13010 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any }, |
| 19725 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any, .any }, |
| 13011 | 19726 | .patterns = &.{ |
| 13012 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19727 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 13013 | 19728 | }, |
| 13014 | 19729 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13015 | 19730 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -13021,10 +19736,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13021 | 19736 | } }, |
| 13022 | 19737 | }, .{ |
| 13023 | 19738 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| 13024 | | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| 19739 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 13025 | 19740 | .patterns = &.{ |
| 13026 | | .{ .src = .{ .mem, .none } }, |
| 13027 | | .{ .src = .{ .to_gpr, .none } }, |
| 19741 | .{ .src = .{ .mem, .none, .none } }, |
| 19742 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13028 | 19743 | }, |
| 13029 | 19744 | .extra_temps = .{ |
| 13030 | 19745 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13050,9 +19765,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13050 | 19765 | } }, |
| 13051 | 19766 | }, .{ |
| 13052 | 19767 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| 13053 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 19768 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 13054 | 19769 | .patterns = &.{ |
| 13055 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 19770 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 13056 | 19771 | }, |
| 13057 | 19772 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 13058 | 19773 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -13065,10 +19780,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13065 | 19780 | } }, |
| 13066 | 19781 | }, .{ |
| 13067 | 19782 | .required_features = .{ .@"64bit", null, null, null }, |
| 13068 | | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any }, |
| 19783 | .src_constraints = .{ .{ .unsigned_po2_or_exact_int = .qword }, .any, .any }, |
| 13069 | 19784 | .patterns = &.{ |
| 13070 | | .{ .src = .{ .mem, .none } }, |
| 13071 | | .{ .src = .{ .to_gpr, .none } }, |
| 19785 | .{ .src = .{ .mem, .none, .none } }, |
| 19786 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13072 | 19787 | }, |
| 13073 | 19788 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 13074 | 19789 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -13079,10 +19794,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13079 | 19794 | } }, |
| 13080 | 19795 | }, .{ |
| 13081 | 19796 | .required_features = .{ .@"64bit", null, null, null }, |
| 13082 | | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| 19797 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 13083 | 19798 | .patterns = &.{ |
| 13084 | | .{ .src = .{ .mem, .none } }, |
| 13085 | | .{ .src = .{ .to_gpr, .none } }, |
| 19799 | .{ .src = .{ .mem, .none, .none } }, |
| 19800 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13086 | 19801 | }, |
| 13087 | 19802 | .extra_temps = .{ |
| 13088 | 19803 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13107,10 +19822,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13107 | 19822 | } }, |
| 13108 | 19823 | }, .{ |
| 13109 | 19824 | .required_features = .{ .@"64bit", null, null, null }, |
| 13110 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, |
| 19825 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 13111 | 19826 | .patterns = &.{ |
| 13112 | | .{ .src = .{ .mem, .none } }, |
| 13113 | | .{ .src = .{ .to_gpr, .none } }, |
| 19827 | .{ .src = .{ .mem, .none, .none } }, |
| 19828 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13114 | 19829 | }, |
| 13115 | 19830 | .extra_temps = .{ |
| 13116 | 19831 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13133,9 +19848,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13133 | 19848 | } }, |
| 13134 | 19849 | }, .{ |
| 13135 | 19850 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 13136 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 19851 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13137 | 19852 | .patterns = &.{ |
| 13138 | | .{ .src = .{ .to_mem, .none } }, |
| 19853 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13139 | 19854 | }, |
| 13140 | 19855 | .extra_temps = .{ |
| 13141 | 19856 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13163,9 +19878,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13163 | 19878 | } }, |
| 13164 | 19879 | }, .{ |
| 13165 | 19880 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 13166 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 19881 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13167 | 19882 | .patterns = &.{ |
| 13168 | | .{ .src = .{ .to_mem, .none } }, |
| 19883 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13169 | 19884 | }, |
| 13170 | 19885 | .extra_temps = .{ |
| 13171 | 19886 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13192,9 +19907,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13192 | 19907 | } }, |
| 13193 | 19908 | }, .{ |
| 13194 | 19909 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| 13195 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 19910 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13196 | 19911 | .patterns = &.{ |
| 13197 | | .{ .src = .{ .to_mem, .none } }, |
| 19912 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13198 | 19913 | }, |
| 13199 | 19914 | .extra_temps = .{ |
| 13200 | 19915 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13223,9 +19938,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13223 | 19938 | } }, |
| 13224 | 19939 | }, .{ |
| 13225 | 19940 | .required_features = .{ .@"64bit", null, null, null }, |
| 13226 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 19941 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13227 | 19942 | .patterns = &.{ |
| 13228 | | .{ .src = .{ .to_mem, .none } }, |
| 19943 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13229 | 19944 | }, |
| 13230 | 19945 | .extra_temps = .{ |
| 13231 | 19946 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13253,9 +19968,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13253 | 19968 | } }, |
| 13254 | 19969 | }, .{ |
| 13255 | 19970 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 13256 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 19971 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13257 | 19972 | .patterns = &.{ |
| 13258 | | .{ .src = .{ .to_mem, .none } }, |
| 19973 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13259 | 19974 | }, |
| 13260 | 19975 | .extra_temps = .{ |
| 13261 | 19976 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13283,9 +19998,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13283 | 19998 | } }, |
| 13284 | 19999 | }, .{ |
| 13285 | 20000 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 13286 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 20001 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13287 | 20002 | .patterns = &.{ |
| 13288 | | .{ .src = .{ .to_mem, .none } }, |
| 20003 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13289 | 20004 | }, |
| 13290 | 20005 | .extra_temps = .{ |
| 13291 | 20006 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13312,9 +20027,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13312 | 20027 | } }, |
| 13313 | 20028 | }, .{ |
| 13314 | 20029 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| 13315 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 20030 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13316 | 20031 | .patterns = &.{ |
| 13317 | | .{ .src = .{ .to_mem, .none } }, |
| 20032 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13318 | 20033 | }, |
| 13319 | 20034 | .extra_temps = .{ |
| 13320 | 20035 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13343,9 +20058,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13343 | 20058 | } }, |
| 13344 | 20059 | }, .{ |
| 13345 | 20060 | .required_features = .{ .@"64bit", null, null, null }, |
| 13346 | | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 20061 | .src_constraints = .{ .{ .unsigned_or_exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13347 | 20062 | .patterns = &.{ |
| 13348 | | .{ .src = .{ .to_mem, .none } }, |
| 20063 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13349 | 20064 | }, |
| 13350 | 20065 | .extra_temps = .{ |
| 13351 | 20066 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13373,9 +20088,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13373 | 20088 | } }, |
| 13374 | 20089 | }, .{ |
| 13375 | 20090 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 13376 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 20091 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13377 | 20092 | .patterns = &.{ |
| 13378 | | .{ .src = .{ .to_mem, .none } }, |
| 20093 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13379 | 20094 | }, |
| 13380 | 20095 | .extra_temps = .{ |
| 13381 | 20096 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13406,9 +20121,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13406 | 20121 | } }, |
| 13407 | 20122 | }, .{ |
| 13408 | 20123 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 13409 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 20124 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13410 | 20125 | .patterns = &.{ |
| 13411 | | .{ .src = .{ .to_mem, .none } }, |
| 20126 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13412 | 20127 | }, |
| 13413 | 20128 | .extra_temps = .{ |
| 13414 | 20129 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13438,9 +20153,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13438 | 20153 | } }, |
| 13439 | 20154 | }, .{ |
| 13440 | 20155 | .required_features = .{ .@"64bit", null, null, null }, |
| 13441 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 20156 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 13442 | 20157 | .patterns = &.{ |
| 13443 | | .{ .src = .{ .to_mem, .none } }, |
| 20158 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13444 | 20159 | }, |
| 13445 | 20160 | .extra_temps = .{ |
| 13446 | 20161 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13470,9 +20185,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13470 | 20185 | } }, |
| 13471 | 20186 | }, .{ |
| 13472 | 20187 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 13473 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 20188 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13474 | 20189 | .patterns = &.{ |
| 13475 | | .{ .src = .{ .to_mem, .none } }, |
| 20190 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13476 | 20191 | }, |
| 13477 | 20192 | .extra_temps = .{ |
| 13478 | 20193 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13503,9 +20218,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13503 | 20218 | } }, |
| 13504 | 20219 | }, .{ |
| 13505 | 20220 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 13506 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 20221 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13507 | 20222 | .patterns = &.{ |
| 13508 | | .{ .src = .{ .to_mem, .none } }, |
| 20223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13509 | 20224 | }, |
| 13510 | 20225 | .extra_temps = .{ |
| 13511 | 20226 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13535,9 +20250,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13535 | 20250 | } }, |
| 13536 | 20251 | }, .{ |
| 13537 | 20252 | .required_features = .{ .@"64bit", null, null, null }, |
| 13538 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 20253 | .src_constraints = .{ .{ .remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 13539 | 20254 | .patterns = &.{ |
| 13540 | | .{ .src = .{ .to_mem, .none } }, |
| 20255 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13541 | 20256 | }, |
| 13542 | 20257 | .extra_temps = .{ |
| 13543 | 20258 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13567,9 +20282,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13567 | 20282 | } }, |
| 13568 | 20283 | }, .{ |
| 13569 | 20284 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, |
| 13570 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20285 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13571 | 20286 | .patterns = &.{ |
| 13572 | | .{ .src = .{ .to_mem, .none } }, |
| 20287 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13573 | 20288 | }, |
| 13574 | 20289 | .extra_temps = .{ |
| 13575 | 20290 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13596,9 +20311,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13596 | 20311 | } }, |
| 13597 | 20312 | }, .{ |
| 13598 | 20313 | .required_features = .{ .lzcnt, null, null, null }, |
| 13599 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20314 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13600 | 20315 | .patterns = &.{ |
| 13601 | | .{ .src = .{ .to_mem, .none } }, |
| 20316 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13602 | 20317 | }, |
| 13603 | 20318 | .extra_temps = .{ |
| 13604 | 20319 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13625,9 +20340,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13625 | 20340 | } }, |
| 13626 | 20341 | }, .{ |
| 13627 | 20342 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, |
| 13628 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20343 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 13629 | 20344 | .patterns = &.{ |
| 13630 | | .{ .src = .{ .to_mem, .none } }, |
| 20345 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13631 | 20346 | }, |
| 13632 | 20347 | .extra_temps = .{ |
| 13633 | 20348 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13654,9 +20369,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13654 | 20369 | } }, |
| 13655 | 20370 | }, .{ |
| 13656 | 20371 | .required_features = .{ .lzcnt, null, null, null }, |
| 13657 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20372 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 13658 | 20373 | .patterns = &.{ |
| 13659 | | .{ .src = .{ .to_mem, .none } }, |
| 20374 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13660 | 20375 | }, |
| 13661 | 20376 | .extra_temps = .{ |
| 13662 | 20377 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13683,9 +20398,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13683 | 20398 | } }, |
| 13684 | 20399 | }, .{ |
| 13685 | 20400 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, |
| 13686 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 20401 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 13687 | 20402 | .patterns = &.{ |
| 13688 | | .{ .src = .{ .to_mem, .none } }, |
| 20403 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13689 | 20404 | }, |
| 13690 | 20405 | .extra_temps = .{ |
| 13691 | 20406 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13712,9 +20427,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13712 | 20427 | } }, |
| 13713 | 20428 | }, .{ |
| 13714 | 20429 | .required_features = .{ .lzcnt, null, null, null }, |
| 13715 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 20430 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 13716 | 20431 | .patterns = &.{ |
| 13717 | | .{ .src = .{ .to_mem, .none } }, |
| 20432 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13718 | 20433 | }, |
| 13719 | 20434 | .extra_temps = .{ |
| 13720 | 20435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13741,9 +20456,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13741 | 20456 | } }, |
| 13742 | 20457 | }, .{ |
| 13743 | 20458 | .required_features = .{ .@"64bit", .lzcnt, .slow_incdec, null }, |
| 13744 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 20459 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 13745 | 20460 | .patterns = &.{ |
| 13746 | | .{ .src = .{ .to_mem, .none } }, |
| 20461 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13747 | 20462 | }, |
| 13748 | 20463 | .extra_temps = .{ |
| 13749 | 20464 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13770,9 +20485,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13770 | 20485 | } }, |
| 13771 | 20486 | }, .{ |
| 13772 | 20487 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 13773 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 20488 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 13774 | 20489 | .patterns = &.{ |
| 13775 | | .{ .src = .{ .to_mem, .none } }, |
| 20490 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13776 | 20491 | }, |
| 13777 | 20492 | .extra_temps = .{ |
| 13778 | 20493 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13799,9 +20514,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13799 | 20514 | } }, |
| 13800 | 20515 | }, .{ |
| 13801 | 20516 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| 13802 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20517 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13803 | 20518 | .patterns = &.{ |
| 13804 | | .{ .src = .{ .to_mem, .none } }, |
| 20519 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13805 | 20520 | }, |
| 13806 | 20521 | .extra_temps = .{ |
| 13807 | 20522 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13831,9 +20546,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13831 | 20546 | } }, |
| 13832 | 20547 | }, .{ |
| 13833 | 20548 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 13834 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20549 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13835 | 20550 | .patterns = &.{ |
| 13836 | | .{ .src = .{ .to_mem, .none } }, |
| 20551 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13837 | 20552 | }, |
| 13838 | 20553 | .extra_temps = .{ |
| 13839 | 20554 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13863,9 +20578,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13863 | 20578 | } }, |
| 13864 | 20579 | }, .{ |
| 13865 | 20580 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, |
| 13866 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20581 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13867 | 20582 | .patterns = &.{ |
| 13868 | | .{ .src = .{ .to_mem, .none } }, |
| 20583 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13869 | 20584 | }, |
| 13870 | 20585 | .extra_temps = .{ |
| 13871 | 20586 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13895,9 +20610,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13895 | 20610 | } }, |
| 13896 | 20611 | }, .{ |
| 13897 | 20612 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 13898 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20613 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13899 | 20614 | .patterns = &.{ |
| 13900 | | .{ .src = .{ .to_mem, .none } }, |
| 20615 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13901 | 20616 | }, |
| 13902 | 20617 | .extra_temps = .{ |
| 13903 | 20618 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13927,9 +20642,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13927 | 20642 | } }, |
| 13928 | 20643 | }, .{ |
| 13929 | 20644 | .required_features = .{ .slow_incdec, null, null, null }, |
| 13930 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20645 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13931 | 20646 | .patterns = &.{ |
| 13932 | | .{ .src = .{ .to_mem, .none } }, |
| 20647 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13933 | 20648 | }, |
| 13934 | 20649 | .extra_temps = .{ |
| 13935 | 20650 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13957,9 +20672,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13957 | 20672 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 13958 | 20673 | } }, |
| 13959 | 20674 | }, .{ |
| 13960 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any }, |
| 20675 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .any, .any }, |
| 13961 | 20676 | .patterns = &.{ |
| 13962 | | .{ .src = .{ .to_mem, .none } }, |
| 20677 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13963 | 20678 | }, |
| 13964 | 20679 | .extra_temps = .{ |
| 13965 | 20680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -13988,9 +20703,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13988 | 20703 | } }, |
| 13989 | 20704 | }, .{ |
| 13990 | 20705 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| 13991 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20706 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 13992 | 20707 | .patterns = &.{ |
| 13993 | | .{ .src = .{ .to_mem, .none } }, |
| 20708 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13994 | 20709 | }, |
| 13995 | 20710 | .extra_temps = .{ |
| 13996 | 20711 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14020,9 +20735,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14020 | 20735 | } }, |
| 14021 | 20736 | }, .{ |
| 14022 | 20737 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 14023 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20738 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 14024 | 20739 | .patterns = &.{ |
| 14025 | | .{ .src = .{ .to_mem, .none } }, |
| 20740 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14026 | 20741 | }, |
| 14027 | 20742 | .extra_temps = .{ |
| 14028 | 20743 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14052,9 +20767,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14052 | 20767 | } }, |
| 14053 | 20768 | }, .{ |
| 14054 | 20769 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, |
| 14055 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20770 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 14056 | 20771 | .patterns = &.{ |
| 14057 | | .{ .src = .{ .to_mem, .none } }, |
| 20772 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14058 | 20773 | }, |
| 14059 | 20774 | .extra_temps = .{ |
| 14060 | 20775 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14084,9 +20799,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14084 | 20799 | } }, |
| 14085 | 20800 | }, .{ |
| 14086 | 20801 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 14087 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20802 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 14088 | 20803 | .patterns = &.{ |
| 14089 | | .{ .src = .{ .to_mem, .none } }, |
| 20804 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14090 | 20805 | }, |
| 14091 | 20806 | .extra_temps = .{ |
| 14092 | 20807 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14116,9 +20831,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14116 | 20831 | } }, |
| 14117 | 20832 | }, .{ |
| 14118 | 20833 | .required_features = .{ .slow_incdec, null, null, null }, |
| 14119 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20834 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 14120 | 20835 | .patterns = &.{ |
| 14121 | | .{ .src = .{ .to_mem, .none } }, |
| 20836 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14122 | 20837 | }, |
| 14123 | 20838 | .extra_temps = .{ |
| 14124 | 20839 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14146,9 +20861,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14146 | 20861 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 14147 | 20862 | } }, |
| 14148 | 20863 | }, .{ |
| 14149 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .any }, |
| 20864 | .src_constraints = .{ .{ .scalar_int_is = .word }, .any, .any }, |
| 14150 | 20865 | .patterns = &.{ |
| 14151 | | .{ .src = .{ .to_mem, .none } }, |
| 20866 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14152 | 20867 | }, |
| 14153 | 20868 | .extra_temps = .{ |
| 14154 | 20869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14177,9 +20892,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14177 | 20892 | } }, |
| 14178 | 20893 | }, .{ |
| 14179 | 20894 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| 14180 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 20895 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 14181 | 20896 | .patterns = &.{ |
| 14182 | | .{ .src = .{ .to_mem, .none } }, |
| 20897 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14183 | 20898 | }, |
| 14184 | 20899 | .extra_temps = .{ |
| 14185 | 20900 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14209,9 +20924,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14209 | 20924 | } }, |
| 14210 | 20925 | }, .{ |
| 14211 | 20926 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, |
| 14212 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 20927 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 14213 | 20928 | .patterns = &.{ |
| 14214 | | .{ .src = .{ .to_mem, .none } }, |
| 20929 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14215 | 20930 | }, |
| 14216 | 20931 | .extra_temps = .{ |
| 14217 | 20932 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14241,9 +20956,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14241 | 20956 | } }, |
| 14242 | 20957 | }, .{ |
| 14243 | 20958 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, |
| 14244 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 20959 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 14245 | 20960 | .patterns = &.{ |
| 14246 | | .{ .src = .{ .to_mem, .none } }, |
| 20961 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14247 | 20962 | }, |
| 14248 | 20963 | .extra_temps = .{ |
| 14249 | 20964 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14273,9 +20988,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14273 | 20988 | } }, |
| 14274 | 20989 | }, .{ |
| 14275 | 20990 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, |
| 14276 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 20991 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 14277 | 20992 | .patterns = &.{ |
| 14278 | | .{ .src = .{ .to_mem, .none } }, |
| 20993 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14279 | 20994 | }, |
| 14280 | 20995 | .extra_temps = .{ |
| 14281 | 20996 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14305,9 +21020,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14305 | 21020 | } }, |
| 14306 | 21021 | }, .{ |
| 14307 | 21022 | .required_features = .{ .slow_incdec, null, null, null }, |
| 14308 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 21023 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 14309 | 21024 | .patterns = &.{ |
| 14310 | | .{ .src = .{ .to_mem, .none } }, |
| 21025 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14311 | 21026 | }, |
| 14312 | 21027 | .extra_temps = .{ |
| 14313 | 21028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14335,9 +21050,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14335 | 21050 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 14336 | 21051 | } }, |
| 14337 | 21052 | }, .{ |
| 14338 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any }, |
| 21053 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .any, .any }, |
| 14339 | 21054 | .patterns = &.{ |
| 14340 | | .{ .src = .{ .to_mem, .none } }, |
| 21055 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14341 | 21056 | }, |
| 14342 | 21057 | .extra_temps = .{ |
| 14343 | 21058 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14366,9 +21081,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14366 | 21081 | } }, |
| 14367 | 21082 | }, .{ |
| 14368 | 21083 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec }, |
| 14369 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 21084 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 14370 | 21085 | .patterns = &.{ |
| 14371 | | .{ .src = .{ .to_mem, .none } }, |
| 21086 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14372 | 21087 | }, |
| 14373 | 21088 | .extra_temps = .{ |
| 14374 | 21089 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14398,9 +21113,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14398 | 21113 | } }, |
| 14399 | 21114 | }, .{ |
| 14400 | 21115 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, |
| 14401 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 21116 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 14402 | 21117 | .patterns = &.{ |
| 14403 | | .{ .src = .{ .to_mem, .none } }, |
| 21118 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14404 | 21119 | }, |
| 14405 | 21120 | .extra_temps = .{ |
| 14406 | 21121 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14430,9 +21145,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14430 | 21145 | } }, |
| 14431 | 21146 | }, .{ |
| 14432 | 21147 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, .slow_incdec, null }, |
| 14433 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 21148 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 14434 | 21149 | .patterns = &.{ |
| 14435 | | .{ .src = .{ .to_mem, .none } }, |
| 21150 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14436 | 21151 | }, |
| 14437 | 21152 | .extra_temps = .{ |
| 14438 | 21153 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14462,9 +21177,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14462 | 21177 | } }, |
| 14463 | 21178 | }, .{ |
| 14464 | 21179 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, |
| 14465 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 21180 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 14466 | 21181 | .patterns = &.{ |
| 14467 | | .{ .src = .{ .to_mem, .none } }, |
| 21182 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14468 | 21183 | }, |
| 14469 | 21184 | .extra_temps = .{ |
| 14470 | 21185 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14494,9 +21209,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14494 | 21209 | } }, |
| 14495 | 21210 | }, .{ |
| 14496 | 21211 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 14497 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 21212 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 14498 | 21213 | .patterns = &.{ |
| 14499 | | .{ .src = .{ .to_mem, .none } }, |
| 21214 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14500 | 21215 | }, |
| 14501 | 21216 | .extra_temps = .{ |
| 14502 | 21217 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14525,9 +21240,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14525 | 21240 | } }, |
| 14526 | 21241 | }, .{ |
| 14527 | 21242 | .required_features = .{ .@"64bit", null, null, null }, |
| 14528 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any }, |
| 21243 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .any, .any }, |
| 14529 | 21244 | .patterns = &.{ |
| 14530 | | .{ .src = .{ .to_mem, .none } }, |
| 21245 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14531 | 21246 | }, |
| 14532 | 21247 | .extra_temps = .{ |
| 14533 | 21248 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14556,10 +21271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14556 | 21271 | } }, |
| 14557 | 21272 | }, .{ |
| 14558 | 21273 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 14559 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 21274 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 14560 | 21275 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14561 | 21276 | .patterns = &.{ |
| 14562 | | .{ .src = .{ .to_mem, .none } }, |
| 21277 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14563 | 21278 | }, |
| 14564 | 21279 | .extra_temps = .{ |
| 14565 | 21280 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14596,10 +21311,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14596 | 21311 | } }, |
| 14597 | 21312 | }, .{ |
| 14598 | 21313 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 14599 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 21314 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 14600 | 21315 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14601 | 21316 | .patterns = &.{ |
| 14602 | | .{ .src = .{ .to_mem, .none } }, |
| 21317 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14603 | 21318 | }, |
| 14604 | 21319 | .extra_temps = .{ |
| 14605 | 21320 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14635,10 +21350,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14635 | 21350 | } }, |
| 14636 | 21351 | }, .{ |
| 14637 | 21352 | .required_features = .{ .@"64bit", null, null, null }, |
| 14638 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 21353 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 14639 | 21354 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14640 | 21355 | .patterns = &.{ |
| 14641 | | .{ .src = .{ .to_mem, .none } }, |
| 21356 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14642 | 21357 | }, |
| 14643 | 21358 | .extra_temps = .{ |
| 14644 | 21359 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14674,10 +21389,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14674 | 21389 | } }, |
| 14675 | 21390 | }, .{ |
| 14676 | 21391 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 14677 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 21392 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 14678 | 21393 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14679 | 21394 | .patterns = &.{ |
| 14680 | | .{ .src = .{ .to_mem, .none } }, |
| 21395 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14681 | 21396 | }, |
| 14682 | 21397 | .extra_temps = .{ |
| 14683 | 21398 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14714,10 +21429,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14714 | 21429 | } }, |
| 14715 | 21430 | }, .{ |
| 14716 | 21431 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 14717 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 21432 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 14718 | 21433 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14719 | 21434 | .patterns = &.{ |
| 14720 | | .{ .src = .{ .to_mem, .none } }, |
| 21435 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14721 | 21436 | }, |
| 14722 | 21437 | .extra_temps = .{ |
| 14723 | 21438 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14753,10 +21468,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14753 | 21468 | } }, |
| 14754 | 21469 | }, .{ |
| 14755 | 21470 | .required_features = .{ .@"64bit", null, null, null }, |
| 14756 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 21471 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 14757 | 21472 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14758 | 21473 | .patterns = &.{ |
| 14759 | | .{ .src = .{ .to_mem, .none } }, |
| 21474 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14760 | 21475 | }, |
| 14761 | 21476 | .extra_temps = .{ |
| 14762 | 21477 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14792,10 +21507,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14792 | 21507 | } }, |
| 14793 | 21508 | }, .{ |
| 14794 | 21509 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 14795 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 21510 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 14796 | 21511 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14797 | 21512 | .patterns = &.{ |
| 14798 | | .{ .src = .{ .to_mem, .none } }, |
| 21513 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14799 | 21514 | }, |
| 14800 | 21515 | .extra_temps = .{ |
| 14801 | 21516 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14832,10 +21547,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14832 | 21547 | } }, |
| 14833 | 21548 | }, .{ |
| 14834 | 21549 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 14835 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 21550 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 14836 | 21551 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14837 | 21552 | .patterns = &.{ |
| 14838 | | .{ .src = .{ .to_mem, .none } }, |
| 21553 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14839 | 21554 | }, |
| 14840 | 21555 | .extra_temps = .{ |
| 14841 | 21556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14871,10 +21586,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14871 | 21586 | } }, |
| 14872 | 21587 | }, .{ |
| 14873 | 21588 | .required_features = .{ .@"64bit", null, null, null }, |
| 14874 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 21589 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 14875 | 21590 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14876 | 21591 | .patterns = &.{ |
| 14877 | | .{ .src = .{ .to_mem, .none } }, |
| 21592 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14878 | 21593 | }, |
| 14879 | 21594 | .extra_temps = .{ |
| 14880 | 21595 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14910,10 +21625,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14910 | 21625 | } }, |
| 14911 | 21626 | }, .{ |
| 14912 | 21627 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, |
| 14913 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 21628 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 14914 | 21629 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14915 | 21630 | .patterns = &.{ |
| 14916 | | .{ .src = .{ .to_mem, .none } }, |
| 21631 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14917 | 21632 | }, |
| 14918 | 21633 | .extra_temps = .{ |
| 14919 | 21634 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14950,10 +21665,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14950 | 21665 | } }, |
| 14951 | 21666 | }, .{ |
| 14952 | 21667 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 14953 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 21668 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 14954 | 21669 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14955 | 21670 | .patterns = &.{ |
| 14956 | | .{ .src = .{ .to_mem, .none } }, |
| 21671 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14957 | 21672 | }, |
| 14958 | 21673 | .extra_temps = .{ |
| 14959 | 21674 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -14989,10 +21704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14989 | 21704 | } }, |
| 14990 | 21705 | }, .{ |
| 14991 | 21706 | .required_features = .{ .@"64bit", null, null, null }, |
| 14992 | | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 21707 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 14993 | 21708 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14994 | 21709 | .patterns = &.{ |
| 14995 | | .{ .src = .{ .to_mem, .none } }, |
| 21710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14996 | 21711 | }, |
| 14997 | 21712 | .extra_temps = .{ |
| 14998 | 21713 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15005,50 +21720,2361 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15005 | 21720 | .unused, |
| 15006 | 21721 | .unused, |
| 15007 | 21722 | }, |
| 15008 | | .dst_temps = .{.mem}, |
| 15009 | | .clobbers = .{ .eflags = true }, |
| 15010 | | .each = .{ .once = &.{ |
| 15011 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| 15012 | | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| 15013 | | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| 15014 | | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| 15015 | | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ }, |
| 15016 | | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| 15017 | | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 15018 | | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| 15019 | | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| 15020 | | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| 15021 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 15022 | | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| 15023 | | .{ ._, ._, .neg, .tmp3d, ._, ._, ._ }, |
| 15024 | | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| 15025 | | .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 15026 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 15027 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 15028 | | } }, |
| 15029 | | } }) catch |err| switch (err) { |
| 15030 | | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 15031 | | @tagName(air_tag), |
| 15032 | | cg.typeOf(ty_op.operand).fmt(pt), |
| 15033 | | ops[0].tracking(cg), |
| 15034 | | }), |
| 15035 | | else => |e| return e, |
| 15036 | | }; |
| 15037 | | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 15038 | | }, |
| 15039 | | |
| 15040 | | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { |
| 15041 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 15042 | | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; |
| 15043 | | switch (extra.compareOperator()) { |
| 15044 | | .eq, .neq => {}, |
| 15045 | | else => break :fallback try cg.airCmpVector(inst), |
| 15046 | | } |
| 15047 | | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); |
| 15048 | | var res: [1]Temp = undefined; |
| 15049 | | switch (extra.compareOperator()) { |
| 15050 | | .lt => unreachable, |
| 15051 | | .lte => unreachable, |
| 21723 | .dst_temps = .{.mem}, |
| 21724 | .clobbers = .{ .eflags = true }, |
| 21725 | .each = .{ .once = &.{ |
| 21726 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| 21727 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| 21728 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| 21729 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| 21730 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ }, |
| 21731 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| 21732 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 21733 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| 21734 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| 21735 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| 21736 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 21737 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| 21738 | .{ ._, ._, .neg, .tmp3d, ._, ._, ._ }, |
| 21739 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| 21740 | .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 21741 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 21742 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 21743 | } }, |
| 21744 | } }) catch |err| switch (err) { |
| 21745 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 21746 | @tagName(air_tag), |
| 21747 | cg.typeOf(ty_op.operand).fmt(pt), |
| 21748 | ops[0].tracking(cg), |
| 21749 | }), |
| 21750 | else => |e| return e, |
| 21751 | }; |
| 21752 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 21753 | }, |
| 21754 | |
| 21755 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { |
| 21756 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 21757 | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; |
| 21758 | switch (extra.compareOperator()) { |
| 21759 | .eq, .neq => {}, |
| 21760 | .lt, .lte, .gte, .gt => if (cg.floatBits(cg.typeOf(extra.lhs).childType(zcu)) == null) |
| 21761 | break :fallback try cg.airCmpVector(inst), |
| 21762 | } |
| 21763 | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); |
| 21764 | var res: [1]Temp = undefined; |
| 21765 | (err: switch (extra.compareOperator()) { |
| 21766 | .lt, .lte, .gte, .gt => |cmp_op| { |
| 21767 | switch (cmp_op) { |
| 21768 | else => unreachable, |
| 21769 | .lt, .lte => {}, |
| 21770 | .gt, .gte => std.mem.swap(Temp, &ops[0], &ops[1]), |
| 21771 | } |
| 21772 | break :err cg.select(&res, &.{ty_pl.ty.toType()}, &ops, switch (@as(Condition, switch (cmp_op) { |
| 21773 | else => unreachable, |
| 21774 | .lt, .gt => .l, |
| 21775 | .lte, .gte => .le, |
| 21776 | })) { |
| 21777 | else => unreachable, |
| 21778 | inline .l, .le => |cc| comptime &.{ .{ |
| 21779 | .required_features = .{ .f16c, null, null, null }, |
| 21780 | .src_constraints = .{ |
| 21781 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 21782 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 21783 | .any, |
| 21784 | }, |
| 21785 | .patterns = &.{ |
| 21786 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21787 | }, |
| 21788 | .extra_temps = .{ |
| 21789 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 21790 | .unused, |
| 21791 | .unused, |
| 21792 | .unused, |
| 21793 | .unused, |
| 21794 | .unused, |
| 21795 | .unused, |
| 21796 | .unused, |
| 21797 | .unused, |
| 21798 | }, |
| 21799 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 21800 | .ref = .src0, |
| 21801 | .rc = .sse, |
| 21802 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21803 | } }}, |
| 21804 | .each = .{ .once = &.{ |
| 21805 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 21806 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 21807 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0d, .vp(switch (cc) { |
| 21808 | else => unreachable, |
| 21809 | .l => .lt, |
| 21810 | .le => .le, |
| 21811 | }) }, |
| 21812 | } }, |
| 21813 | }, .{ |
| 21814 | .required_features = .{ .f16c, null, null, null }, |
| 21815 | .src_constraints = .{ |
| 21816 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 21817 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 21818 | .any, |
| 21819 | }, |
| 21820 | .patterns = &.{ |
| 21821 | .{ .src = .{ .mem, .mem, .none } }, |
| 21822 | .{ .src = .{ .sse, .mem, .none } }, |
| 21823 | .{ .src = .{ .mem, .sse, .none } }, |
| 21824 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21825 | }, |
| 21826 | .extra_temps = .{ |
| 21827 | .{ .kind = .{ .rc = .sse } }, |
| 21828 | .unused, |
| 21829 | .unused, |
| 21830 | .unused, |
| 21831 | .unused, |
| 21832 | .unused, |
| 21833 | .unused, |
| 21834 | .unused, |
| 21835 | .unused, |
| 21836 | }, |
| 21837 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 21838 | .ref = .src0, |
| 21839 | .rc = .sse, |
| 21840 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21841 | } }}, |
| 21842 | .each = .{ .once = &.{ |
| 21843 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 21844 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 21845 | .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { |
| 21846 | else => unreachable, |
| 21847 | .l => .lt, |
| 21848 | .le => .le, |
| 21849 | }) }, |
| 21850 | } }, |
| 21851 | }, .{ |
| 21852 | .required_features = .{ .f16c, null, null, null }, |
| 21853 | .src_constraints = .{ |
| 21854 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 21855 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 21856 | .any, |
| 21857 | }, |
| 21858 | .patterns = &.{ |
| 21859 | .{ .src = .{ .mem, .mem, .none } }, |
| 21860 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21861 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 21862 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21863 | }, |
| 21864 | .extra_temps = .{ |
| 21865 | .{ .kind = .{ .rc = .sse } }, |
| 21866 | .unused, |
| 21867 | .unused, |
| 21868 | .unused, |
| 21869 | .unused, |
| 21870 | .unused, |
| 21871 | .unused, |
| 21872 | .unused, |
| 21873 | .unused, |
| 21874 | }, |
| 21875 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 21876 | .ref = .src0, |
| 21877 | .rc = .sse, |
| 21878 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21879 | } }}, |
| 21880 | .each = .{ .once = &.{ |
| 21881 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 21882 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 21883 | .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .vp(switch (cc) { |
| 21884 | else => unreachable, |
| 21885 | .l => .lt, |
| 21886 | .le => .le, |
| 21887 | }) }, |
| 21888 | } }, |
| 21889 | }, .{ |
| 21890 | .required_features = .{ .avx, null, null, null }, |
| 21891 | .src_constraints = .{ |
| 21892 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 21893 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 21894 | .any, |
| 21895 | }, |
| 21896 | .patterns = &.{ |
| 21897 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21898 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21899 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21900 | }, |
| 21901 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 21902 | .ref = .src0, |
| 21903 | .rc = .sse, |
| 21904 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21905 | } }}, |
| 21906 | .each = .{ .once = &.{ |
| 21907 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { |
| 21908 | else => unreachable, |
| 21909 | .l => .lt, |
| 21910 | .le => .le, |
| 21911 | }) }, |
| 21912 | } }, |
| 21913 | }, .{ |
| 21914 | .required_features = .{ .sse, null, null, null }, |
| 21915 | .src_constraints = .{ |
| 21916 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 21917 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 21918 | .any, |
| 21919 | }, |
| 21920 | .patterns = &.{ |
| 21921 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 21922 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 21923 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 21924 | }, |
| 21925 | .dst_temps = .{.{ .ref_mask = .{ |
| 21926 | .ref = .src0, |
| 21927 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21928 | } }}, |
| 21929 | .each = .{ .once = &.{ |
| 21930 | .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) { |
| 21931 | else => unreachable, |
| 21932 | .l => .lt, |
| 21933 | .le => .le, |
| 21934 | }), ._ }, |
| 21935 | } }, |
| 21936 | }, .{ |
| 21937 | .required_features = .{ .avx, null, null, null }, |
| 21938 | .src_constraints = .{ |
| 21939 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 21940 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 21941 | .any, |
| 21942 | }, |
| 21943 | .patterns = &.{ |
| 21944 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21945 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21946 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21947 | }, |
| 21948 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 21949 | .ref = .src0, |
| 21950 | .rc = .sse, |
| 21951 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21952 | } }}, |
| 21953 | .each = .{ .once = &.{ |
| 21954 | .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 21955 | else => unreachable, |
| 21956 | .l => .lt, |
| 21957 | .le => .le, |
| 21958 | }) }, |
| 21959 | } }, |
| 21960 | }, .{ |
| 21961 | .required_features = .{ .sse, null, null, null }, |
| 21962 | .src_constraints = .{ |
| 21963 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 21964 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 21965 | .any, |
| 21966 | }, |
| 21967 | .patterns = &.{ |
| 21968 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 21969 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 21970 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 21971 | }, |
| 21972 | .dst_temps = .{.{ .ref_mask = .{ |
| 21973 | .ref = .src0, |
| 21974 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21975 | } }}, |
| 21976 | .each = .{ .once = &.{ |
| 21977 | .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) { |
| 21978 | else => unreachable, |
| 21979 | .l => .lt, |
| 21980 | .le => .le, |
| 21981 | }), ._ }, |
| 21982 | } }, |
| 21983 | }, .{ |
| 21984 | .required_features = .{ .avx, null, null, null }, |
| 21985 | .src_constraints = .{ |
| 21986 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 21987 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 21988 | .any, |
| 21989 | }, |
| 21990 | .patterns = &.{ |
| 21991 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21992 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21993 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21994 | }, |
| 21995 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 21996 | .ref = .src0, |
| 21997 | .rc = .sse, |
| 21998 | .info = .{ .kind = .all, .scalar = .dword }, |
| 21999 | } }}, |
| 22000 | .each = .{ .once = &.{ |
| 22001 | .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { |
| 22002 | else => unreachable, |
| 22003 | .l => .lt, |
| 22004 | .le => .le, |
| 22005 | }) }, |
| 22006 | } }, |
| 22007 | }, .{ |
| 22008 | .required_features = .{ .avx, null, null, null }, |
| 22009 | .src_constraints = .{ |
| 22010 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 22011 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 22012 | .any, |
| 22013 | }, |
| 22014 | .patterns = &.{ |
| 22015 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 22016 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 22017 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 22018 | }, |
| 22019 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 22020 | .ref = .src0, |
| 22021 | .rc = .sse, |
| 22022 | .info = .{ .kind = .all, .scalar = .qword }, |
| 22023 | } }}, |
| 22024 | .each = .{ .once = &.{ |
| 22025 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { |
| 22026 | else => unreachable, |
| 22027 | .l => .lt, |
| 22028 | .le => .le, |
| 22029 | }) }, |
| 22030 | } }, |
| 22031 | }, .{ |
| 22032 | .required_features = .{ .sse2, null, null, null }, |
| 22033 | .src_constraints = .{ |
| 22034 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 22035 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 22036 | .any, |
| 22037 | }, |
| 22038 | .patterns = &.{ |
| 22039 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 22040 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 22041 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 22042 | }, |
| 22043 | .dst_temps = .{.{ .ref_mask = .{ |
| 22044 | .ref = .src0, |
| 22045 | .info = .{ .kind = .all, .scalar = .qword }, |
| 22046 | } }}, |
| 22047 | .each = .{ .once = &.{ |
| 22048 | .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) { |
| 22049 | else => unreachable, |
| 22050 | .l => .lt, |
| 22051 | .le => .le, |
| 22052 | }), ._ }, |
| 22053 | } }, |
| 22054 | }, .{ |
| 22055 | .required_features = .{ .avx, null, null, null }, |
| 22056 | .src_constraints = .{ |
| 22057 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 22058 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 22059 | .any, |
| 22060 | }, |
| 22061 | .patterns = &.{ |
| 22062 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 22063 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 22064 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 22065 | }, |
| 22066 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 22067 | .ref = .src0, |
| 22068 | .rc = .sse, |
| 22069 | .info = .{ .kind = .all, .scalar = .qword }, |
| 22070 | } }}, |
| 22071 | .each = .{ .once = &.{ |
| 22072 | .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 22073 | else => unreachable, |
| 22074 | .l => .lt, |
| 22075 | .le => .le, |
| 22076 | }) }, |
| 22077 | } }, |
| 22078 | }, .{ |
| 22079 | .required_features = .{ .sse2, null, null, null }, |
| 22080 | .src_constraints = .{ |
| 22081 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 22082 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 22083 | .any, |
| 22084 | }, |
| 22085 | .patterns = &.{ |
| 22086 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 22087 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 22088 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 22089 | }, |
| 22090 | .dst_temps = .{.{ .ref_mask = .{ |
| 22091 | .ref = .src0, |
| 22092 | .info = .{ .kind = .all, .scalar = .qword }, |
| 22093 | } }}, |
| 22094 | .each = .{ .once = &.{ |
| 22095 | .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) { |
| 22096 | else => unreachable, |
| 22097 | .l => .lt, |
| 22098 | .le => .le, |
| 22099 | }), ._ }, |
| 22100 | } }, |
| 22101 | }, .{ |
| 22102 | .required_features = .{ .avx, null, null, null }, |
| 22103 | .src_constraints = .{ |
| 22104 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 22105 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 22106 | .any, |
| 22107 | }, |
| 22108 | .patterns = &.{ |
| 22109 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 22110 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 22111 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 22112 | }, |
| 22113 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 22114 | .ref = .src0, |
| 22115 | .rc = .sse, |
| 22116 | .info = .{ .kind = .all, .scalar = .qword }, |
| 22117 | } }}, |
| 22118 | .each = .{ .once = &.{ |
| 22119 | .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { |
| 22120 | else => unreachable, |
| 22121 | .l => .lt, |
| 22122 | .le => .le, |
| 22123 | }) }, |
| 22124 | } }, |
| 22125 | }, .{ |
| 22126 | .required_features = .{ .f16c, .slow_incdec, null, null }, |
| 22127 | .src_constraints = .{ |
| 22128 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 22129 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 22130 | .any, |
| 22131 | }, |
| 22132 | .patterns = &.{ |
| 22133 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22134 | }, |
| 22135 | .extra_temps = .{ |
| 22136 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22137 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22138 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22139 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22140 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22141 | .unused, |
| 22142 | .unused, |
| 22143 | .unused, |
| 22144 | .unused, |
| 22145 | }, |
| 22146 | .dst_temps = .{.mem}, |
| 22147 | .clobbers = .{ .eflags = true }, |
| 22148 | .each = .{ .once = &.{ |
| 22149 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22150 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22151 | .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 22152 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 22153 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) { |
| 22154 | else => unreachable, |
| 22155 | .l => .lt, |
| 22156 | .le => .le, |
| 22157 | }) }, |
| 22158 | .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 22159 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ }, |
| 22160 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 22161 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 22162 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22163 | } }, |
| 22164 | }, .{ |
| 22165 | .required_features = .{ .f16c, null, null, null }, |
| 22166 | .src_constraints = .{ |
| 22167 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 22168 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 22169 | .any, |
| 22170 | }, |
| 22171 | .patterns = &.{ |
| 22172 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22173 | }, |
| 22174 | .extra_temps = .{ |
| 22175 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22176 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22177 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22178 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22179 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22180 | .unused, |
| 22181 | .unused, |
| 22182 | .unused, |
| 22183 | .unused, |
| 22184 | }, |
| 22185 | .dst_temps = .{.mem}, |
| 22186 | .clobbers = .{ .eflags = true }, |
| 22187 | .each = .{ .once = &.{ |
| 22188 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22189 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22190 | .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 22191 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 22192 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) { |
| 22193 | else => unreachable, |
| 22194 | .l => .lt, |
| 22195 | .le => .le, |
| 22196 | }) }, |
| 22197 | .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 22198 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ }, |
| 22199 | .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, |
| 22200 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 22201 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22202 | } }, |
| 22203 | }, .{ |
| 22204 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 22205 | .src_constraints = .{ |
| 22206 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22207 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22208 | .any, |
| 22209 | }, |
| 22210 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 22211 | .patterns = &.{ |
| 22212 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22213 | }, |
| 22214 | .call_frame = .{ .alignment = .@"16" }, |
| 22215 | .extra_temps = .{ |
| 22216 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22217 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22218 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22219 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22220 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22221 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22222 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 22223 | .unused, |
| 22224 | .unused, |
| 22225 | }, |
| 22226 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 22227 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22228 | .each = .{ .once = &.{ |
| 22229 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 22230 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22231 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 22232 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0) }, |
| 22233 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0) }, |
| 22234 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22235 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 22236 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 22237 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 22238 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22239 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 22240 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| 22241 | .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ }, |
| 22242 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22243 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22244 | } }, |
| 22245 | }, .{ |
| 22246 | .required_features = .{ .avx, null, null, null }, |
| 22247 | .src_constraints = .{ |
| 22248 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22249 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22250 | .any, |
| 22251 | }, |
| 22252 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 22253 | .patterns = &.{ |
| 22254 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22255 | }, |
| 22256 | .call_frame = .{ .alignment = .@"16" }, |
| 22257 | .extra_temps = .{ |
| 22258 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22259 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22260 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22261 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22262 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22263 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22264 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 22265 | .unused, |
| 22266 | .unused, |
| 22267 | }, |
| 22268 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 22269 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22270 | .each = .{ .once = &.{ |
| 22271 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 22272 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22273 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 22274 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0) }, |
| 22275 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0) }, |
| 22276 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22277 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 22278 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 22279 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 22280 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22281 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 22282 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| 22283 | .{ ._, ._c, .in, .tmp0d, ._, ._, ._ }, |
| 22284 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22285 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22286 | } }, |
| 22287 | }, .{ |
| 22288 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 22289 | .src_constraints = .{ |
| 22290 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22291 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22292 | .any, |
| 22293 | }, |
| 22294 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 22295 | .patterns = &.{ |
| 22296 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22297 | }, |
| 22298 | .call_frame = .{ .alignment = .@"16" }, |
| 22299 | .extra_temps = .{ |
| 22300 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22301 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22302 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22303 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22304 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22305 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22306 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 22307 | .unused, |
| 22308 | .unused, |
| 22309 | }, |
| 22310 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 22311 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22312 | .each = .{ .once = &.{ |
| 22313 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 22314 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22315 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 22316 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 22317 | .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ }, |
| 22318 | .{ ._, .p_w, .insr, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ }, |
| 22319 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22320 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 22321 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 22322 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 22323 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22324 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 22325 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| 22326 | .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ }, |
| 22327 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22328 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22329 | } }, |
| 22330 | }, .{ |
| 22331 | .required_features = .{ .sse2, null, null, null }, |
| 22332 | .src_constraints = .{ |
| 22333 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22334 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22335 | .any, |
| 22336 | }, |
| 22337 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 22338 | .patterns = &.{ |
| 22339 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22340 | }, |
| 22341 | .call_frame = .{ .alignment = .@"16" }, |
| 22342 | .extra_temps = .{ |
| 22343 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22344 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22345 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22346 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22347 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22348 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22349 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 22350 | .unused, |
| 22351 | .unused, |
| 22352 | }, |
| 22353 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 22354 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22355 | .each = .{ .once = &.{ |
| 22356 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 22357 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22358 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 22359 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 22360 | .{ ._, .p_w, .insr, .tmp1x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ }, |
| 22361 | .{ ._, .p_w, .insr, .tmp2x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ }, |
| 22362 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22363 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 22364 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 22365 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 22366 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22367 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 22368 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| 22369 | .{ ._, ._c, .in, .tmp0d, ._, ._, ._ }, |
| 22370 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22371 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22372 | } }, |
| 22373 | }, .{ |
| 22374 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 22375 | .src_constraints = .{ |
| 22376 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22377 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22378 | .any, |
| 22379 | }, |
| 22380 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 22381 | .patterns = &.{ |
| 22382 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22383 | }, |
| 22384 | .call_frame = .{ .alignment = .@"16" }, |
| 22385 | .extra_temps = .{ |
| 22386 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22387 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22388 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22389 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22390 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22391 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22392 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 22393 | .{ .type = .f32, .kind = .mem }, |
| 22394 | .unused, |
| 22395 | }, |
| 22396 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 22397 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22398 | .each = .{ .once = &.{ |
| 22399 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 22400 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22401 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 22402 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 22403 | .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ }, |
| 22404 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 22405 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 22406 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ }, |
| 22407 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22408 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 22409 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 22410 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 22411 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22412 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 22413 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| 22414 | .{ ._, ._, .add, .tmp0d, .si(1), ._, ._ }, |
| 22415 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22416 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22417 | } }, |
| 22418 | }, .{ |
| 22419 | .required_features = .{ .sse, null, null, null }, |
| 22420 | .src_constraints = .{ |
| 22421 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22422 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22423 | .any, |
| 22424 | }, |
| 22425 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 22426 | .patterns = &.{ |
| 22427 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22428 | }, |
| 22429 | .call_frame = .{ .alignment = .@"16" }, |
| 22430 | .extra_temps = .{ |
| 22431 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22432 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22433 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22434 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22435 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22436 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22437 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 22438 | .{ .type = .f32, .kind = .mem }, |
| 22439 | .unused, |
| 22440 | }, |
| 22441 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 22442 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22443 | .each = .{ .once = &.{ |
| 22444 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 22445 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22446 | .{ .@"0:", ._, .movzx, .tmp4d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 22447 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 22448 | .{ ._, ._ss, .mov, .tmp1x, .mem(.tmp7d), ._, ._ }, |
| 22449 | .{ ._, ._, .movzx, .tmp4d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 22450 | .{ ._, ._, .mov, .mem(.tmp7d), .tmp4d, ._, ._ }, |
| 22451 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp7d), ._, ._ }, |
| 22452 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22453 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| 22454 | .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, |
| 22455 | .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, |
| 22456 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22457 | .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, |
| 22458 | .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, |
| 22459 | .{ ._, ._c, .in, .tmp0d, ._, ._, ._ }, |
| 22460 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22461 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22462 | } }, |
| 22463 | }, .{ |
| 22464 | .required_features = .{ .@"64bit", .avx, .slow_incdec, null }, |
| 22465 | .src_constraints = .{ |
| 22466 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22467 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22468 | .any, |
| 22469 | }, |
| 22470 | .patterns = &.{ |
| 22471 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22472 | }, |
| 22473 | .call_frame = .{ .alignment = .@"16" }, |
| 22474 | .extra_temps = .{ |
| 22475 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22476 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 22477 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22478 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22479 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22480 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22481 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22482 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 22483 | .unused, |
| 22484 | }, |
| 22485 | .dst_temps = .{.mem}, |
| 22486 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22487 | .each = .{ .once = &.{ |
| 22488 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22489 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22490 | .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| 22491 | .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memsi(.src0w, .@"2", .tmp0), .ui(0) }, |
| 22492 | .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0) }, |
| 22493 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22494 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 22495 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 22496 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 22497 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 22498 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 22499 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| 22500 | .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ }, |
| 22501 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22502 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 22503 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22504 | .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ }, |
| 22505 | .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ }, |
| 22506 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22507 | .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22508 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22509 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22510 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 22511 | .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, |
| 22512 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ }, |
| 22513 | } }, |
| 22514 | }, .{ |
| 22515 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 22516 | .src_constraints = .{ |
| 22517 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22518 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22519 | .any, |
| 22520 | }, |
| 22521 | .patterns = &.{ |
| 22522 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22523 | }, |
| 22524 | .call_frame = .{ .alignment = .@"16" }, |
| 22525 | .extra_temps = .{ |
| 22526 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22527 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 22528 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22529 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22530 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22531 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22532 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22533 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 22534 | .unused, |
| 22535 | }, |
| 22536 | .dst_temps = .{.mem}, |
| 22537 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22538 | .each = .{ .once = &.{ |
| 22539 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22540 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22541 | .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| 22542 | .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memsi(.src0w, .@"2", .tmp0), .ui(0) }, |
| 22543 | .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0) }, |
| 22544 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22545 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 22546 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 22547 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 22548 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 22549 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 22550 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| 22551 | .{ ._, ._c, .in, .tmp0d, ._, ._, ._ }, |
| 22552 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22553 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 22554 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22555 | .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ }, |
| 22556 | .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ }, |
| 22557 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22558 | .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22559 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22560 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22561 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 22562 | .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, |
| 22563 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ }, |
| 22564 | } }, |
| 22565 | }, .{ |
| 22566 | .required_features = .{ .@"64bit", .sse2, .slow_incdec, null }, |
| 22567 | .src_constraints = .{ |
| 22568 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22569 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22570 | .any, |
| 22571 | }, |
| 22572 | .patterns = &.{ |
| 22573 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22574 | }, |
| 22575 | .call_frame = .{ .alignment = .@"16" }, |
| 22576 | .extra_temps = .{ |
| 22577 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22578 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 22579 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22580 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22581 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22582 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22583 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22584 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 22585 | .unused, |
| 22586 | }, |
| 22587 | .dst_temps = .{.mem}, |
| 22588 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22589 | .each = .{ .once = &.{ |
| 22590 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22591 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22592 | .{ .@"0:", .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 22593 | .{ ._, .p_w, .insr, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ }, |
| 22594 | .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 22595 | .{ ._, .p_w, .insr, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ }, |
| 22596 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22597 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 22598 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 22599 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 22600 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 22601 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 22602 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| 22603 | .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ }, |
| 22604 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22605 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 22606 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22607 | .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ }, |
| 22608 | .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ }, |
| 22609 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22610 | .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22611 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22612 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22613 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 22614 | .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, |
| 22615 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ }, |
| 22616 | } }, |
| 22617 | }, .{ |
| 22618 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 22619 | .src_constraints = .{ |
| 22620 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22621 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22622 | .any, |
| 22623 | }, |
| 22624 | .patterns = &.{ |
| 22625 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22626 | }, |
| 22627 | .call_frame = .{ .alignment = .@"16" }, |
| 22628 | .extra_temps = .{ |
| 22629 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22630 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 22631 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22632 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22633 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22634 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22635 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22636 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 22637 | .unused, |
| 22638 | }, |
| 22639 | .dst_temps = .{.mem}, |
| 22640 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22641 | .each = .{ .once = &.{ |
| 22642 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22643 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22644 | .{ .@"0:", .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 22645 | .{ ._, .p_w, .insr, .tmp2x, .memsi(.src0w, .@"2", .tmp0), .ui(0), ._ }, |
| 22646 | .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 22647 | .{ ._, .p_w, .insr, .tmp3x, .memsi(.src1w, .@"2", .tmp0), .ui(0), ._ }, |
| 22648 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22649 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 22650 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 22651 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 22652 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 22653 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 22654 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| 22655 | .{ ._, ._c, .in, .tmp0d, ._, ._, ._ }, |
| 22656 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22657 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 22658 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22659 | .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ }, |
| 22660 | .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ }, |
| 22661 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22662 | .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22663 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22664 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22665 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 22666 | .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, |
| 22667 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ }, |
| 22668 | } }, |
| 22669 | }, .{ |
| 22670 | .required_features = .{ .@"64bit", .sse, .slow_incdec, null }, |
| 22671 | .src_constraints = .{ |
| 22672 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22673 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22674 | .any, |
| 22675 | }, |
| 22676 | .patterns = &.{ |
| 22677 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22678 | }, |
| 22679 | .call_frame = .{ .alignment = .@"16" }, |
| 22680 | .extra_temps = .{ |
| 22681 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22682 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 22683 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22684 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22685 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22686 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22687 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22688 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 22689 | .{ .type = .f32, .kind = .mem }, |
| 22690 | }, |
| 22691 | .dst_temps = .{.mem}, |
| 22692 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22693 | .each = .{ .once = &.{ |
| 22694 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22695 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22696 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 22697 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 22698 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ }, |
| 22699 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 22700 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 22701 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ }, |
| 22702 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22703 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 22704 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 22705 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 22706 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 22707 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 22708 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| 22709 | .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 1), ._, ._ }, |
| 22710 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22711 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 22712 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22713 | .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ }, |
| 22714 | .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ }, |
| 22715 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22716 | .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22717 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22718 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22719 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 22720 | .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, |
| 22721 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ }, |
| 22722 | } }, |
| 22723 | }, .{ |
| 22724 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 22725 | .src_constraints = .{ |
| 22726 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22727 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 22728 | .any, |
| 22729 | }, |
| 22730 | .patterns = &.{ |
| 22731 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22732 | }, |
| 22733 | .call_frame = .{ .alignment = .@"16" }, |
| 22734 | .extra_temps = .{ |
| 22735 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 22736 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 22737 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22738 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 22739 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 22740 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 22741 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 22742 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 22743 | .{ .type = .f32, .kind = .mem }, |
| 22744 | }, |
| 22745 | .dst_temps = .{.mem}, |
| 22746 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22747 | .each = .{ .once = &.{ |
| 22748 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 22749 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22750 | .{ .@"0:", ._, .movzx, .tmp5d, .memsi(.src0w, .@"2", .tmp0), ._, ._ }, |
| 22751 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 22752 | .{ ._, ._ss, .mov, .tmp2x, .mem(.tmp8d), ._, ._ }, |
| 22753 | .{ ._, ._, .movzx, .tmp5d, .memsi(.src1w, .@"2", .tmp0), ._, ._ }, |
| 22754 | .{ ._, ._, .mov, .mem(.tmp8d), .tmp5d, ._, ._ }, |
| 22755 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp8d), ._, ._ }, |
| 22756 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22757 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 22758 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 22759 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 22760 | .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, |
| 22761 | .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, |
| 22762 | .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, |
| 22763 | .{ ._, ._c, .in, .tmp0d, ._, ._, ._ }, |
| 22764 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22765 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 22766 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| 22767 | .{ ._, ._r, .sh, .tmp5d, .ui(3), ._, ._ }, |
| 22768 | .{ ._, ._, .mov, .memid(.dst0q, .tmp5, -8), .tmp1q, ._, ._ }, |
| 22769 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 22770 | .{ .@"1:", ._, .cmp, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 22771 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 22772 | .{ ._, ._, .@"test", .tmp0d, .si(0b111111), ._, ._ }, |
| 22773 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 22774 | .{ ._, ._r, .sh, .tmp0d, .ui(6), ._, ._ }, |
| 22775 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp1q, ._, ._ }, |
| 22776 | } }, |
| 22777 | }, .{ |
| 22778 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 22779 | .src_constraints = .{ |
| 22780 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22781 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22782 | .any, |
| 22783 | }, |
| 22784 | .patterns = &.{ |
| 22785 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22786 | }, |
| 22787 | .extra_temps = .{ |
| 22788 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22789 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22790 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22791 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22792 | .unused, |
| 22793 | .unused, |
| 22794 | .unused, |
| 22795 | .unused, |
| 22796 | .unused, |
| 22797 | }, |
| 22798 | .dst_temps = .{.mem}, |
| 22799 | .clobbers = .{ .eflags = true }, |
| 22800 | .each = .{ .once = &.{ |
| 22801 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22802 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22803 | .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 22804 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 22805 | else => unreachable, |
| 22806 | .l => .lt, |
| 22807 | .le => .le, |
| 22808 | }) }, |
| 22809 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, |
| 22810 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 22811 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 22812 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 22813 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22814 | } }, |
| 22815 | }, .{ |
| 22816 | .required_features = .{ .avx, null, null, null }, |
| 22817 | .src_constraints = .{ |
| 22818 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22819 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22820 | .any, |
| 22821 | }, |
| 22822 | .patterns = &.{ |
| 22823 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22824 | }, |
| 22825 | .extra_temps = .{ |
| 22826 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22827 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22828 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22829 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22830 | .unused, |
| 22831 | .unused, |
| 22832 | .unused, |
| 22833 | .unused, |
| 22834 | .unused, |
| 22835 | }, |
| 22836 | .dst_temps = .{.mem}, |
| 22837 | .clobbers = .{ .eflags = true }, |
| 22838 | .each = .{ .once = &.{ |
| 22839 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22840 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22841 | .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 22842 | .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 22843 | else => unreachable, |
| 22844 | .l => .lt, |
| 22845 | .le => .le, |
| 22846 | }) }, |
| 22847 | .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, |
| 22848 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 22849 | .{ ._, ._c, .in, .tmp1q, ._, ._, ._ }, |
| 22850 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 22851 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22852 | } }, |
| 22853 | }, .{ |
| 22854 | .required_features = .{ .sse2, null, null, null }, |
| 22855 | .src_constraints = .{ |
| 22856 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22857 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22858 | .any, |
| 22859 | }, |
| 22860 | .patterns = &.{ |
| 22861 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22862 | }, |
| 22863 | .extra_temps = .{ |
| 22864 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22865 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22866 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 22867 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 22868 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22869 | .unused, |
| 22870 | .unused, |
| 22871 | .unused, |
| 22872 | .unused, |
| 22873 | }, |
| 22874 | .dst_temps = .{.mem}, |
| 22875 | .clobbers = .{ .eflags = true }, |
| 22876 | .each = .{ .once = &.{ |
| 22877 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22878 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22879 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 22880 | .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, |
| 22881 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 22882 | else => unreachable, |
| 22883 | .l => .lt, |
| 22884 | .le => .le, |
| 22885 | }), ._ }, |
| 22886 | .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) { |
| 22887 | else => unreachable, |
| 22888 | .l => .lt, |
| 22889 | .le => .le, |
| 22890 | }), ._ }, |
| 22891 | .{ ._, .p_w, .ackssd, .tmp2x, .tmp3x, ._, ._ }, |
| 22892 | .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ }, |
| 22893 | .{ ._, .p_b, .movmsk, .tmp4d, .tmp2x, ._, ._ }, |
| 22894 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ }, |
| 22895 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 22896 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 22897 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22898 | } }, |
| 22899 | }, .{ |
| 22900 | .required_features = .{ .sse, null, null, null }, |
| 22901 | .src_constraints = .{ |
| 22902 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22903 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 22904 | .any, |
| 22905 | }, |
| 22906 | .patterns = &.{ |
| 22907 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22908 | }, |
| 22909 | .extra_temps = .{ |
| 22910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22911 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22912 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 22913 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22914 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22915 | .unused, |
| 22916 | .unused, |
| 22917 | .unused, |
| 22918 | .unused, |
| 22919 | }, |
| 22920 | .dst_temps = .{.mem}, |
| 22921 | .clobbers = .{ .eflags = true }, |
| 22922 | .each = .{ .once = &.{ |
| 22923 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22924 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22925 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 22926 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 22927 | else => unreachable, |
| 22928 | .l => .lt, |
| 22929 | .le => .le, |
| 22930 | }), ._ }, |
| 22931 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, |
| 22932 | .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, |
| 22933 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) { |
| 22934 | else => unreachable, |
| 22935 | .l => .lt, |
| 22936 | .le => .le, |
| 22937 | }), ._ }, |
| 22938 | .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, |
| 22939 | .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, |
| 22940 | .{ ._, ._, .@"or", .tmp3b, .tmp4b, ._, ._ }, |
| 22941 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 22942 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 22943 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 22944 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22945 | } }, |
| 22946 | }, .{ |
| 22947 | .required_features = .{ .sse, null, null, null }, |
| 22948 | .src_constraints = .{ |
| 22949 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 22950 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 22951 | .any, |
| 22952 | }, |
| 22953 | .patterns = &.{ |
| 22954 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 22955 | }, |
| 22956 | .extra_temps = .{ |
| 22957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 22959 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 22960 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22961 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 22962 | .unused, |
| 22963 | .unused, |
| 22964 | .unused, |
| 22965 | .unused, |
| 22966 | }, |
| 22967 | .dst_temps = .{.mem}, |
| 22968 | .clobbers = .{ .eflags = true }, |
| 22969 | .each = .{ .once = &.{ |
| 22970 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 22971 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 22972 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, |
| 22973 | .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ }, |
| 22974 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .sp(switch (cc) { |
| 22975 | else => unreachable, |
| 22976 | .l => .lt, |
| 22977 | .le => .le, |
| 22978 | }), ._ }, |
| 22979 | .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, |
| 22980 | .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, |
| 22981 | .{ ._, ._, .@"or", .tmp3b, .tmp4b, ._, ._ }, |
| 22982 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 22983 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 22984 | .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 22985 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 22986 | else => unreachable, |
| 22987 | .l => .lt, |
| 22988 | .le => .le, |
| 22989 | }), ._ }, |
| 22990 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, |
| 22991 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 22992 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22993 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 22994 | } }, |
| 22995 | }, .{ |
| 22996 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 22997 | .src_constraints = .{ |
| 22998 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 22999 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 23000 | .any, |
| 23001 | }, |
| 23002 | .patterns = &.{ |
| 23003 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23004 | }, |
| 23005 | .extra_temps = .{ |
| 23006 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23007 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 23008 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23009 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23010 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23011 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23012 | .unused, |
| 23013 | .unused, |
| 23014 | .unused, |
| 23015 | }, |
| 23016 | .dst_temps = .{.mem}, |
| 23017 | .clobbers = .{ .eflags = true }, |
| 23018 | .each = .{ .once = &.{ |
| 23019 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23020 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 23021 | .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 23022 | .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, |
| 23023 | .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 23024 | else => unreachable, |
| 23025 | .l => .lt, |
| 23026 | .le => .le, |
| 23027 | }) }, |
| 23028 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) { |
| 23029 | else => unreachable, |
| 23030 | .l => .lt, |
| 23031 | .le => .le, |
| 23032 | }) }, |
| 23033 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 23034 | .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, |
| 23035 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| 23036 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, |
| 23037 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ }, |
| 23038 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 23039 | .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ }, |
| 23040 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23041 | } }, |
| 23042 | }, .{ |
| 23043 | .required_features = .{ .avx, null, null, null }, |
| 23044 | .src_constraints = .{ |
| 23045 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 23046 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 23047 | .any, |
| 23048 | }, |
| 23049 | .patterns = &.{ |
| 23050 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23051 | }, |
| 23052 | .extra_temps = .{ |
| 23053 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23054 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 23055 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23056 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23057 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23058 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23059 | .unused, |
| 23060 | .unused, |
| 23061 | .unused, |
| 23062 | }, |
| 23063 | .dst_temps = .{.mem}, |
| 23064 | .clobbers = .{ .eflags = true }, |
| 23065 | .each = .{ .once = &.{ |
| 23066 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23067 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 23068 | .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 23069 | .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, |
| 23070 | .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 23071 | else => unreachable, |
| 23072 | .l => .lt, |
| 23073 | .le => .le, |
| 23074 | }) }, |
| 23075 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) { |
| 23076 | else => unreachable, |
| 23077 | .l => .lt, |
| 23078 | .le => .le, |
| 23079 | }) }, |
| 23080 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, |
| 23081 | .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, |
| 23082 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| 23083 | .{ ._, ._, .@"or", .tmp4b, .tmp5b, ._, ._ }, |
| 23084 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp4b, ._, ._ }, |
| 23085 | .{ ._, ._c, .in, .tmp1q, ._, ._, ._ }, |
| 23086 | .{ ._, ._, .add, .tmp0p, .si(64), ._, ._ }, |
| 23087 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23088 | } }, |
| 23089 | }, .{ |
| 23090 | .required_features = .{ .avx, null, null, null }, |
| 23091 | .src_constraints = .{ |
| 23092 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 23093 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 23094 | .any, |
| 23095 | }, |
| 23096 | .patterns = &.{ |
| 23097 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23098 | }, |
| 23099 | .extra_temps = .{ |
| 23100 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23101 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23102 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23103 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23104 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23105 | .unused, |
| 23106 | .unused, |
| 23107 | .unused, |
| 23108 | .unused, |
| 23109 | }, |
| 23110 | .dst_temps = .{.mem}, |
| 23111 | .clobbers = .{ .eflags = true }, |
| 23112 | .each = .{ .once = &.{ |
| 23113 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23114 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23115 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23116 | .{ .@"0:", .v_pd, .mova, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 23117 | .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { |
| 23118 | else => unreachable, |
| 23119 | .l => .lt, |
| 23120 | .le => .le, |
| 23121 | }) }, |
| 23122 | .{ ._, .v_pd, .movmsk, .tmp4d, .tmp3y, ._, ._ }, |
| 23123 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| 23124 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, |
| 23125 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 4), ._, ._ }, |
| 23126 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23127 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23128 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| 23129 | .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ }, |
| 23130 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, |
| 23131 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23132 | .{ .@"1:", ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 23133 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23134 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23135 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23136 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23137 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23138 | } }, |
| 23139 | }, .{ |
| 23140 | .required_features = .{ .sse2, null, null, null }, |
| 23141 | .src_constraints = .{ |
| 23142 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 23143 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 23144 | .any, |
| 23145 | }, |
| 23146 | .patterns = &.{ |
| 23147 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23148 | }, |
| 23149 | .extra_temps = .{ |
| 23150 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23151 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23152 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23153 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 23154 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23155 | .unused, |
| 23156 | .unused, |
| 23157 | .unused, |
| 23158 | .unused, |
| 23159 | }, |
| 23160 | .dst_temps = .{.mem}, |
| 23161 | .clobbers = .{ .eflags = true }, |
| 23162 | .each = .{ .once = &.{ |
| 23163 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23164 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23165 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23166 | .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23167 | .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 23168 | else => unreachable, |
| 23169 | .l => .lt, |
| 23170 | .le => .le, |
| 23171 | }), ._ }, |
| 23172 | .{ ._, ._pd, .movmsk, .tmp4d, .tmp3x, ._, ._ }, |
| 23173 | .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, |
| 23174 | .{ ._, ._, .@"or", .tmp2b, .tmp4b, ._, ._ }, |
| 23175 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 2), ._, ._ }, |
| 23176 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23177 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23178 | .{ ._, ._, .mov, .tmp4d, .tmp1d, ._, ._ }, |
| 23179 | .{ ._, ._r, .sh, .tmp4d, .ui(3), ._, ._ }, |
| 23180 | .{ ._, ._, .mov, .memid(.dst0b, .tmp4, -1), .tmp2b, ._, ._ }, |
| 23181 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23182 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23183 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23184 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23185 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23186 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23187 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23188 | } }, |
| 23189 | }, .{ |
| 23190 | .required_features = .{ .x87, .cmov, .slow_incdec, null }, |
| 23191 | .src_constraints = .{ |
| 23192 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 23193 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 23194 | .any, |
| 23195 | }, |
| 23196 | .patterns = &.{ |
| 23197 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 23198 | }, |
| 23199 | .extra_temps = .{ |
| 23200 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23201 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23202 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23203 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23204 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 23205 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 23206 | .unused, |
| 23207 | .unused, |
| 23208 | .unused, |
| 23209 | }, |
| 23210 | .dst_temps = .{.mem}, |
| 23211 | .clobbers = .{ .eflags = true }, |
| 23212 | .each = .{ .once = &.{ |
| 23213 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23214 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23215 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23216 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 23217 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ }, |
| 23218 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, |
| 23219 | .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ }, |
| 23220 | .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ }, |
| 23221 | .{ ._, .fromCond(switch (cc) { |
| 23222 | else => unreachable, |
| 23223 | .l => .a, |
| 23224 | .le => .ae, |
| 23225 | }), .set, .tmp3b, ._, ._, ._ }, |
| 23226 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 23227 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 23228 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23229 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23230 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23231 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 23232 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 23233 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 23234 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23235 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23236 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23237 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23238 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23239 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23240 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23241 | } }, |
| 23242 | }, .{ |
| 23243 | .required_features = .{ .x87, .cmov, null, null }, |
| 23244 | .src_constraints = .{ |
| 23245 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 23246 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 23247 | .any, |
| 23248 | }, |
| 23249 | .patterns = &.{ |
| 23250 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 23251 | }, |
| 23252 | .extra_temps = .{ |
| 23253 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23254 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23255 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23256 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23257 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 23258 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 23259 | .unused, |
| 23260 | .unused, |
| 23261 | .unused, |
| 23262 | }, |
| 23263 | .dst_temps = .{.mem}, |
| 23264 | .clobbers = .{ .eflags = true }, |
| 23265 | .each = .{ .once = &.{ |
| 23266 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23267 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23268 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23269 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 23270 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ }, |
| 23271 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, |
| 23272 | .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ }, |
| 23273 | .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ }, |
| 23274 | .{ ._, .fromCond(switch (cc) { |
| 23275 | else => unreachable, |
| 23276 | .l => .a, |
| 23277 | .le => .ae, |
| 23278 | }), .set, .tmp3b, ._, ._, ._ }, |
| 23279 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 23280 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 23281 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23282 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23283 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23284 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 23285 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 23286 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 23287 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23288 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23289 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23290 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23291 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23292 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23293 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23294 | } }, |
| 23295 | }, .{ |
| 23296 | .required_features = .{ .x87, null, null, null }, |
| 23297 | .src_constraints = .{ |
| 23298 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 23299 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 23300 | .any, |
| 23301 | }, |
| 23302 | .patterns = &.{ |
| 23303 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 23304 | }, |
| 23305 | .extra_temps = .{ |
| 23306 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23307 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23308 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23309 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23310 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 23311 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 23312 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 23313 | .unused, |
| 23314 | .unused, |
| 23315 | }, |
| 23316 | .dst_temps = .{.mem}, |
| 23317 | .clobbers = .{ .eflags = true }, |
| 23318 | .each = .{ .once = &.{ |
| 23319 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23320 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23321 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23322 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 23323 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_size), ._, ._, ._ }, |
| 23324 | .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, |
| 23325 | .{ ._, .f_pp, .ucom, ._, ._, ._, ._ }, |
| 23326 | .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, |
| 23327 | switch (cc) { |
| 23328 | else => unreachable, |
| 23329 | .l => .{ ._, ._, .@"test", .tmp6b, .si(0b1_000_001), ._, ._ }, |
| 23330 | .le => .{ ._, ._r, .sh, .tmp6b, .ui(1), ._, ._ }, |
| 23331 | }, |
| 23332 | .{ ._, .fromCond(switch (cc) { |
| 23333 | else => unreachable, |
| 23334 | .l => .z, |
| 23335 | .le => .nc, |
| 23336 | }), .set, .tmp3b, ._, ._, ._ }, |
| 23337 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 23338 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 23339 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23340 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23341 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23342 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 23343 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 23344 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 23345 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23346 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23347 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23348 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23349 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23350 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23351 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23352 | } }, |
| 23353 | }, .{ |
| 23354 | .required_features = .{ .x87, .cmov, .slow_incdec, null }, |
| 23355 | .src_constraints = .{ |
| 23356 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 23357 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 23358 | .any, |
| 23359 | }, |
| 23360 | .patterns = &.{ |
| 23361 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 23362 | }, |
| 23363 | .extra_temps = .{ |
| 23364 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23365 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23366 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23367 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23368 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 23369 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 23370 | .unused, |
| 23371 | .unused, |
| 23372 | .unused, |
| 23373 | }, |
| 23374 | .dst_temps = .{.mem}, |
| 23375 | .clobbers = .{ .eflags = true }, |
| 23376 | .each = .{ .once = &.{ |
| 23377 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23378 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23379 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23380 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 23381 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 23382 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 23383 | .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ }, |
| 23384 | .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ }, |
| 23385 | .{ ._, .fromCond(switch (cc) { |
| 23386 | else => unreachable, |
| 23387 | .l => .a, |
| 23388 | .le => .ae, |
| 23389 | }), .set, .tmp3b, ._, ._, ._ }, |
| 23390 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 23391 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 23392 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23393 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23394 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23395 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 23396 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 23397 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 23398 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23399 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23400 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23401 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23402 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23403 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23404 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23405 | } }, |
| 23406 | }, .{ |
| 23407 | .required_features = .{ .x87, .cmov, null, null }, |
| 23408 | .src_constraints = .{ |
| 23409 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 23410 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 23411 | .any, |
| 23412 | }, |
| 23413 | .patterns = &.{ |
| 23414 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 23415 | }, |
| 23416 | .extra_temps = .{ |
| 23417 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23418 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23419 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23420 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23421 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 23422 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 23423 | .unused, |
| 23424 | .unused, |
| 23425 | .unused, |
| 23426 | }, |
| 23427 | .dst_temps = .{.mem}, |
| 23428 | .clobbers = .{ .eflags = true }, |
| 23429 | .each = .{ .once = &.{ |
| 23430 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23431 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23432 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23433 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 23434 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 23435 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 23436 | .{ ._, .f_p, .ucomi, .tmp4t, .tmp5t, ._, ._ }, |
| 23437 | .{ ._, .f_p, .st, .tmp5t, ._, ._, ._ }, |
| 23438 | .{ ._, .fromCond(switch (cc) { |
| 23439 | else => unreachable, |
| 23440 | .l => .a, |
| 23441 | .le => .ae, |
| 23442 | }), .set, .tmp3b, ._, ._, ._ }, |
| 23443 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 23444 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 23445 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23446 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23447 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23448 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 23449 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 23450 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 23451 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23452 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23453 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23454 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23455 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23456 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23457 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23458 | } }, |
| 23459 | }, .{ |
| 23460 | .required_features = .{ .x87, null, null, null }, |
| 23461 | .src_constraints = .{ |
| 23462 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 23463 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 23464 | .any, |
| 23465 | }, |
| 23466 | .patterns = &.{ |
| 23467 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 23468 | }, |
| 23469 | .extra_temps = .{ |
| 23470 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23471 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 23472 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23473 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23474 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 23475 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 23476 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 23477 | .unused, |
| 23478 | .unused, |
| 23479 | }, |
| 23480 | .dst_temps = .{.mem}, |
| 23481 | .clobbers = .{ .eflags = true }, |
| 23482 | .each = .{ .once = &.{ |
| 23483 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23484 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23485 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23486 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 23487 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_size), ._, ._, ._ }, |
| 23488 | .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, |
| 23489 | .{ ._, .f_pp, .ucom, ._, ._, ._, ._ }, |
| 23490 | .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, |
| 23491 | switch (cc) { |
| 23492 | else => unreachable, |
| 23493 | .l => .{ ._, ._, .@"test", .tmp6b, .si(0b1_000_001), ._, ._ }, |
| 23494 | .le => .{ ._, ._r, .sh, .tmp6b, .ui(1), ._, ._ }, |
| 23495 | }, |
| 23496 | .{ ._, .fromCond(switch (cc) { |
| 23497 | else => unreachable, |
| 23498 | .l => .z, |
| 23499 | .le => .nc, |
| 23500 | }), .set, .tmp3b, ._, ._, ._ }, |
| 23501 | .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, |
| 23502 | .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, |
| 23503 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23504 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23505 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23506 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 23507 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 23508 | .{ ._, ._, .mov, .memid(.dst0b, .tmp3, -1), .tmp2b, ._, ._ }, |
| 23509 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23510 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23511 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23512 | .{ ._, ._, .@"test", .tmp1d, .si(0b111), ._, ._ }, |
| 23513 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23514 | .{ ._, ._r, .sh, .tmp1d, .ui(3), ._, ._ }, |
| 23515 | .{ ._, ._, .mov, .memi(.dst0b, .tmp1), .tmp2b, ._, ._ }, |
| 23516 | } }, |
| 23517 | }, .{ |
| 23518 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 23519 | .src_constraints = .{ |
| 23520 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23521 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23522 | .any, |
| 23523 | }, |
| 23524 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 23525 | .patterns = &.{ |
| 23526 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23527 | }, |
| 23528 | .call_frame = .{ .alignment = .@"16" }, |
| 23529 | .extra_temps = .{ |
| 23530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23531 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23532 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23533 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23534 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23535 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23536 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23537 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 23538 | .unused, |
| 23539 | }, |
| 23540 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23541 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23542 | .each = .{ .once = &.{ |
| 23543 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 23544 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23545 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23546 | .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23547 | .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23548 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23549 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 23550 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 23551 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 23552 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23553 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 23554 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| 23555 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23556 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23557 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23558 | } }, |
| 23559 | }, .{ |
| 23560 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 23561 | .src_constraints = .{ |
| 23562 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23563 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23564 | .any, |
| 23565 | }, |
| 23566 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 23567 | .patterns = &.{ |
| 23568 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23569 | }, |
| 23570 | .call_frame = .{ .alignment = .@"16" }, |
| 23571 | .extra_temps = .{ |
| 23572 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23573 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23574 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23575 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23576 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23577 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23578 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23579 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 23580 | .unused, |
| 23581 | }, |
| 23582 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23583 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23584 | .each = .{ .once = &.{ |
| 23585 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 23586 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23587 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23588 | .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23589 | .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23590 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23591 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 23592 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 23593 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 23594 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23595 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 23596 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| 23597 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23598 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23599 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23600 | } }, |
| 23601 | }, .{ |
| 23602 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 23603 | .src_constraints = .{ |
| 23604 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23605 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23606 | .any, |
| 23607 | }, |
| 23608 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 23609 | .patterns = &.{ |
| 23610 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23611 | }, |
| 23612 | .call_frame = .{ .alignment = .@"16" }, |
| 23613 | .extra_temps = .{ |
| 23614 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23615 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23616 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23617 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23618 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23619 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23620 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23621 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 23622 | .unused, |
| 23623 | }, |
| 23624 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23625 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23626 | .each = .{ .once = &.{ |
| 23627 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 23628 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23629 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23630 | .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23631 | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23632 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23633 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 23634 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 23635 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 23636 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23637 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 23638 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| 23639 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23640 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23641 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23642 | } }, |
| 23643 | }, .{ |
| 23644 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 23645 | .src_constraints = .{ |
| 23646 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23647 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23648 | .any, |
| 23649 | }, |
| 23650 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 23651 | .patterns = &.{ |
| 23652 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23653 | }, |
| 23654 | .call_frame = .{ .alignment = .@"16" }, |
| 23655 | .extra_temps = .{ |
| 23656 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23657 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23658 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23659 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23660 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23661 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23662 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23663 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 23664 | .unused, |
| 23665 | }, |
| 23666 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23667 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23668 | .each = .{ .once = &.{ |
| 23669 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 23670 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23671 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23672 | .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23673 | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23674 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23675 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 23676 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 23677 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 23678 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23679 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 23680 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| 23681 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23682 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23683 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23684 | } }, |
| 23685 | }, .{ |
| 23686 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 23687 | .src_constraints = .{ |
| 23688 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23689 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23690 | .any, |
| 23691 | }, |
| 23692 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 23693 | .patterns = &.{ |
| 23694 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23695 | }, |
| 23696 | .call_frame = .{ .alignment = .@"16" }, |
| 23697 | .extra_temps = .{ |
| 23698 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23699 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23700 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23701 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23702 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23703 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23704 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23705 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 23706 | .unused, |
| 23707 | }, |
| 23708 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23709 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23710 | .each = .{ .once = &.{ |
| 23711 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 23712 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23713 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23714 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23715 | .{ ._, ._ps, .mova, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23716 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23717 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 23718 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 23719 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 23720 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23721 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 23722 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| 23723 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23724 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23725 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23726 | } }, |
| 23727 | }, .{ |
| 23728 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 23729 | .src_constraints = .{ |
| 23730 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23731 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23732 | .any, |
| 23733 | }, |
| 23734 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 23735 | .patterns = &.{ |
| 23736 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23737 | }, |
| 23738 | .call_frame = .{ .alignment = .@"16" }, |
| 23739 | .extra_temps = .{ |
| 23740 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23741 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23742 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23743 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23744 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23745 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23746 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23747 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 23748 | .unused, |
| 23749 | }, |
| 23750 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23751 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23752 | .each = .{ .once = &.{ |
| 23753 | .{ ._, ._, .xor, .dst0d, .dst0d, ._, ._ }, |
| 23754 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23755 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23756 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23757 | .{ ._, ._ps, .mova, .tmp3x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23758 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23759 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| 23760 | .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, |
| 23761 | .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, |
| 23762 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23763 | .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, |
| 23764 | .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, |
| 23765 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23766 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23767 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23768 | } }, |
| 23769 | }, .{ |
| 23770 | .required_features = .{ .@"64bit", .avx, .slow_incdec, null }, |
| 23771 | .src_constraints = .{ |
| 23772 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23773 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23774 | .any, |
| 23775 | }, |
| 23776 | .patterns = &.{ |
| 23777 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23778 | }, |
| 23779 | .call_frame = .{ .alignment = .@"16" }, |
| 23780 | .extra_temps = .{ |
| 23781 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23782 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23783 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 23784 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23785 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23786 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23787 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23788 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23789 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 23790 | }, |
| 23791 | .dst_temps = .{.mem}, |
| 23792 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23793 | .each = .{ .once = &.{ |
| 23794 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23795 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23796 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23797 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23798 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23799 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 23800 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 23801 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 23802 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 23803 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 23804 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 23805 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| 23806 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23807 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23808 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23809 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23810 | .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ }, |
| 23811 | .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ }, |
| 23812 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23813 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23814 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23815 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23816 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23817 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 23818 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 23819 | } }, |
| 23820 | }, .{ |
| 23821 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 23822 | .src_constraints = .{ |
| 23823 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23824 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23825 | .any, |
| 23826 | }, |
| 23827 | .patterns = &.{ |
| 23828 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23829 | }, |
| 23830 | .call_frame = .{ .alignment = .@"16" }, |
| 23831 | .extra_temps = .{ |
| 23832 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23833 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23834 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 23835 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23836 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23837 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23838 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23839 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23840 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 23841 | }, |
| 23842 | .dst_temps = .{.mem}, |
| 23843 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23844 | .each = .{ .once = &.{ |
| 23845 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23846 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23847 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23848 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23849 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23850 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 23851 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 23852 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 23853 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 23854 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 23855 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 23856 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| 23857 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23858 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23859 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23860 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23861 | .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ }, |
| 23862 | .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ }, |
| 23863 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23864 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23865 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23866 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23867 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23868 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 23869 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 23870 | } }, |
| 23871 | }, .{ |
| 23872 | .required_features = .{ .@"64bit", .sse2, .slow_incdec, null }, |
| 23873 | .src_constraints = .{ |
| 23874 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23875 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23876 | .any, |
| 23877 | }, |
| 23878 | .patterns = &.{ |
| 23879 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23880 | }, |
| 23881 | .call_frame = .{ .alignment = .@"16" }, |
| 23882 | .extra_temps = .{ |
| 23883 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23884 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23885 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 23886 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23887 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23888 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23889 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23890 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23891 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 23892 | }, |
| 23893 | .dst_temps = .{.mem}, |
| 23894 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23895 | .each = .{ .once = &.{ |
| 23896 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23897 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23898 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23899 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23900 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23901 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 23902 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 23903 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 23904 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 23905 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 23906 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 23907 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| 23908 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 23909 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23910 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23911 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23912 | .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ }, |
| 23913 | .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ }, |
| 23914 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23915 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23916 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23917 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23918 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23919 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 23920 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 23921 | } }, |
| 23922 | }, .{ |
| 23923 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 23924 | .src_constraints = .{ |
| 23925 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23926 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23927 | .any, |
| 23928 | }, |
| 23929 | .patterns = &.{ |
| 23930 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23931 | }, |
| 23932 | .call_frame = .{ .alignment = .@"16" }, |
| 23933 | .extra_temps = .{ |
| 23934 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23935 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23936 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 23937 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23938 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23939 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23940 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23941 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23942 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 23943 | }, |
| 23944 | .dst_temps = .{.mem}, |
| 23945 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23946 | .each = .{ .once = &.{ |
| 23947 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23948 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23949 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23950 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 23951 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 23952 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 23953 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 23954 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 23955 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 23956 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 23957 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 23958 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| 23959 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 23960 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23961 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 23962 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 23963 | .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ }, |
| 23964 | .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ }, |
| 23965 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 23966 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23967 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23968 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 23969 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 23970 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 23971 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 23972 | } }, |
| 23973 | }, .{ |
| 23974 | .required_features = .{ .@"64bit", .sse, .slow_incdec, null }, |
| 23975 | .src_constraints = .{ |
| 23976 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23977 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 23978 | .any, |
| 23979 | }, |
| 23980 | .patterns = &.{ |
| 23981 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 23982 | }, |
| 23983 | .call_frame = .{ .alignment = .@"16" }, |
| 23984 | .extra_temps = .{ |
| 23985 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23986 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23987 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 23988 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23989 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 23990 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 23991 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 23992 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 23993 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 23994 | }, |
| 23995 | .dst_temps = .{.mem}, |
| 23996 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23997 | .each = .{ .once = &.{ |
| 23998 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 23999 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 24000 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 24001 | .{ .@"0:", ._ps, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 24002 | .{ ._, ._ps, .mova, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 24003 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 24004 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 24005 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 24006 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 24007 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 24008 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 24009 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| 24010 | .{ ._, ._, .lea, .tmp1d, .lead(.tmp1, 1), ._, ._ }, |
| 24011 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 24012 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 24013 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 24014 | .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ }, |
| 24015 | .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ }, |
| 24016 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 24017 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 24018 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24019 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 24020 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 24021 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 24022 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 24023 | } }, |
| 24024 | }, .{ |
| 24025 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 24026 | .src_constraints = .{ |
| 24027 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 24028 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 24029 | .any, |
| 24030 | }, |
| 24031 | .patterns = &.{ |
| 24032 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 24033 | }, |
| 24034 | .call_frame = .{ .alignment = .@"16" }, |
| 24035 | .extra_temps = .{ |
| 24036 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24037 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24038 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 24039 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 24040 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 24041 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 24042 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 24043 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 24044 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 24045 | }, |
| 24046 | .dst_temps = .{.mem}, |
| 24047 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 24048 | .each = .{ .once = &.{ |
| 24049 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 24050 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 24051 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 24052 | .{ .@"0:", ._ps, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 24053 | .{ ._, ._ps, .mova, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 24054 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 24055 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| 24056 | .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, |
| 24057 | .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, |
| 24058 | .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, |
| 24059 | .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, |
| 24060 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| 24061 | .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, |
| 24062 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 24063 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 24064 | .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, |
| 24065 | .{ ._, ._r, .sh, .tmp6d, .ui(3), ._, ._ }, |
| 24066 | .{ ._, ._, .mov, .memid(.dst0q, .tmp6, -8), .tmp2q, ._, ._ }, |
| 24067 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 24068 | .{ .@"1:", ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 24069 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24070 | .{ ._, ._, .@"test", .tmp1d, .si(0b111111), ._, ._ }, |
| 24071 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 24072 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 24073 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 24074 | } }, |
| 24075 | } }, |
| 24076 | }); |
| 24077 | }, |
| 15052 | 24078 | .eq, .neq => |cmp_op| cg.select(&res, &.{ty_pl.ty.toType()}, &ops, switch (@as(Condition, switch (cmp_op) { |
| 15053 | 24079 | else => unreachable, |
| 15054 | 24080 | .eq => .e, |
| ... | ... | @@ -15057,11 +24083,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15057 | 24083 | else => unreachable, |
| 15058 | 24084 | inline .e, .ne => |cc| comptime &.{ .{ |
| 15059 | 24085 | .required_features = .{ .avx2, null, null, null }, |
| 15060 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24086 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15061 | 24087 | .patterns = &.{ |
| 15062 | | .{ .src = .{ .to_ymm, .mem } }, |
| 15063 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 15064 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 24088 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 24089 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 24090 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15065 | 24091 | }, |
| 15066 | 24092 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15067 | 24093 | .kind = .all, |
| ... | ... | @@ -15077,11 +24103,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15077 | 24103 | } }, |
| 15078 | 24104 | }, .{ |
| 15079 | 24105 | .required_features = .{ .avx2, null, null, null }, |
| 15080 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 24106 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15081 | 24107 | .patterns = &.{ |
| 15082 | | .{ .src = .{ .to_ymm, .mem } }, |
| 15083 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 15084 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 24108 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 24109 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 24110 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15085 | 24111 | }, |
| 15086 | 24112 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15087 | 24113 | .kind = .all, |
| ... | ... | @@ -15097,11 +24123,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15097 | 24123 | } }, |
| 15098 | 24124 | }, .{ |
| 15099 | 24125 | .required_features = .{ .avx2, null, null, null }, |
| 15100 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 24126 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 15101 | 24127 | .patterns = &.{ |
| 15102 | | .{ .src = .{ .to_ymm, .mem } }, |
| 15103 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 15104 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 24128 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 24129 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 24130 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15105 | 24131 | }, |
| 15106 | 24132 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15107 | 24133 | .kind = .all, |
| ... | ... | @@ -15117,11 +24143,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15117 | 24143 | } }, |
| 15118 | 24144 | }, .{ |
| 15119 | 24145 | .required_features = .{ .avx2, null, null, null }, |
| 15120 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 24146 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 15121 | 24147 | .patterns = &.{ |
| 15122 | | .{ .src = .{ .to_ymm, .mem } }, |
| 15123 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 15124 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 24148 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 24149 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 24150 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15125 | 24151 | }, |
| 15126 | 24152 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15127 | 24153 | .kind = .all, |
| ... | ... | @@ -15137,11 +24163,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15137 | 24163 | } }, |
| 15138 | 24164 | }, .{ |
| 15139 | 24165 | .required_features = .{ .avx, null, null, null }, |
| 15140 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24166 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15141 | 24167 | .patterns = &.{ |
| 15142 | | .{ .src = .{ .to_xmm, .mem } }, |
| 15143 | | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 15144 | | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 24168 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 24169 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24170 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15145 | 24171 | }, |
| 15146 | 24172 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15147 | 24173 | .kind = .all, |
| ... | ... | @@ -15157,11 +24183,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15157 | 24183 | } }, |
| 15158 | 24184 | }, .{ |
| 15159 | 24185 | .required_features = .{ .avx, null, null, null }, |
| 15160 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 24186 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15161 | 24187 | .patterns = &.{ |
| 15162 | | .{ .src = .{ .to_xmm, .mem } }, |
| 15163 | | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 15164 | | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 24188 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 24189 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24190 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15165 | 24191 | }, |
| 15166 | 24192 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15167 | 24193 | .kind = .all, |
| ... | ... | @@ -15177,11 +24203,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15177 | 24203 | } }, |
| 15178 | 24204 | }, .{ |
| 15179 | 24205 | .required_features = .{ .avx, null, null, null }, |
| 15180 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 24206 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 15181 | 24207 | .patterns = &.{ |
| 15182 | | .{ .src = .{ .to_xmm, .mem } }, |
| 15183 | | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 15184 | | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 24208 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 24209 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24210 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15185 | 24211 | }, |
| 15186 | 24212 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15187 | 24213 | .kind = .all, |
| ... | ... | @@ -15197,11 +24223,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15197 | 24223 | } }, |
| 15198 | 24224 | }, .{ |
| 15199 | 24225 | .required_features = .{ .avx, null, null, null }, |
| 15200 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 24226 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 15201 | 24227 | .patterns = &.{ |
| 15202 | | .{ .src = .{ .to_xmm, .mem } }, |
| 15203 | | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 15204 | | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 24228 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 24229 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24230 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15205 | 24231 | }, |
| 15206 | 24232 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15207 | 24233 | .kind = .all, |
| ... | ... | @@ -15217,11 +24243,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15217 | 24243 | } }, |
| 15218 | 24244 | }, .{ |
| 15219 | 24245 | .required_features = .{ .sse2, null, null, null }, |
| 15220 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24246 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15221 | 24247 | .patterns = &.{ |
| 15222 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 15223 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 15224 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 24248 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 24249 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24250 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15225 | 24251 | }, |
| 15226 | 24252 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15227 | 24253 | .kind = .all, |
| ... | ... | @@ -15237,11 +24263,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15237 | 24263 | } }, |
| 15238 | 24264 | }, .{ |
| 15239 | 24265 | .required_features = .{ .sse2, null, null, null }, |
| 15240 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 24266 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15241 | 24267 | .patterns = &.{ |
| 15242 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 15243 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 15244 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 24268 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 24269 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24270 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15245 | 24271 | }, |
| 15246 | 24272 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15247 | 24273 | .kind = .all, |
| ... | ... | @@ -15257,11 +24283,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15257 | 24283 | } }, |
| 15258 | 24284 | }, .{ |
| 15259 | 24285 | .required_features = .{ .sse2, null, null, null }, |
| 15260 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 24286 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 15261 | 24287 | .patterns = &.{ |
| 15262 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 15263 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 15264 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 24288 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 24289 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24290 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15265 | 24291 | }, |
| 15266 | 24292 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15267 | 24293 | .kind = .all, |
| ... | ... | @@ -15277,11 +24303,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15277 | 24303 | } }, |
| 15278 | 24304 | }, .{ |
| 15279 | 24305 | .required_features = .{ .sse4_1, null, null, null }, |
| 15280 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 24306 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 15281 | 24307 | .patterns = &.{ |
| 15282 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 15283 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 15284 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 24308 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 24309 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 24310 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15285 | 24311 | }, |
| 15286 | 24312 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15287 | 24313 | .kind = .all, |
| ... | ... | @@ -15297,11 +24323,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15297 | 24323 | } }, |
| 15298 | 24324 | }, .{ |
| 15299 | 24325 | .required_features = .{ .mmx, null, null, null }, |
| 15300 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24326 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15301 | 24327 | .patterns = &.{ |
| 15302 | | .{ .src = .{ .to_mut_mm, .mem } }, |
| 15303 | | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 15304 | | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 24328 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 24329 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 24330 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 15305 | 24331 | }, |
| 15306 | 24332 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15307 | 24333 | .kind = .all, |
| ... | ... | @@ -15317,11 +24343,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15317 | 24343 | } }, |
| 15318 | 24344 | }, .{ |
| 15319 | 24345 | .required_features = .{ .mmx, null, null, null }, |
| 15320 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 24346 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15321 | 24347 | .patterns = &.{ |
| 15322 | | .{ .src = .{ .to_mut_mm, .mem } }, |
| 15323 | | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 15324 | | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 24348 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 24349 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 24350 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 15325 | 24351 | }, |
| 15326 | 24352 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15327 | 24353 | .kind = .all, |
| ... | ... | @@ -15337,11 +24363,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15337 | 24363 | } }, |
| 15338 | 24364 | }, .{ |
| 15339 | 24365 | .required_features = .{ .mmx, null, null, null }, |
| 15340 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 24366 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 15341 | 24367 | .patterns = &.{ |
| 15342 | | .{ .src = .{ .to_mut_mm, .mem } }, |
| 15343 | | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 15344 | | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 24368 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 24369 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 24370 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 15345 | 24371 | }, |
| 15346 | 24372 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15347 | 24373 | .kind = .all, |
| ... | ... | @@ -15356,17 +24382,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15356 | 24382 | .{ ._, .p_d, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 15357 | 24383 | } }, |
| 15358 | 24384 | }, .{ |
| 15359 | | .src_constraints = .{ .{ .bool_vec = .byte }, .{ .bool_vec = .byte } }, |
| 24385 | .src_constraints = .{ .{ .bool_vec = .byte }, .{ .bool_vec = .byte }, .any }, |
| 15360 | 24386 | .patterns = &.{ |
| 15361 | | .{ .src = .{ .mut_mem, .imm8 } }, |
| 15362 | | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15363 | | .{ .src = .{ .to_mut_gpr, .imm8 } }, |
| 15364 | | .{ .src = .{ .imm8, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15365 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 15366 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15367 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 15368 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15369 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 24387 | .{ .src = .{ .mut_mem, .imm8, .none } }, |
| 24388 | .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24389 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 24390 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24391 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 24392 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24393 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 24394 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24395 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15370 | 24396 | }, |
| 15371 | 24397 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15372 | 24398 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -15381,17 +24407,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15381 | 24407 | }, |
| 15382 | 24408 | } }, |
| 15383 | 24409 | }, .{ |
| 15384 | | .src_constraints = .{ .{ .bool_vec = .word }, .{ .bool_vec = .word } }, |
| 24410 | .src_constraints = .{ .{ .bool_vec = .word }, .{ .bool_vec = .word }, .any }, |
| 15385 | 24411 | .patterns = &.{ |
| 15386 | | .{ .src = .{ .mut_mem, .imm16 } }, |
| 15387 | | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15388 | | .{ .src = .{ .to_mut_gpr, .imm16 } }, |
| 15389 | | .{ .src = .{ .imm16, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15390 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 15391 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15392 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 15393 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15394 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 24412 | .{ .src = .{ .mut_mem, .imm16, .none } }, |
| 24413 | .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24414 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 24415 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24416 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 24417 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24418 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 24419 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24420 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15395 | 24421 | }, |
| 15396 | 24422 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15397 | 24423 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -15406,17 +24432,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15406 | 24432 | }, |
| 15407 | 24433 | } }, |
| 15408 | 24434 | }, .{ |
| 15409 | | .src_constraints = .{ .{ .bool_vec = .dword }, .{ .bool_vec = .dword } }, |
| 24435 | .src_constraints = .{ .{ .bool_vec = .dword }, .{ .bool_vec = .dword }, .any }, |
| 15410 | 24436 | .patterns = &.{ |
| 15411 | | .{ .src = .{ .mut_mem, .imm32 } }, |
| 15412 | | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15413 | | .{ .src = .{ .to_mut_gpr, .imm32 } }, |
| 15414 | | .{ .src = .{ .imm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15415 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 15416 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15417 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 15418 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15419 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 24437 | .{ .src = .{ .mut_mem, .imm32, .none } }, |
| 24438 | .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24439 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 24440 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24441 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 24442 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24443 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 24444 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24445 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15420 | 24446 | }, |
| 15421 | 24447 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15422 | 24448 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -15432,17 +24458,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15432 | 24458 | } }, |
| 15433 | 24459 | }, .{ |
| 15434 | 24460 | .required_features = .{ .@"64bit", null, null, null }, |
| 15435 | | .src_constraints = .{ .{ .bool_vec = .qword }, .{ .bool_vec = .qword } }, |
| 24461 | .src_constraints = .{ .{ .bool_vec = .qword }, .{ .bool_vec = .qword }, .any }, |
| 15436 | 24462 | .patterns = &.{ |
| 15437 | | .{ .src = .{ .mut_mem, .simm32 } }, |
| 15438 | | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15439 | | .{ .src = .{ .to_mut_gpr, .simm32 } }, |
| 15440 | | .{ .src = .{ .simm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15441 | | .{ .src = .{ .mut_mem, .to_gpr } }, |
| 15442 | | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, |
| 15443 | | .{ .src = .{ .to_mut_gpr, .mem } }, |
| 15444 | | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, |
| 15445 | | .{ .src = .{ .to_mut_gpr, .to_gpr } }, |
| 24463 | .{ .src = .{ .mut_mem, .simm32, .none } }, |
| 24464 | .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24465 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 24466 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24467 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 24468 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 24469 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 24470 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 24471 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15446 | 24472 | }, |
| 15447 | 24473 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15448 | 24474 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -15457,9 +24483,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15457 | 24483 | }, |
| 15458 | 24484 | } }, |
| 15459 | 24485 | }, .{ |
| 15460 | | .src_constraints = .{ .any_bool_vec, .any_bool_vec }, |
| 24486 | .src_constraints = .{ .any_bool_vec, .any_bool_vec, .any }, |
| 15461 | 24487 | .patterns = &.{ |
| 15462 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24488 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15463 | 24489 | }, |
| 15464 | 24490 | .extra_temps = .{ |
| 15465 | 24491 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15496,9 +24522,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15496 | 24522 | } }, |
| 15497 | 24523 | }, .{ |
| 15498 | 24524 | .required_features = .{ .avx2, null, null, null }, |
| 15499 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24525 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15500 | 24526 | .patterns = &.{ |
| 15501 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24527 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15502 | 24528 | }, |
| 15503 | 24529 | .extra_temps = .{ |
| 15504 | 24530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15541,9 +24567,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15541 | 24567 | } }, |
| 15542 | 24568 | }, .{ |
| 15543 | 24569 | .required_features = .{ .avx2, null, null, null }, |
| 15544 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 24570 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15545 | 24571 | .patterns = &.{ |
| 15546 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24572 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15547 | 24573 | }, |
| 15548 | 24574 | .extra_temps = .{ |
| 15549 | 24575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15588,9 +24614,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15588 | 24614 | } }, |
| 15589 | 24615 | }, .{ |
| 15590 | 24616 | .required_features = .{ .avx2, null, null, null }, |
| 15591 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 24617 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 15592 | 24618 | .patterns = &.{ |
| 15593 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24619 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15594 | 24620 | }, |
| 15595 | 24621 | .extra_temps = .{ |
| 15596 | 24622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15633,9 +24659,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15633 | 24659 | } }, |
| 15634 | 24660 | }, .{ |
| 15635 | 24661 | .required_features = .{ .avx2, null, null, null }, |
| 15636 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 24662 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 15637 | 24663 | .patterns = &.{ |
| 15638 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24664 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15639 | 24665 | }, |
| 15640 | 24666 | .extra_temps = .{ |
| 15641 | 24667 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15702,9 +24728,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15702 | 24728 | } }, |
| 15703 | 24729 | }, .{ |
| 15704 | 24730 | .required_features = .{ .avx, null, null, null }, |
| 15705 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24731 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15706 | 24732 | .patterns = &.{ |
| 15707 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24733 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15708 | 24734 | }, |
| 15709 | 24735 | .extra_temps = .{ |
| 15710 | 24736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15747,9 +24773,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15747 | 24773 | } }, |
| 15748 | 24774 | }, .{ |
| 15749 | 24775 | .required_features = .{ .avx, null, null, null }, |
| 15750 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 24776 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15751 | 24777 | .patterns = &.{ |
| 15752 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24778 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15753 | 24779 | }, |
| 15754 | 24780 | .extra_temps = .{ |
| 15755 | 24781 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15794,9 +24820,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15794 | 24820 | } }, |
| 15795 | 24821 | }, .{ |
| 15796 | 24822 | .required_features = .{ .avx, null, null, null }, |
| 15797 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 24823 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 15798 | 24824 | .patterns = &.{ |
| 15799 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24825 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15800 | 24826 | }, |
| 15801 | 24827 | .extra_temps = .{ |
| 15802 | 24828 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15863,9 +24889,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15863 | 24889 | } }, |
| 15864 | 24890 | }, .{ |
| 15865 | 24891 | .required_features = .{ .avx, null, null, null }, |
| 15866 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 24892 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 15867 | 24893 | .patterns = &.{ |
| 15868 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24894 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15869 | 24895 | }, |
| 15870 | 24896 | .extra_temps = .{ |
| 15871 | 24897 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15932,9 +24958,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15932 | 24958 | } }, |
| 15933 | 24959 | }, .{ |
| 15934 | 24960 | .required_features = .{ .sse2, null, null, null }, |
| 15935 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 24961 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 15936 | 24962 | .patterns = &.{ |
| 15937 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 24963 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15938 | 24964 | }, |
| 15939 | 24965 | .extra_temps = .{ |
| 15940 | 24966 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -15977,9 +25003,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15977 | 25003 | } }, |
| 15978 | 25004 | }, .{ |
| 15979 | 25005 | .required_features = .{ .sse2, null, null, null }, |
| 15980 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 25006 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 15981 | 25007 | .patterns = &.{ |
| 15982 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25008 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15983 | 25009 | }, |
| 15984 | 25010 | .extra_temps = .{ |
| 15985 | 25011 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16024,9 +25050,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16024 | 25050 | } }, |
| 16025 | 25051 | }, .{ |
| 16026 | 25052 | .required_features = .{ .sse2, null, null, null }, |
| 16027 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 25053 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 16028 | 25054 | .patterns = &.{ |
| 16029 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25055 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16030 | 25056 | }, |
| 16031 | 25057 | .extra_temps = .{ |
| 16032 | 25058 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16093,9 +25119,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16093 | 25119 | } }, |
| 16094 | 25120 | }, .{ |
| 16095 | 25121 | .required_features = .{ .sse4_1, null, null, null }, |
| 16096 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 25122 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 16097 | 25123 | .patterns = &.{ |
| 16098 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25124 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16099 | 25125 | }, |
| 16100 | 25126 | .extra_temps = .{ |
| 16101 | 25127 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16162,9 +25188,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16162 | 25188 | } }, |
| 16163 | 25189 | }, .{ |
| 16164 | 25190 | .required_features = .{ .sse, .mmx, null, null }, |
| 16165 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 25191 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 16166 | 25192 | .patterns = &.{ |
| 16167 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25193 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16168 | 25194 | }, |
| 16169 | 25195 | .extra_temps = .{ |
| 16170 | 25196 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16207,9 +25233,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16207 | 25233 | } }, |
| 16208 | 25234 | }, .{ |
| 16209 | 25235 | .required_features = .{ .sse, .mmx, null, null }, |
| 16210 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 25236 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 16211 | 25237 | .patterns = &.{ |
| 16212 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25238 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16213 | 25239 | }, |
| 16214 | 25240 | .extra_temps = .{ |
| 16215 | 25241 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16280,9 +25306,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16280 | 25306 | } }, |
| 16281 | 25307 | }, .{ |
| 16282 | 25308 | .required_features = .{ .sse, .mmx, null, null }, |
| 16283 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 25309 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 16284 | 25310 | .patterns = &.{ |
| 16285 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25311 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16286 | 25312 | }, |
| 16287 | 25313 | .extra_temps = .{ |
| 16288 | 25314 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16354,10 +25380,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16354 | 25380 | }, |
| 16355 | 25381 | } }, |
| 16356 | 25382 | }, .{ |
| 16357 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 25383 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 16358 | 25384 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16359 | 25385 | .patterns = &.{ |
| 16360 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25386 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16361 | 25387 | }, |
| 16362 | 25388 | .extra_temps = .{ |
| 16363 | 25389 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16386,10 +25412,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16386 | 25412 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16387 | 25413 | } }, |
| 16388 | 25414 | }, .{ |
| 16389 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 25415 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 16390 | 25416 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16391 | 25417 | .patterns = &.{ |
| 16392 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25418 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16393 | 25419 | }, |
| 16394 | 25420 | .extra_temps = .{ |
| 16395 | 25421 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16418,10 +25444,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16418 | 25444 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16419 | 25445 | } }, |
| 16420 | 25446 | }, .{ |
| 16421 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 25447 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 16422 | 25448 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16423 | 25449 | .patterns = &.{ |
| 16424 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25450 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16425 | 25451 | }, |
| 16426 | 25452 | .extra_temps = .{ |
| 16427 | 25453 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16451,10 +25477,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16451 | 25477 | } }, |
| 16452 | 25478 | }, .{ |
| 16453 | 25479 | .required_features = .{ .@"64bit", null, null, null }, |
| 16454 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 25480 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 16455 | 25481 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16456 | 25482 | .patterns = &.{ |
| 16457 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25483 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16458 | 25484 | }, |
| 16459 | 25485 | .extra_temps = .{ |
| 16460 | 25486 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16483,10 +25509,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16483 | 25509 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16484 | 25510 | } }, |
| 16485 | 25511 | }, .{ |
| 16486 | | .src_constraints = .{ .any_scalar_int, .any_scalar_int }, |
| 25512 | .src_constraints = .{ .any_scalar_int, .any_scalar_int, .any }, |
| 16487 | 25513 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16488 | 25514 | .patterns = &.{ |
| 16489 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25515 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16490 | 25516 | }, |
| 16491 | 25517 | .extra_temps = .{ |
| 16492 | 25518 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16522,10 +25548,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16522 | 25548 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 16523 | 25549 | } }, |
| 16524 | 25550 | }, .{ |
| 16525 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 25551 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 16526 | 25552 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16527 | 25553 | .patterns = &.{ |
| 16528 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25554 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16529 | 25555 | }, |
| 16530 | 25556 | .extra_temps = .{ |
| 16531 | 25557 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16555,10 +25581,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16555 | 25581 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16556 | 25582 | } }, |
| 16557 | 25583 | }, .{ |
| 16558 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 25584 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 16559 | 25585 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16560 | 25586 | .patterns = &.{ |
| 16561 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25587 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16562 | 25588 | }, |
| 16563 | 25589 | .extra_temps = .{ |
| 16564 | 25590 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16588,10 +25614,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16588 | 25614 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16589 | 25615 | } }, |
| 16590 | 25616 | }, .{ |
| 16591 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 25617 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 16592 | 25618 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16593 | 25619 | .patterns = &.{ |
| 16594 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25620 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16595 | 25621 | }, |
| 16596 | 25622 | .extra_temps = .{ |
| 16597 | 25623 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16622,10 +25648,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16622 | 25648 | } }, |
| 16623 | 25649 | }, .{ |
| 16624 | 25650 | .required_features = .{ .@"64bit", null, null, null }, |
| 16625 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 25651 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 16626 | 25652 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16627 | 25653 | .patterns = &.{ |
| 16628 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25654 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16629 | 25655 | }, |
| 16630 | 25656 | .extra_temps = .{ |
| 16631 | 25657 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16655,10 +25681,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16655 | 25681 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 16656 | 25682 | } }, |
| 16657 | 25683 | }, .{ |
| 16658 | | .src_constraints = .{ .any_scalar_int, .any_scalar_int }, |
| 25684 | .src_constraints = .{ .any_scalar_int, .any_scalar_int, .any }, |
| 16659 | 25685 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16660 | 25686 | .patterns = &.{ |
| 16661 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25687 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16662 | 25688 | }, |
| 16663 | 25689 | .extra_temps = .{ |
| 16664 | 25690 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16696,10 +25722,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16696 | 25722 | } }, |
| 16697 | 25723 | }, .{ |
| 16698 | 25724 | .required_features = .{ .@"64bit", null, null, null }, |
| 16699 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 25725 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 16700 | 25726 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16701 | 25727 | .patterns = &.{ |
| 16702 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25728 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16703 | 25729 | }, |
| 16704 | 25730 | .extra_temps = .{ |
| 16705 | 25731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16730,10 +25756,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16730 | 25756 | } }, |
| 16731 | 25757 | }, .{ |
| 16732 | 25758 | .required_features = .{ .@"64bit", null, null, null }, |
| 16733 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word } }, |
| 25759 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 16734 | 25760 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16735 | 25761 | .patterns = &.{ |
| 16736 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25762 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16737 | 25763 | }, |
| 16738 | 25764 | .extra_temps = .{ |
| 16739 | 25765 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16763,10 +25789,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16763 | 25789 | } }, |
| 16764 | 25790 | }, .{ |
| 16765 | 25791 | .required_features = .{ .@"64bit", null, null, null }, |
| 16766 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword } }, |
| 25792 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 16767 | 25793 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16768 | 25794 | .patterns = &.{ |
| 16769 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25795 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16770 | 25796 | }, |
| 16771 | 25797 | .extra_temps = .{ |
| 16772 | 25798 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16797,10 +25823,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16797 | 25823 | } }, |
| 16798 | 25824 | }, .{ |
| 16799 | 25825 | .required_features = .{ .@"64bit", null, null, null }, |
| 16800 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword } }, |
| 25826 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 16801 | 25827 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16802 | 25828 | .patterns = &.{ |
| 16803 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25829 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16804 | 25830 | }, |
| 16805 | 25831 | .extra_temps = .{ |
| 16806 | 25832 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16831,10 +25857,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16831 | 25857 | } }, |
| 16832 | 25858 | }, .{ |
| 16833 | 25859 | .required_features = .{ .@"64bit", null, null, null }, |
| 16834 | | .src_constraints = .{ .any_scalar_int, .any_scalar_int }, |
| 25860 | .src_constraints = .{ .any_scalar_int, .any_scalar_int, .any }, |
| 16835 | 25861 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16836 | 25862 | .patterns = &.{ |
| 16837 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25863 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16838 | 25864 | }, |
| 16839 | 25865 | .extra_temps = .{ |
| 16840 | 25866 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16871,9 +25897,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16871 | 25897 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 16872 | 25898 | } }, |
| 16873 | 25899 | }, .{ |
| 16874 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte } }, |
| 25900 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 16875 | 25901 | .patterns = &.{ |
| 16876 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 25902 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16877 | 25903 | }, |
| 16878 | 25904 | .extra_temps = .{ |
| 16879 | 25905 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -16917,9 +25943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16917 | 25943 | .src_constraints = .{ |
| 16918 | 25944 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 16919 | 25945 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 25946 | .any, |
| 16920 | 25947 | }, |
| 16921 | 25948 | .patterns = &.{ |
| 16922 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 25949 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 16923 | 25950 | }, |
| 16924 | 25951 | .extra_temps = .{ |
| 16925 | 25952 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| ... | ... | @@ -16940,7 +25967,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16940 | 25967 | .each = .{ .once = &.{ |
| 16941 | 25968 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 16942 | 25969 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 16943 | | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { |
| 25970 | .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0d, .vp(switch (cc) { |
| 16944 | 25971 | else => unreachable, |
| 16945 | 25972 | .e => .eq, |
| 16946 | 25973 | .ne => .neq, |
| ... | ... | @@ -16951,12 +25978,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16951 | 25978 | .src_constraints = .{ |
| 16952 | 25979 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 16953 | 25980 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 25981 | .any, |
| 16954 | 25982 | }, |
| 16955 | 25983 | .patterns = &.{ |
| 16956 | | .{ .src = .{ .mem, .mem } }, |
| 16957 | | .{ .src = .{ .sse, .mem } }, |
| 16958 | | .{ .src = .{ .mem, .sse } }, |
| 16959 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 25984 | .{ .src = .{ .mem, .mem, .none } }, |
| 25985 | .{ .src = .{ .sse, .mem, .none } }, |
| 25986 | .{ .src = .{ .mem, .sse, .none } }, |
| 25987 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 16960 | 25988 | }, |
| 16961 | 25989 | .extra_temps = .{ |
| 16962 | 25990 | .{ .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -16988,12 +26016,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16988 | 26016 | .src_constraints = .{ |
| 16989 | 26017 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 16990 | 26018 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 26019 | .any, |
| 16991 | 26020 | }, |
| 16992 | 26021 | .patterns = &.{ |
| 16993 | | .{ .src = .{ .mem, .mem } }, |
| 16994 | | .{ .src = .{ .to_sse, .mem } }, |
| 16995 | | .{ .src = .{ .mem, .to_sse } }, |
| 16996 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26022 | .{ .src = .{ .mem, .mem, .none } }, |
| 26023 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26024 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 26025 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 16997 | 26026 | }, |
| 16998 | 26027 | .extra_temps = .{ |
| 16999 | 26028 | .{ .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -17025,11 +26054,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17025 | 26054 | .src_constraints = .{ |
| 17026 | 26055 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 17027 | 26056 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 26057 | .any, |
| 17028 | 26058 | }, |
| 17029 | 26059 | .patterns = &.{ |
| 17030 | | .{ .src = .{ .to_sse, .mem } }, |
| 17031 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 17032 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26060 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26061 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26062 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17033 | 26063 | }, |
| 17034 | 26064 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17035 | 26065 | .ref = .src0, |
| ... | ... | @@ -17037,7 +26067,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17037 | 26067 | .info = .{ .kind = .all, .scalar = .dword }, |
| 17038 | 26068 | } }}, |
| 17039 | 26069 | .each = .{ .once = &.{ |
| 17040 | | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 26070 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { |
| 17041 | 26071 | else => unreachable, |
| 17042 | 26072 | .e => .eq, |
| 17043 | 26073 | .ne => .neq, |
| ... | ... | @@ -17048,18 +26078,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17048 | 26078 | .src_constraints = .{ |
| 17049 | 26079 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 17050 | 26080 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 26081 | .any, |
| 17051 | 26082 | }, |
| 17052 | 26083 | .patterns = &.{ |
| 17053 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 17054 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 17055 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 26084 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26085 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26086 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17056 | 26087 | }, |
| 17057 | 26088 | .dst_temps = .{.{ .ref_mask = .{ |
| 17058 | 26089 | .ref = .src0, |
| 17059 | 26090 | .info = .{ .kind = .all, .scalar = .dword }, |
| 17060 | 26091 | } }}, |
| 17061 | 26092 | .each = .{ .once = &.{ |
| 17062 | | .{ ._, ._ss, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 26093 | .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) { |
| 17063 | 26094 | else => unreachable, |
| 17064 | 26095 | .e => .eq, |
| 17065 | 26096 | .ne => .neq, |
| ... | ... | @@ -17070,11 +26101,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17070 | 26101 | .src_constraints = .{ |
| 17071 | 26102 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 17072 | 26103 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 26104 | .any, |
| 17073 | 26105 | }, |
| 17074 | 26106 | .patterns = &.{ |
| 17075 | | .{ .src = .{ .to_sse, .mem } }, |
| 17076 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 17077 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26107 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26108 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26109 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17078 | 26110 | }, |
| 17079 | 26111 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17080 | 26112 | .ref = .src0, |
| ... | ... | @@ -17093,18 +26125,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17093 | 26125 | .src_constraints = .{ |
| 17094 | 26126 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 17095 | 26127 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 26128 | .any, |
| 17096 | 26129 | }, |
| 17097 | 26130 | .patterns = &.{ |
| 17098 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 17099 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 17100 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 26131 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26132 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26133 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17101 | 26134 | }, |
| 17102 | 26135 | .dst_temps = .{.{ .ref_mask = .{ |
| 17103 | 26136 | .ref = .src0, |
| 17104 | 26137 | .info = .{ .kind = .all, .scalar = .dword }, |
| 17105 | 26138 | } }}, |
| 17106 | 26139 | .each = .{ .once = &.{ |
| 17107 | | .{ ._, ._ps, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 26140 | .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) { |
| 17108 | 26141 | else => unreachable, |
| 17109 | 26142 | .e => .eq, |
| 17110 | 26143 | .ne => .neq, |
| ... | ... | @@ -17115,11 +26148,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17115 | 26148 | .src_constraints = .{ |
| 17116 | 26149 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 17117 | 26150 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 26151 | .any, |
| 17118 | 26152 | }, |
| 17119 | 26153 | .patterns = &.{ |
| 17120 | | .{ .src = .{ .to_sse, .mem } }, |
| 17121 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 17122 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26154 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26155 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26156 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17123 | 26157 | }, |
| 17124 | 26158 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17125 | 26159 | .ref = .src0, |
| ... | ... | @@ -17138,11 +26172,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17138 | 26172 | .src_constraints = .{ |
| 17139 | 26173 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 17140 | 26174 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 26175 | .any, |
| 17141 | 26176 | }, |
| 17142 | 26177 | .patterns = &.{ |
| 17143 | | .{ .src = .{ .to_sse, .mem } }, |
| 17144 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 17145 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26178 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26179 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26180 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17146 | 26181 | }, |
| 17147 | 26182 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17148 | 26183 | .ref = .src0, |
| ... | ... | @@ -17150,7 +26185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17150 | 26185 | .info = .{ .kind = .all, .scalar = .qword }, |
| 17151 | 26186 | } }}, |
| 17152 | 26187 | .each = .{ .once = &.{ |
| 17153 | | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 26188 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { |
| 17154 | 26189 | else => unreachable, |
| 17155 | 26190 | .e => .eq, |
| 17156 | 26191 | .ne => .neq, |
| ... | ... | @@ -17161,18 +26196,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17161 | 26196 | .src_constraints = .{ |
| 17162 | 26197 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 17163 | 26198 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 26199 | .any, |
| 17164 | 26200 | }, |
| 17165 | 26201 | .patterns = &.{ |
| 17166 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 17167 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 17168 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 26202 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26203 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26204 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17169 | 26205 | }, |
| 17170 | 26206 | .dst_temps = .{.{ .ref_mask = .{ |
| 17171 | 26207 | .ref = .src0, |
| 17172 | 26208 | .info = .{ .kind = .all, .scalar = .qword }, |
| 17173 | 26209 | } }}, |
| 17174 | 26210 | .each = .{ .once = &.{ |
| 17175 | | .{ ._, ._sd, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 26211 | .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) { |
| 17176 | 26212 | else => unreachable, |
| 17177 | 26213 | .e => .eq, |
| 17178 | 26214 | .ne => .neq, |
| ... | ... | @@ -17183,11 +26219,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17183 | 26219 | .src_constraints = .{ |
| 17184 | 26220 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 17185 | 26221 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 26222 | .any, |
| 17186 | 26223 | }, |
| 17187 | 26224 | .patterns = &.{ |
| 17188 | | .{ .src = .{ .to_sse, .mem } }, |
| 17189 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 17190 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26225 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26226 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26227 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17191 | 26228 | }, |
| 17192 | 26229 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17193 | 26230 | .ref = .src0, |
| ... | ... | @@ -17206,18 +26243,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17206 | 26243 | .src_constraints = .{ |
| 17207 | 26244 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 17208 | 26245 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 26246 | .any, |
| 17209 | 26247 | }, |
| 17210 | 26248 | .patterns = &.{ |
| 17211 | | .{ .src = .{ .to_mut_sse, .mem } }, |
| 17212 | | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 17213 | | .{ .src = .{ .to_mut_sse, .to_sse } }, |
| 26249 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26250 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26251 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17214 | 26252 | }, |
| 17215 | 26253 | .dst_temps = .{.{ .ref_mask = .{ |
| 17216 | 26254 | .ref = .src0, |
| 17217 | 26255 | .info = .{ .kind = .all, .scalar = .qword }, |
| 17218 | 26256 | } }}, |
| 17219 | 26257 | .each = .{ .once = &.{ |
| 17220 | | .{ ._, ._pd, .cmp, .dst0x, .src1x, .vp(switch (cc) { |
| 26258 | .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) { |
| 17221 | 26259 | else => unreachable, |
| 17222 | 26260 | .e => .eq, |
| 17223 | 26261 | .ne => .neq, |
| ... | ... | @@ -17228,11 +26266,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17228 | 26266 | .src_constraints = .{ |
| 17229 | 26267 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 17230 | 26268 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 26269 | .any, |
| 17231 | 26270 | }, |
| 17232 | 26271 | .patterns = &.{ |
| 17233 | | .{ .src = .{ .to_sse, .mem } }, |
| 17234 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 17235 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 26272 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26273 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26274 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17236 | 26275 | }, |
| 17237 | 26276 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17238 | 26277 | .ref = .src0, |
| ... | ... | @@ -17251,15 +26290,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17251 | 26290 | .src_constraints = .{ |
| 17252 | 26291 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 17253 | 26292 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 26293 | .any, |
| 17254 | 26294 | }, |
| 17255 | 26295 | .patterns = &.{ |
| 17256 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26296 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17257 | 26297 | }, |
| 17258 | 26298 | .extra_temps = .{ |
| 17259 | 26299 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 17260 | 26300 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 17261 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 17262 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 26301 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 26302 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 17263 | 26303 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 17264 | 26304 | .unused, |
| 17265 | 26305 | .unused, |
| ... | ... | @@ -17289,15 +26329,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17289 | 26329 | .src_constraints = .{ |
| 17290 | 26330 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 17291 | 26331 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 26332 | .any, |
| 17292 | 26333 | }, |
| 17293 | 26334 | .patterns = &.{ |
| 17294 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26335 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17295 | 26336 | }, |
| 17296 | 26337 | .extra_temps = .{ |
| 17297 | 26338 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 17298 | 26339 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 17299 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 17300 | | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, |
| 26340 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 26341 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 17301 | 26342 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 17302 | 26343 | .unused, |
| 17303 | 26344 | .unused, |
| ... | ... | @@ -17327,21 +26368,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17327 | 26368 | .src_constraints = .{ |
| 17328 | 26369 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17329 | 26370 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26371 | .any, |
| 17330 | 26372 | }, |
| 17331 | 26373 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17332 | 26374 | .patterns = &.{ |
| 17333 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26375 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17334 | 26376 | }, |
| 17335 | 26377 | .call_frame = .{ .alignment = .@"16" }, |
| 17336 | 26378 | .extra_temps = .{ |
| 17337 | 26379 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17338 | 26380 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17339 | 26381 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17340 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17341 | | else => unreachable, |
| 17342 | | .e => "__eqhf2", |
| 17343 | | .ne => "__nehf2", |
| 17344 | | } } } }, |
| 26382 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17345 | 26383 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17346 | 26384 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17347 | 26385 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -17372,21 +26410,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17372 | 26410 | .src_constraints = .{ |
| 17373 | 26411 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17374 | 26412 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26413 | .any, |
| 17375 | 26414 | }, |
| 17376 | 26415 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17377 | 26416 | .patterns = &.{ |
| 17378 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26417 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17379 | 26418 | }, |
| 17380 | 26419 | .call_frame = .{ .alignment = .@"16" }, |
| 17381 | 26420 | .extra_temps = .{ |
| 17382 | 26421 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17383 | 26422 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17384 | 26423 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17385 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17386 | | else => unreachable, |
| 17387 | | .e => "__eqhf2", |
| 17388 | | .ne => "__nehf2", |
| 17389 | | } } } }, |
| 26424 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17390 | 26425 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17391 | 26426 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17392 | 26427 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -17417,21 +26452,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17417 | 26452 | .src_constraints = .{ |
| 17418 | 26453 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17419 | 26454 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26455 | .any, |
| 17420 | 26456 | }, |
| 17421 | 26457 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17422 | 26458 | .patterns = &.{ |
| 17423 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26459 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17424 | 26460 | }, |
| 17425 | 26461 | .call_frame = .{ .alignment = .@"16" }, |
| 17426 | 26462 | .extra_temps = .{ |
| 17427 | 26463 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17428 | 26464 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17429 | 26465 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17430 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17431 | | else => unreachable, |
| 17432 | | .e => "__eqhf2", |
| 17433 | | .ne => "__nehf2", |
| 17434 | | } } } }, |
| 26466 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17435 | 26467 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17436 | 26468 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17437 | 26469 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -17463,21 +26495,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17463 | 26495 | .src_constraints = .{ |
| 17464 | 26496 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17465 | 26497 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26498 | .any, |
| 17466 | 26499 | }, |
| 17467 | 26500 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17468 | 26501 | .patterns = &.{ |
| 17469 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26502 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17470 | 26503 | }, |
| 17471 | 26504 | .call_frame = .{ .alignment = .@"16" }, |
| 17472 | 26505 | .extra_temps = .{ |
| 17473 | 26506 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17474 | 26507 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17475 | 26508 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17476 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17477 | | else => unreachable, |
| 17478 | | .e => "__eqhf2", |
| 17479 | | .ne => "__nehf2", |
| 17480 | | } } } }, |
| 26509 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17481 | 26510 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17482 | 26511 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17483 | 26512 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -17509,21 +26538,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17509 | 26538 | .src_constraints = .{ |
| 17510 | 26539 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17511 | 26540 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26541 | .any, |
| 17512 | 26542 | }, |
| 17513 | 26543 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17514 | 26544 | .patterns = &.{ |
| 17515 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26545 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17516 | 26546 | }, |
| 17517 | 26547 | .call_frame = .{ .alignment = .@"16" }, |
| 17518 | 26548 | .extra_temps = .{ |
| 17519 | 26549 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17520 | 26550 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17521 | 26551 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17522 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17523 | | else => unreachable, |
| 17524 | | .e => "__eqhf2", |
| 17525 | | .ne => "__nehf2", |
| 17526 | | } } } }, |
| 26552 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17527 | 26553 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17528 | 26554 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17529 | 26555 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -17557,21 +26583,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17557 | 26583 | .src_constraints = .{ |
| 17558 | 26584 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17559 | 26585 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26586 | .any, |
| 17560 | 26587 | }, |
| 17561 | 26588 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17562 | 26589 | .patterns = &.{ |
| 17563 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26590 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17564 | 26591 | }, |
| 17565 | 26592 | .call_frame = .{ .alignment = .@"16" }, |
| 17566 | 26593 | .extra_temps = .{ |
| 17567 | 26594 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17568 | 26595 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17569 | 26596 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17570 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17571 | | else => unreachable, |
| 17572 | | .e => "__eqhf2", |
| 17573 | | .ne => "__nehf2", |
| 17574 | | } } } }, |
| 26597 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17575 | 26598 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17576 | 26599 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17577 | 26600 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -17605,9 +26628,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17605 | 26628 | .src_constraints = .{ |
| 17606 | 26629 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17607 | 26630 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26631 | .any, |
| 17608 | 26632 | }, |
| 17609 | 26633 | .patterns = &.{ |
| 17610 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26634 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17611 | 26635 | }, |
| 17612 | 26636 | .call_frame = .{ .alignment = .@"16" }, |
| 17613 | 26637 | .extra_temps = .{ |
| ... | ... | @@ -17615,11 +26639,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17615 | 26639 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17616 | 26640 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17617 | 26641 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17618 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17619 | | else => unreachable, |
| 17620 | | .e => "__eqhf2", |
| 17621 | | .ne => "__nehf2", |
| 17622 | | } } } }, |
| 26642 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17623 | 26643 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17624 | 26644 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17625 | 26645 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -17659,9 +26679,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17659 | 26679 | .src_constraints = .{ |
| 17660 | 26680 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17661 | 26681 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26682 | .any, |
| 17662 | 26683 | }, |
| 17663 | 26684 | .patterns = &.{ |
| 17664 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26685 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17665 | 26686 | }, |
| 17666 | 26687 | .call_frame = .{ .alignment = .@"16" }, |
| 17667 | 26688 | .extra_temps = .{ |
| ... | ... | @@ -17669,11 +26690,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17669 | 26690 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17670 | 26691 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17671 | 26692 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17672 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17673 | | else => unreachable, |
| 17674 | | .e => "__eqhf2", |
| 17675 | | .ne => "__nehf2", |
| 17676 | | } } } }, |
| 26693 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17677 | 26694 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17678 | 26695 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17679 | 26696 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -17713,9 +26730,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17713 | 26730 | .src_constraints = .{ |
| 17714 | 26731 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17715 | 26732 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26733 | .any, |
| 17716 | 26734 | }, |
| 17717 | 26735 | .patterns = &.{ |
| 17718 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26736 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17719 | 26737 | }, |
| 17720 | 26738 | .call_frame = .{ .alignment = .@"16" }, |
| 17721 | 26739 | .extra_temps = .{ |
| ... | ... | @@ -17723,11 +26741,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17723 | 26741 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17724 | 26742 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17725 | 26743 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17726 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17727 | | else => unreachable, |
| 17728 | | .e => "__eqhf2", |
| 17729 | | .ne => "__nehf2", |
| 17730 | | } } } }, |
| 26744 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17731 | 26745 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17732 | 26746 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17733 | 26747 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -17768,9 +26782,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17768 | 26782 | .src_constraints = .{ |
| 17769 | 26783 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17770 | 26784 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26785 | .any, |
| 17771 | 26786 | }, |
| 17772 | 26787 | .patterns = &.{ |
| 17773 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26788 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17774 | 26789 | }, |
| 17775 | 26790 | .call_frame = .{ .alignment = .@"16" }, |
| 17776 | 26791 | .extra_temps = .{ |
| ... | ... | @@ -17778,11 +26793,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17778 | 26793 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17779 | 26794 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17780 | 26795 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17781 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17782 | | else => unreachable, |
| 17783 | | .e => "__eqhf2", |
| 17784 | | .ne => "__nehf2", |
| 17785 | | } } } }, |
| 26796 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17786 | 26797 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17787 | 26798 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17788 | 26799 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -17823,9 +26834,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17823 | 26834 | .src_constraints = .{ |
| 17824 | 26835 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17825 | 26836 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26837 | .any, |
| 17826 | 26838 | }, |
| 17827 | 26839 | .patterns = &.{ |
| 17828 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26840 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17829 | 26841 | }, |
| 17830 | 26842 | .call_frame = .{ .alignment = .@"16" }, |
| 17831 | 26843 | .extra_temps = .{ |
| ... | ... | @@ -17833,11 +26845,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17833 | 26845 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17834 | 26846 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17835 | 26847 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17836 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17837 | | else => unreachable, |
| 17838 | | .e => "__eqhf2", |
| 17839 | | .ne => "__nehf2", |
| 17840 | | } } } }, |
| 26848 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17841 | 26849 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17842 | 26850 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17843 | 26851 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -17880,9 +26888,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17880 | 26888 | .src_constraints = .{ |
| 17881 | 26889 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17882 | 26890 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 26891 | .any, |
| 17883 | 26892 | }, |
| 17884 | 26893 | .patterns = &.{ |
| 17885 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26894 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17886 | 26895 | }, |
| 17887 | 26896 | .call_frame = .{ .alignment = .@"16" }, |
| 17888 | 26897 | .extra_temps = .{ |
| ... | ... | @@ -17890,11 +26899,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17890 | 26899 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17891 | 26900 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17892 | 26901 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17893 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 17894 | | else => unreachable, |
| 17895 | | .e => "__eqhf2", |
| 17896 | | .ne => "__nehf2", |
| 17897 | | } } } }, |
| 26902 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17898 | 26903 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17899 | 26904 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17900 | 26905 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -17937,9 +26942,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17937 | 26942 | .src_constraints = .{ |
| 17938 | 26943 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 17939 | 26944 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 26945 | .any, |
| 17940 | 26946 | }, |
| 17941 | 26947 | .patterns = &.{ |
| 17942 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26948 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17943 | 26949 | }, |
| 17944 | 26950 | .extra_temps = .{ |
| 17945 | 26951 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -17974,9 +26980,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17974 | 26980 | .src_constraints = .{ |
| 17975 | 26981 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 17976 | 26982 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 26983 | .any, |
| 17977 | 26984 | }, |
| 17978 | 26985 | .patterns = &.{ |
| 17979 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 26986 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17980 | 26987 | }, |
| 17981 | 26988 | .extra_temps = .{ |
| 17982 | 26989 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18011,9 +27018,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18011 | 27018 | .src_constraints = .{ |
| 18012 | 27019 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 18013 | 27020 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 27021 | .any, |
| 18014 | 27022 | }, |
| 18015 | 27023 | .patterns = &.{ |
| 18016 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27024 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18017 | 27025 | }, |
| 18018 | 27026 | .extra_temps = .{ |
| 18019 | 27027 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18033,12 +27041,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18033 | 27041 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 18034 | 27042 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 18035 | 27043 | .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, |
| 18036 | | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 27044 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 18037 | 27045 | else => unreachable, |
| 18038 | 27046 | .e => .eq, |
| 18039 | 27047 | .ne => .neq, |
| 18040 | 27048 | }), ._ }, |
| 18041 | | .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .vp(switch (cc) { |
| 27049 | .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) { |
| 18042 | 27050 | else => unreachable, |
| 18043 | 27051 | .e => .eq, |
| 18044 | 27052 | .ne => .neq, |
| ... | ... | @@ -18056,9 +27064,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18056 | 27064 | .src_constraints = .{ |
| 18057 | 27065 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 18058 | 27066 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 27067 | .any, |
| 18059 | 27068 | }, |
| 18060 | 27069 | .patterns = &.{ |
| 18061 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27070 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18062 | 27071 | }, |
| 18063 | 27072 | .extra_temps = .{ |
| 18064 | 27073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18077,14 +27086,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18077 | 27086 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 18078 | 27087 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 18079 | 27088 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 18080 | | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 27089 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 18081 | 27090 | else => unreachable, |
| 18082 | 27091 | .e => .eq, |
| 18083 | 27092 | .ne => .neq, |
| 18084 | 27093 | }), ._ }, |
| 18085 | 27094 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, |
| 18086 | 27095 | .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, |
| 18087 | | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .vp(switch (cc) { |
| 27096 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .sp(switch (cc) { |
| 18088 | 27097 | else => unreachable, |
| 18089 | 27098 | .e => .eq, |
| 18090 | 27099 | .ne => .neq, |
| ... | ... | @@ -18102,9 +27111,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18102 | 27111 | .src_constraints = .{ |
| 18103 | 27112 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 18104 | 27113 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 27114 | .any, |
| 18105 | 27115 | }, |
| 18106 | 27116 | .patterns = &.{ |
| 18107 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27117 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18108 | 27118 | }, |
| 18109 | 27119 | .extra_temps = .{ |
| 18110 | 27120 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18124,7 +27134,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18124 | 27134 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 18125 | 27135 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, |
| 18126 | 27136 | .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ }, |
| 18127 | | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .vp(switch (cc) { |
| 27137 | .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .sp(switch (cc) { |
| 18128 | 27138 | else => unreachable, |
| 18129 | 27139 | .e => .eq, |
| 18130 | 27140 | .ne => .neq, |
| ... | ... | @@ -18135,7 +27145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18135 | 27145 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 18136 | 27146 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 18137 | 27147 | .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 18138 | | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 27148 | .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 18139 | 27149 | else => unreachable, |
| 18140 | 27150 | .e => .eq, |
| 18141 | 27151 | .ne => .neq, |
| ... | ... | @@ -18150,9 +27160,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18150 | 27160 | .src_constraints = .{ |
| 18151 | 27161 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 18152 | 27162 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 27163 | .any, |
| 18153 | 27164 | }, |
| 18154 | 27165 | .patterns = &.{ |
| 18155 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27166 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18156 | 27167 | }, |
| 18157 | 27168 | .extra_temps = .{ |
| 18158 | 27169 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18196,9 +27207,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18196 | 27207 | .src_constraints = .{ |
| 18197 | 27208 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 18198 | 27209 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 27210 | .any, |
| 18199 | 27211 | }, |
| 18200 | 27212 | .patterns = &.{ |
| 18201 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27213 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18202 | 27214 | }, |
| 18203 | 27215 | .extra_temps = .{ |
| 18204 | 27216 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18242,9 +27254,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18242 | 27254 | .src_constraints = .{ |
| 18243 | 27255 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 18244 | 27256 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 27257 | .any, |
| 18245 | 27258 | }, |
| 18246 | 27259 | .patterns = &.{ |
| 18247 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27260 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18248 | 27261 | }, |
| 18249 | 27262 | .extra_temps = .{ |
| 18250 | 27263 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18291,9 +27304,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18291 | 27304 | .src_constraints = .{ |
| 18292 | 27305 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 18293 | 27306 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 27307 | .any, |
| 18294 | 27308 | }, |
| 18295 | 27309 | .patterns = &.{ |
| 18296 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27310 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18297 | 27311 | }, |
| 18298 | 27312 | .extra_temps = .{ |
| 18299 | 27313 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18313,7 +27327,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18313 | 27327 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 18314 | 27328 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 18315 | 27329 | .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 18316 | | .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { |
| 27330 | .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .sp(switch (cc) { |
| 18317 | 27331 | else => unreachable, |
| 18318 | 27332 | .e => .eq, |
| 18319 | 27333 | .ne => .neq, |
| ... | ... | @@ -18340,9 +27354,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18340 | 27354 | .src_constraints = .{ |
| 18341 | 27355 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 18342 | 27356 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 27357 | .any, |
| 18343 | 27358 | }, |
| 18344 | 27359 | .patterns = &.{ |
| 18345 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27360 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18346 | 27361 | }, |
| 18347 | 27362 | .extra_temps = .{ |
| 18348 | 27363 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18350,8 +27365,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18350 | 27365 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18351 | 27366 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18352 | 27367 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18353 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 18354 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 27368 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 27369 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 18355 | 27370 | .unused, |
| 18356 | 27371 | .unused, |
| 18357 | 27372 | }, |
| ... | ... | @@ -18399,9 +27414,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18399 | 27414 | .src_constraints = .{ |
| 18400 | 27415 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 18401 | 27416 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 27417 | .any, |
| 18402 | 27418 | }, |
| 18403 | 27419 | .patterns = &.{ |
| 18404 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27420 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18405 | 27421 | }, |
| 18406 | 27422 | .extra_temps = .{ |
| 18407 | 27423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18409,8 +27425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18409 | 27425 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18410 | 27426 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18411 | 27427 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18412 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 18413 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 27428 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 27429 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 18414 | 27430 | .unused, |
| 18415 | 27431 | .unused, |
| 18416 | 27432 | }, |
| ... | ... | @@ -18458,17 +27474,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18458 | 27474 | .src_constraints = .{ |
| 18459 | 27475 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 18460 | 27476 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 27477 | .any, |
| 18461 | 27478 | }, |
| 18462 | 27479 | .patterns = &.{ |
| 18463 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27480 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18464 | 27481 | }, |
| 18465 | 27482 | .extra_temps = .{ |
| 18466 | 27483 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 18467 | 27484 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 18468 | 27485 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18469 | 27486 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18470 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 18471 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 27487 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 27488 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 18472 | 27489 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 18473 | 27490 | .unused, |
| 18474 | 27491 | .unused, |
| ... | ... | @@ -18508,9 +27525,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18508 | 27525 | .src_constraints = .{ |
| 18509 | 27526 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 18510 | 27527 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 27528 | .any, |
| 18511 | 27529 | }, |
| 18512 | 27530 | .patterns = &.{ |
| 18513 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27531 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18514 | 27532 | }, |
| 18515 | 27533 | .extra_temps = .{ |
| 18516 | 27534 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18567,9 +27585,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18567 | 27585 | .src_constraints = .{ |
| 18568 | 27586 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 18569 | 27587 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 27588 | .any, |
| 18570 | 27589 | }, |
| 18571 | 27590 | .patterns = &.{ |
| 18572 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27591 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18573 | 27592 | }, |
| 18574 | 27593 | .extra_temps = .{ |
| 18575 | 27594 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18626,9 +27645,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18626 | 27645 | .src_constraints = .{ |
| 18627 | 27646 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 18628 | 27647 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 27648 | .any, |
| 18629 | 27649 | }, |
| 18630 | 27650 | .patterns = &.{ |
| 18631 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27651 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18632 | 27652 | }, |
| 18633 | 27653 | .extra_temps = .{ |
| 18634 | 27654 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -18676,10 +27696,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18676 | 27696 | .src_constraints = .{ |
| 18677 | 27697 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18678 | 27698 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27699 | .any, |
| 18679 | 27700 | }, |
| 18680 | 27701 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18681 | 27702 | .patterns = &.{ |
| 18682 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27703 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18683 | 27704 | }, |
| 18684 | 27705 | .call_frame = .{ .alignment = .@"16" }, |
| 18685 | 27706 | .extra_temps = .{ |
| ... | ... | @@ -18687,11 +27708,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18687 | 27708 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18688 | 27709 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18689 | 27710 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18690 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18691 | | else => unreachable, |
| 18692 | | .e => "__eqtf2", |
| 18693 | | .ne => "__netf2", |
| 18694 | | } } } }, |
| 27711 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18695 | 27712 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18696 | 27713 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18697 | 27714 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -18721,10 +27738,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18721 | 27738 | .src_constraints = .{ |
| 18722 | 27739 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18723 | 27740 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27741 | .any, |
| 18724 | 27742 | }, |
| 18725 | 27743 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18726 | 27744 | .patterns = &.{ |
| 18727 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27745 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18728 | 27746 | }, |
| 18729 | 27747 | .call_frame = .{ .alignment = .@"16" }, |
| 18730 | 27748 | .extra_temps = .{ |
| ... | ... | @@ -18732,11 +27750,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18732 | 27750 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18733 | 27751 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18734 | 27752 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18735 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18736 | | else => unreachable, |
| 18737 | | .e => "__eqtf2", |
| 18738 | | .ne => "__netf2", |
| 18739 | | } } } }, |
| 27753 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18740 | 27754 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18741 | 27755 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18742 | 27756 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -18766,10 +27780,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18766 | 27780 | .src_constraints = .{ |
| 18767 | 27781 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18768 | 27782 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27783 | .any, |
| 18769 | 27784 | }, |
| 18770 | 27785 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18771 | 27786 | .patterns = &.{ |
| 18772 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27787 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18773 | 27788 | }, |
| 18774 | 27789 | .call_frame = .{ .alignment = .@"16" }, |
| 18775 | 27790 | .extra_temps = .{ |
| ... | ... | @@ -18777,11 +27792,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18777 | 27792 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18778 | 27793 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18779 | 27794 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18780 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18781 | | else => unreachable, |
| 18782 | | .e => "__eqtf2", |
| 18783 | | .ne => "__netf2", |
| 18784 | | } } } }, |
| 27795 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18785 | 27796 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18786 | 27797 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18787 | 27798 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -18811,10 +27822,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18811 | 27822 | .src_constraints = .{ |
| 18812 | 27823 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18813 | 27824 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27825 | .any, |
| 18814 | 27826 | }, |
| 18815 | 27827 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18816 | 27828 | .patterns = &.{ |
| 18817 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27829 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18818 | 27830 | }, |
| 18819 | 27831 | .call_frame = .{ .alignment = .@"16" }, |
| 18820 | 27832 | .extra_temps = .{ |
| ... | ... | @@ -18822,11 +27834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18822 | 27834 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18823 | 27835 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18824 | 27836 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18825 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18826 | | else => unreachable, |
| 18827 | | .e => "__eqtf2", |
| 18828 | | .ne => "__netf2", |
| 18829 | | } } } }, |
| 27837 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18830 | 27838 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18831 | 27839 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18832 | 27840 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -18856,10 +27864,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18856 | 27864 | .src_constraints = .{ |
| 18857 | 27865 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18858 | 27866 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27867 | .any, |
| 18859 | 27868 | }, |
| 18860 | 27869 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18861 | 27870 | .patterns = &.{ |
| 18862 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27871 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18863 | 27872 | }, |
| 18864 | 27873 | .call_frame = .{ .alignment = .@"16" }, |
| 18865 | 27874 | .extra_temps = .{ |
| ... | ... | @@ -18867,11 +27876,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18867 | 27876 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18868 | 27877 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18869 | 27878 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18870 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18871 | | else => unreachable, |
| 18872 | | .e => "__eqtf2", |
| 18873 | | .ne => "__netf2", |
| 18874 | | } } } }, |
| 27879 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18875 | 27880 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18876 | 27881 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18877 | 27882 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -18901,10 +27906,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18901 | 27906 | .src_constraints = .{ |
| 18902 | 27907 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18903 | 27908 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27909 | .any, |
| 18904 | 27910 | }, |
| 18905 | 27911 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18906 | 27912 | .patterns = &.{ |
| 18907 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27913 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18908 | 27914 | }, |
| 18909 | 27915 | .call_frame = .{ .alignment = .@"16" }, |
| 18910 | 27916 | .extra_temps = .{ |
| ... | ... | @@ -18912,11 +27918,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18912 | 27918 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18913 | 27919 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18914 | 27920 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18915 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18916 | | else => unreachable, |
| 18917 | | .e => "__eqtf2", |
| 18918 | | .ne => "__netf2", |
| 18919 | | } } } }, |
| 27921 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18920 | 27922 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18921 | 27923 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18922 | 27924 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | ... | @@ -18946,9 +27948,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18946 | 27948 | .src_constraints = .{ |
| 18947 | 27949 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18948 | 27950 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 27951 | .any, |
| 18949 | 27952 | }, |
| 18950 | 27953 | .patterns = &.{ |
| 18951 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 27954 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18952 | 27955 | }, |
| 18953 | 27956 | .call_frame = .{ .alignment = .@"16" }, |
| 18954 | 27957 | .extra_temps = .{ |
| ... | ... | @@ -18957,11 +27960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18957 | 27960 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 18958 | 27961 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18959 | 27962 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18960 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 18961 | | else => unreachable, |
| 18962 | | .e => "__eqtf2", |
| 18963 | | .ne => "__netf2", |
| 18964 | | } } } }, |
| 27963 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18965 | 27964 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18966 | 27965 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18967 | 27966 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -19000,9 +27999,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19000 | 27999 | .src_constraints = .{ |
| 19001 | 28000 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19002 | 28001 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 28002 | .any, |
| 19003 | 28003 | }, |
| 19004 | 28004 | .patterns = &.{ |
| 19005 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 28005 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19006 | 28006 | }, |
| 19007 | 28007 | .call_frame = .{ .alignment = .@"16" }, |
| 19008 | 28008 | .extra_temps = .{ |
| ... | ... | @@ -19011,11 +28011,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19011 | 28011 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19012 | 28012 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19013 | 28013 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19014 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 19015 | | else => unreachable, |
| 19016 | | .e => "__eqtf2", |
| 19017 | | .ne => "__netf2", |
| 19018 | | } } } }, |
| 28014 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19019 | 28015 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19020 | 28016 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19021 | 28017 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -19054,9 +28050,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19054 | 28050 | .src_constraints = .{ |
| 19055 | 28051 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19056 | 28052 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 28053 | .any, |
| 19057 | 28054 | }, |
| 19058 | 28055 | .patterns = &.{ |
| 19059 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 28056 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19060 | 28057 | }, |
| 19061 | 28058 | .call_frame = .{ .alignment = .@"16" }, |
| 19062 | 28059 | .extra_temps = .{ |
| ... | ... | @@ -19065,11 +28062,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19065 | 28062 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19066 | 28063 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19067 | 28064 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19068 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 19069 | | else => unreachable, |
| 19070 | | .e => "__eqtf2", |
| 19071 | | .ne => "__netf2", |
| 19072 | | } } } }, |
| 28065 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19073 | 28066 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19074 | 28067 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19075 | 28068 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -19108,9 +28101,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19108 | 28101 | .src_constraints = .{ |
| 19109 | 28102 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19110 | 28103 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 28104 | .any, |
| 19111 | 28105 | }, |
| 19112 | 28106 | .patterns = &.{ |
| 19113 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 28107 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19114 | 28108 | }, |
| 19115 | 28109 | .call_frame = .{ .alignment = .@"16" }, |
| 19116 | 28110 | .extra_temps = .{ |
| ... | ... | @@ -19119,11 +28113,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19119 | 28113 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19120 | 28114 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19121 | 28115 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19122 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 19123 | | else => unreachable, |
| 19124 | | .e => "__eqtf2", |
| 19125 | | .ne => "__netf2", |
| 19126 | | } } } }, |
| 28116 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19127 | 28117 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19128 | 28118 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19129 | 28119 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -19162,9 +28152,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19162 | 28152 | .src_constraints = .{ |
| 19163 | 28153 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19164 | 28154 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 28155 | .any, |
| 19165 | 28156 | }, |
| 19166 | 28157 | .patterns = &.{ |
| 19167 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 28158 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19168 | 28159 | }, |
| 19169 | 28160 | .call_frame = .{ .alignment = .@"16" }, |
| 19170 | 28161 | .extra_temps = .{ |
| ... | ... | @@ -19173,11 +28164,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19173 | 28164 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19174 | 28165 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19175 | 28166 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19176 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 19177 | | else => unreachable, |
| 19178 | | .e => "__eqtf2", |
| 19179 | | .ne => "__netf2", |
| 19180 | | } } } }, |
| 28167 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19181 | 28168 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19182 | 28169 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19183 | 28170 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -19216,9 +28203,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19216 | 28203 | .src_constraints = .{ |
| 19217 | 28204 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19218 | 28205 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 28206 | .any, |
| 19219 | 28207 | }, |
| 19220 | 28208 | .patterns = &.{ |
| 19221 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 28209 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19222 | 28210 | }, |
| 19223 | 28211 | .call_frame = .{ .alignment = .@"16" }, |
| 19224 | 28212 | .extra_temps = .{ |
| ... | ... | @@ -19227,11 +28215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19227 | 28215 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19228 | 28216 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19229 | 28217 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19230 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { |
| 19231 | | else => unreachable, |
| 19232 | | .e => "__eqtf2", |
| 19233 | | .ne => "__netf2", |
| 19234 | | } } } }, |
| 28218 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19235 | 28219 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19236 | 28220 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19237 | 28221 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | ... | @@ -19266,31 +28250,1583 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19266 | 28250 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 19267 | 28251 | } }, |
| 19268 | 28252 | } }, |
| 19269 | | }) catch |err| switch (err) { |
| 19270 | | error.SelectFailed => return cg.fail("failed to select {s} {s} {} {} {}", .{ |
| 19271 | | @tagName(air_tag), |
| 19272 | | @tagName(extra.compareOperator()), |
| 19273 | | cg.typeOf(extra.lhs).fmt(pt), |
| 19274 | | ops[0].tracking(cg), |
| 19275 | | ops[1].tracking(cg), |
| 19276 | | }), |
| 19277 | | else => |e| return e, |
| 19278 | | }, |
| 19279 | | .gte => unreachable, |
| 19280 | | .gt => unreachable, |
| 19281 | | } |
| 19282 | | try res[0].finish(inst, &.{ extra.lhs, extra.rhs }, &ops, cg); |
| 28253 | }), |
| 28254 | }) catch |err| switch (err) { |
| 28255 | error.SelectFailed => return cg.fail("failed to select {s} {s} {} {} {}", .{ |
| 28256 | @tagName(air_tag), |
| 28257 | @tagName(extra.compareOperator()), |
| 28258 | cg.typeOf(extra.lhs).fmt(pt), |
| 28259 | ops[0].tracking(cg), |
| 28260 | ops[1].tracking(cg), |
| 28261 | }), |
| 28262 | else => |e| return e, |
| 28263 | }; |
| 28264 | try res[0].finish(inst, &.{ extra.lhs, extra.rhs }, &ops, cg); |
| 28265 | }, |
| 28266 | |
| 28267 | .sqrt => |air_tag| if (use_old) try cg.airSqrt(inst) else { |
| 28268 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 28269 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 28270 | var res: [1]Temp = undefined; |
| 28271 | cg.select(&res, &.{cg.typeOf(un_op)}, &ops, comptime &.{ .{ |
| 28272 | .required_features = .{ .f16c, null, null, null }, |
| 28273 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 28274 | .patterns = &.{ |
| 28275 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28276 | }, |
| 28277 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28278 | .each = .{ .once = &.{ |
| 28279 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 28280 | .{ ._, .v_ss, .sqrt, .dst0x, .dst0x, .dst0d, ._ }, |
| 28281 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 28282 | } }, |
| 28283 | }, .{ |
| 28284 | .required_features = .{ .sse, null, null, null }, |
| 28285 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 28286 | .patterns = &.{ |
| 28287 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 28288 | }, |
| 28289 | .call_frame = .{ .alignment = .@"16" }, |
| 28290 | .extra_temps = .{ |
| 28291 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrth" } } }, |
| 28292 | .unused, |
| 28293 | .unused, |
| 28294 | .unused, |
| 28295 | .unused, |
| 28296 | .unused, |
| 28297 | .unused, |
| 28298 | .unused, |
| 28299 | .unused, |
| 28300 | }, |
| 28301 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28302 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28303 | .each = .{ .once = &.{ |
| 28304 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 28305 | } }, |
| 28306 | }, .{ |
| 28307 | .required_features = .{ .f16c, null, null, null }, |
| 28308 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 28309 | .patterns = &.{ |
| 28310 | .{ .src = .{ .mem, .none, .none } }, |
| 28311 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28312 | }, |
| 28313 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28314 | .each = .{ .once = &.{ |
| 28315 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 28316 | .{ ._, .v_ps, .sqrt, .dst0x, .dst0x, ._, ._ }, |
| 28317 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 28318 | } }, |
| 28319 | }, .{ |
| 28320 | .required_features = .{ .f16c, null, null, null }, |
| 28321 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 28322 | .patterns = &.{ |
| 28323 | .{ .src = .{ .mem, .none, .none } }, |
| 28324 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28325 | }, |
| 28326 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28327 | .each = .{ .once = &.{ |
| 28328 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 28329 | .{ ._, .v_ps, .sqrt, .dst0y, .dst0y, ._, ._ }, |
| 28330 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 28331 | } }, |
| 28332 | }, .{ |
| 28333 | .required_features = .{ .f16c, null, null, null }, |
| 28334 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 28335 | .patterns = &.{ |
| 28336 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28337 | }, |
| 28338 | .extra_temps = .{ |
| 28339 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28340 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 28341 | .unused, |
| 28342 | .unused, |
| 28343 | .unused, |
| 28344 | .unused, |
| 28345 | .unused, |
| 28346 | .unused, |
| 28347 | .unused, |
| 28348 | }, |
| 28349 | .dst_temps = .{.mem}, |
| 28350 | .clobbers = .{ .eflags = true }, |
| 28351 | .each = .{ .once = &.{ |
| 28352 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28353 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28354 | .{ ._, .v_ps, .sqrt, .tmp1y, .tmp1y, ._, ._ }, |
| 28355 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 28356 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 28357 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28358 | } }, |
| 28359 | }, .{ |
| 28360 | .required_features = .{ .avx, null, null, null }, |
| 28361 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 28362 | .patterns = &.{ |
| 28363 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28364 | }, |
| 28365 | .call_frame = .{ .alignment = .@"16" }, |
| 28366 | .extra_temps = .{ |
| 28367 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28368 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 28369 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrth" } } }, |
| 28370 | .unused, |
| 28371 | .unused, |
| 28372 | .unused, |
| 28373 | .unused, |
| 28374 | .unused, |
| 28375 | .unused, |
| 28376 | }, |
| 28377 | .dst_temps = .{.mem}, |
| 28378 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28379 | .each = .{ .once = &.{ |
| 28380 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28381 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 28382 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 28383 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28384 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 28385 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28386 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28387 | } }, |
| 28388 | }, .{ |
| 28389 | .required_features = .{ .sse4_1, null, null, null }, |
| 28390 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 28391 | .patterns = &.{ |
| 28392 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28393 | }, |
| 28394 | .call_frame = .{ .alignment = .@"16" }, |
| 28395 | .extra_temps = .{ |
| 28396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 28398 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrth" } } }, |
| 28399 | .unused, |
| 28400 | .unused, |
| 28401 | .unused, |
| 28402 | .unused, |
| 28403 | .unused, |
| 28404 | .unused, |
| 28405 | }, |
| 28406 | .dst_temps = .{.mem}, |
| 28407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28408 | .each = .{ .once = &.{ |
| 28409 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28410 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 28411 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 28412 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28413 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 28414 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28415 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28416 | } }, |
| 28417 | }, .{ |
| 28418 | .required_features = .{ .sse2, null, null, null }, |
| 28419 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 28420 | .patterns = &.{ |
| 28421 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28422 | }, |
| 28423 | .call_frame = .{ .alignment = .@"16" }, |
| 28424 | .extra_temps = .{ |
| 28425 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28426 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 28427 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrth" } } }, |
| 28428 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 28429 | .unused, |
| 28430 | .unused, |
| 28431 | .unused, |
| 28432 | .unused, |
| 28433 | .unused, |
| 28434 | }, |
| 28435 | .dst_temps = .{.mem}, |
| 28436 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28437 | .each = .{ .once = &.{ |
| 28438 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28439 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 28440 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 28441 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28442 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 28443 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 28444 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28445 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28446 | } }, |
| 28447 | }, .{ |
| 28448 | .required_features = .{ .sse, null, null, null }, |
| 28449 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 28450 | .patterns = &.{ |
| 28451 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28452 | }, |
| 28453 | .call_frame = .{ .alignment = .@"16" }, |
| 28454 | .extra_temps = .{ |
| 28455 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28456 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 28457 | .{ .type = .f32, .kind = .mem }, |
| 28458 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 28459 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrth" } } }, |
| 28460 | .unused, |
| 28461 | .unused, |
| 28462 | .unused, |
| 28463 | .unused, |
| 28464 | }, |
| 28465 | .dst_temps = .{.mem}, |
| 28466 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28467 | .each = .{ .once = &.{ |
| 28468 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28469 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28470 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 28471 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 28472 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 28473 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 28474 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 28475 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 28476 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28477 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28478 | } }, |
| 28479 | }, .{ |
| 28480 | .required_features = .{ .avx, null, null, null }, |
| 28481 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28482 | .patterns = &.{ |
| 28483 | .{ .src = .{ .mem, .none, .none } }, |
| 28484 | }, |
| 28485 | .dst_temps = .{.{ .rc = .sse }}, |
| 28486 | .each = .{ .once = &.{ |
| 28487 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 28488 | .{ ._, .v_ss, .sqrt, .dst0x, .dst0x, .src0d, ._ }, |
| 28489 | } }, |
| 28490 | }, .{ |
| 28491 | .required_features = .{ .avx, null, null, null }, |
| 28492 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28493 | .patterns = &.{ |
| 28494 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28495 | }, |
| 28496 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28497 | .each = .{ .once = &.{ |
| 28498 | .{ ._, .v_ss, .sqrt, .dst0x, .src0x, .src0d, ._ }, |
| 28499 | } }, |
| 28500 | }, .{ |
| 28501 | .required_features = .{ .sse4_1, null, null, null }, |
| 28502 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28503 | .patterns = &.{ |
| 28504 | .{ .src = .{ .mem, .none, .none } }, |
| 28505 | }, |
| 28506 | .dst_temps = .{.{ .rc = .sse }}, |
| 28507 | .each = .{ .once = &.{ |
| 28508 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 28509 | .{ ._, ._ss, .sqrt, .dst0x, .src0d, ._, ._ }, |
| 28510 | } }, |
| 28511 | }, .{ |
| 28512 | .required_features = .{ .sse4_1, null, null, null }, |
| 28513 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28514 | .patterns = &.{ |
| 28515 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28516 | }, |
| 28517 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28518 | .each = .{ .once = &.{ |
| 28519 | .{ ._, ._ss, .sqrt, .dst0x, .src0d, ._, ._ }, |
| 28520 | } }, |
| 28521 | }, .{ |
| 28522 | .required_features = .{ .sse, null, null, null }, |
| 28523 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28524 | .patterns = &.{ |
| 28525 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 28526 | }, |
| 28527 | .call_frame = .{ .alignment = .@"16" }, |
| 28528 | .extra_temps = .{ |
| 28529 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtf" } } }, |
| 28530 | .unused, |
| 28531 | .unused, |
| 28532 | .unused, |
| 28533 | .unused, |
| 28534 | .unused, |
| 28535 | .unused, |
| 28536 | .unused, |
| 28537 | .unused, |
| 28538 | }, |
| 28539 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28540 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28541 | .each = .{ .once = &.{ |
| 28542 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 28543 | } }, |
| 28544 | }, .{ |
| 28545 | .required_features = .{ .avx, null, null, null }, |
| 28546 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 28547 | .patterns = &.{ |
| 28548 | .{ .src = .{ .mem, .none, .none } }, |
| 28549 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28550 | }, |
| 28551 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28552 | .each = .{ .once = &.{ |
| 28553 | .{ ._, .v_ps, .sqrt, .dst0x, .src0x, ._, ._ }, |
| 28554 | } }, |
| 28555 | }, .{ |
| 28556 | .required_features = .{ .sse4_1, null, null, null }, |
| 28557 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 28558 | .patterns = &.{ |
| 28559 | .{ .src = .{ .mem, .none, .none } }, |
| 28560 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28561 | }, |
| 28562 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28563 | .each = .{ .once = &.{ |
| 28564 | .{ ._, ._ps, .sqrt, .dst0x, .src0x, ._, ._ }, |
| 28565 | } }, |
| 28566 | }, .{ |
| 28567 | .required_features = .{ .avx, null, null, null }, |
| 28568 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 28569 | .patterns = &.{ |
| 28570 | .{ .src = .{ .mem, .none, .none } }, |
| 28571 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28572 | }, |
| 28573 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28574 | .each = .{ .once = &.{ |
| 28575 | .{ ._, .v_ps, .sqrt, .dst0y, .src0y, ._, ._ }, |
| 28576 | } }, |
| 28577 | }, .{ |
| 28578 | .required_features = .{ .avx, null, null, null }, |
| 28579 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 28580 | .patterns = &.{ |
| 28581 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28582 | }, |
| 28583 | .extra_temps = .{ |
| 28584 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28585 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 28586 | .unused, |
| 28587 | .unused, |
| 28588 | .unused, |
| 28589 | .unused, |
| 28590 | .unused, |
| 28591 | .unused, |
| 28592 | .unused, |
| 28593 | }, |
| 28594 | .dst_temps = .{.mem}, |
| 28595 | .clobbers = .{ .eflags = true }, |
| 28596 | .each = .{ .once = &.{ |
| 28597 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28598 | .{ .@"0:", .v_ps, .sqrt, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28599 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 28600 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 28601 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28602 | } }, |
| 28603 | }, .{ |
| 28604 | .required_features = .{ .sse4_1, null, null, null }, |
| 28605 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 28606 | .patterns = &.{ |
| 28607 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28608 | }, |
| 28609 | .extra_temps = .{ |
| 28610 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28611 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 28612 | .unused, |
| 28613 | .unused, |
| 28614 | .unused, |
| 28615 | .unused, |
| 28616 | .unused, |
| 28617 | .unused, |
| 28618 | .unused, |
| 28619 | }, |
| 28620 | .dst_temps = .{.mem}, |
| 28621 | .clobbers = .{ .eflags = true }, |
| 28622 | .each = .{ .once = &.{ |
| 28623 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28624 | .{ .@"0:", ._ps, .sqrt, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28625 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28626 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 28627 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28628 | } }, |
| 28629 | }, .{ |
| 28630 | .required_features = .{ .avx, null, null, null }, |
| 28631 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28632 | .patterns = &.{ |
| 28633 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28634 | }, |
| 28635 | .call_frame = .{ .alignment = .@"16" }, |
| 28636 | .extra_temps = .{ |
| 28637 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28638 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 28639 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtf" } } }, |
| 28640 | .unused, |
| 28641 | .unused, |
| 28642 | .unused, |
| 28643 | .unused, |
| 28644 | .unused, |
| 28645 | .unused, |
| 28646 | }, |
| 28647 | .dst_temps = .{.mem}, |
| 28648 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28649 | .each = .{ .once = &.{ |
| 28650 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28651 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28652 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28653 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28654 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28655 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28656 | } }, |
| 28657 | }, .{ |
| 28658 | .required_features = .{ .sse, null, null, null }, |
| 28659 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 28660 | .patterns = &.{ |
| 28661 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28662 | }, |
| 28663 | .call_frame = .{ .alignment = .@"16" }, |
| 28664 | .extra_temps = .{ |
| 28665 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28666 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 28667 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtf" } } }, |
| 28668 | .unused, |
| 28669 | .unused, |
| 28670 | .unused, |
| 28671 | .unused, |
| 28672 | .unused, |
| 28673 | .unused, |
| 28674 | }, |
| 28675 | .dst_temps = .{.mem}, |
| 28676 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28677 | .each = .{ .once = &.{ |
| 28678 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28679 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28680 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28681 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28682 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28683 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28684 | } }, |
| 28685 | }, .{ |
| 28686 | .required_features = .{ .avx, null, null, null }, |
| 28687 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28688 | .patterns = &.{ |
| 28689 | .{ .src = .{ .mem, .none, .none } }, |
| 28690 | }, |
| 28691 | .dst_temps = .{.{ .rc = .sse }}, |
| 28692 | .each = .{ .once = &.{ |
| 28693 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 28694 | .{ ._, .v_sd, .sqrt, .dst0x, .dst0x, .src0q, ._ }, |
| 28695 | } }, |
| 28696 | }, .{ |
| 28697 | .required_features = .{ .avx, null, null, null }, |
| 28698 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28699 | .patterns = &.{ |
| 28700 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28701 | }, |
| 28702 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28703 | .each = .{ .once = &.{ |
| 28704 | .{ ._, .v_sd, .sqrt, .dst0x, .src0x, .src0q, ._ }, |
| 28705 | } }, |
| 28706 | }, .{ |
| 28707 | .required_features = .{ .sse4_1, null, null, null }, |
| 28708 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28709 | .patterns = &.{ |
| 28710 | .{ .src = .{ .mem, .none, .none } }, |
| 28711 | }, |
| 28712 | .dst_temps = .{.{ .rc = .sse }}, |
| 28713 | .each = .{ .once = &.{ |
| 28714 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 28715 | .{ ._, ._sd, .sqrt, .dst0x, .src0q, ._, ._ }, |
| 28716 | } }, |
| 28717 | }, .{ |
| 28718 | .required_features = .{ .sse4_1, null, null, null }, |
| 28719 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28720 | .patterns = &.{ |
| 28721 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28722 | }, |
| 28723 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28724 | .each = .{ .once = &.{ |
| 28725 | .{ ._, ._sd, .sqrt, .dst0x, .src0q, ._, ._ }, |
| 28726 | } }, |
| 28727 | }, .{ |
| 28728 | .required_features = .{ .sse, null, null, null }, |
| 28729 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28730 | .patterns = &.{ |
| 28731 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 28732 | }, |
| 28733 | .call_frame = .{ .alignment = .@"16" }, |
| 28734 | .extra_temps = .{ |
| 28735 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrt" } } }, |
| 28736 | .unused, |
| 28737 | .unused, |
| 28738 | .unused, |
| 28739 | .unused, |
| 28740 | .unused, |
| 28741 | .unused, |
| 28742 | .unused, |
| 28743 | .unused, |
| 28744 | }, |
| 28745 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28746 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28747 | .each = .{ .once = &.{ |
| 28748 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 28749 | } }, |
| 28750 | }, .{ |
| 28751 | .required_features = .{ .avx, null, null, null }, |
| 28752 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 28753 | .patterns = &.{ |
| 28754 | .{ .src = .{ .mem, .none, .none } }, |
| 28755 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28756 | }, |
| 28757 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28758 | .each = .{ .once = &.{ |
| 28759 | .{ ._, .v_pd, .sqrt, .dst0x, .src0x, ._, ._ }, |
| 28760 | } }, |
| 28761 | }, .{ |
| 28762 | .required_features = .{ .sse4_1, null, null, null }, |
| 28763 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 28764 | .patterns = &.{ |
| 28765 | .{ .src = .{ .mem, .none, .none } }, |
| 28766 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28767 | }, |
| 28768 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28769 | .each = .{ .once = &.{ |
| 28770 | .{ ._, ._pd, .sqrt, .dst0x, .src0x, ._, ._ }, |
| 28771 | } }, |
| 28772 | }, .{ |
| 28773 | .required_features = .{ .avx, null, null, null }, |
| 28774 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 28775 | .patterns = &.{ |
| 28776 | .{ .src = .{ .mem, .none, .none } }, |
| 28777 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28778 | }, |
| 28779 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28780 | .each = .{ .once = &.{ |
| 28781 | .{ ._, .v_pd, .sqrt, .dst0y, .src0y, ._, ._ }, |
| 28782 | } }, |
| 28783 | }, .{ |
| 28784 | .required_features = .{ .avx, null, null, null }, |
| 28785 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 28786 | .patterns = &.{ |
| 28787 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28788 | }, |
| 28789 | .extra_temps = .{ |
| 28790 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28791 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 28792 | .unused, |
| 28793 | .unused, |
| 28794 | .unused, |
| 28795 | .unused, |
| 28796 | .unused, |
| 28797 | .unused, |
| 28798 | .unused, |
| 28799 | }, |
| 28800 | .dst_temps = .{.mem}, |
| 28801 | .clobbers = .{ .eflags = true }, |
| 28802 | .each = .{ .once = &.{ |
| 28803 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28804 | .{ .@"0:", .v_pd, .sqrt, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28805 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 28806 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 28807 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28808 | } }, |
| 28809 | }, .{ |
| 28810 | .required_features = .{ .sse4_1, null, null, null }, |
| 28811 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 28812 | .patterns = &.{ |
| 28813 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28814 | }, |
| 28815 | .extra_temps = .{ |
| 28816 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28817 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 28818 | .unused, |
| 28819 | .unused, |
| 28820 | .unused, |
| 28821 | .unused, |
| 28822 | .unused, |
| 28823 | .unused, |
| 28824 | .unused, |
| 28825 | }, |
| 28826 | .dst_temps = .{.mem}, |
| 28827 | .clobbers = .{ .eflags = true }, |
| 28828 | .each = .{ .once = &.{ |
| 28829 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28830 | .{ .@"0:", ._pd, .sqrt, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28831 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28832 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 28833 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28834 | } }, |
| 28835 | }, .{ |
| 28836 | .required_features = .{ .avx, null, null, null }, |
| 28837 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28838 | .patterns = &.{ |
| 28839 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28840 | }, |
| 28841 | .call_frame = .{ .alignment = .@"16" }, |
| 28842 | .extra_temps = .{ |
| 28843 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28844 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 28845 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrt" } } }, |
| 28846 | .unused, |
| 28847 | .unused, |
| 28848 | .unused, |
| 28849 | .unused, |
| 28850 | .unused, |
| 28851 | .unused, |
| 28852 | }, |
| 28853 | .dst_temps = .{.mem}, |
| 28854 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28855 | .each = .{ .once = &.{ |
| 28856 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28857 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28858 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28859 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28860 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28861 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28862 | } }, |
| 28863 | }, .{ |
| 28864 | .required_features = .{ .sse2, null, null, null }, |
| 28865 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28866 | .patterns = &.{ |
| 28867 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28868 | }, |
| 28869 | .call_frame = .{ .alignment = .@"16" }, |
| 28870 | .extra_temps = .{ |
| 28871 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28872 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 28873 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrt" } } }, |
| 28874 | .unused, |
| 28875 | .unused, |
| 28876 | .unused, |
| 28877 | .unused, |
| 28878 | .unused, |
| 28879 | .unused, |
| 28880 | }, |
| 28881 | .dst_temps = .{.mem}, |
| 28882 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28883 | .each = .{ .once = &.{ |
| 28884 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28885 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28886 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28887 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28888 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28889 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28890 | } }, |
| 28891 | }, .{ |
| 28892 | .required_features = .{ .sse, null, null, null }, |
| 28893 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 28894 | .patterns = &.{ |
| 28895 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28896 | }, |
| 28897 | .call_frame = .{ .alignment = .@"16" }, |
| 28898 | .extra_temps = .{ |
| 28899 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28900 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 28901 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrt" } } }, |
| 28902 | .unused, |
| 28903 | .unused, |
| 28904 | .unused, |
| 28905 | .unused, |
| 28906 | .unused, |
| 28907 | .unused, |
| 28908 | }, |
| 28909 | .dst_temps = .{.mem}, |
| 28910 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28911 | .each = .{ .once = &.{ |
| 28912 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28913 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 28914 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28915 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28916 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28917 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28918 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28919 | } }, |
| 28920 | }, .{ |
| 28921 | .required_features = .{ .avx, .x87, null, null }, |
| 28922 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 28923 | .patterns = &.{ |
| 28924 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28925 | }, |
| 28926 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 28927 | .extra_temps = .{ |
| 28928 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 28929 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 28930 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrtx" } } }, |
| 28931 | .unused, |
| 28932 | .unused, |
| 28933 | .unused, |
| 28934 | .unused, |
| 28935 | .unused, |
| 28936 | .unused, |
| 28937 | }, |
| 28938 | .dst_temps = .{.{ .reg = .st0 }}, |
| 28939 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28940 | .each = .{ .once = &.{ |
| 28941 | .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 28942 | .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 28943 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28944 | } }, |
| 28945 | }, .{ |
| 28946 | .required_features = .{ .sse2, .x87, null, null }, |
| 28947 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 28948 | .patterns = &.{ |
| 28949 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28950 | }, |
| 28951 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 28952 | .extra_temps = .{ |
| 28953 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 28954 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 28955 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrtx" } } }, |
| 28956 | .unused, |
| 28957 | .unused, |
| 28958 | .unused, |
| 28959 | .unused, |
| 28960 | .unused, |
| 28961 | .unused, |
| 28962 | }, |
| 28963 | .dst_temps = .{.{ .reg = .st0 }}, |
| 28964 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28965 | .each = .{ .once = &.{ |
| 28966 | .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 28967 | .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 28968 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28969 | } }, |
| 28970 | }, .{ |
| 28971 | .required_features = .{ .sse, .x87, null, null }, |
| 28972 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 28973 | .patterns = &.{ |
| 28974 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28975 | }, |
| 28976 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 28977 | .extra_temps = .{ |
| 28978 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 28979 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 28980 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrtx" } } }, |
| 28981 | .unused, |
| 28982 | .unused, |
| 28983 | .unused, |
| 28984 | .unused, |
| 28985 | .unused, |
| 28986 | .unused, |
| 28987 | }, |
| 28988 | .dst_temps = .{.{ .reg = .st0 }}, |
| 28989 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 28990 | .each = .{ .once = &.{ |
| 28991 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ }, |
| 28992 | .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 28993 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 28994 | } }, |
| 28995 | }, .{ |
| 28996 | .required_features = .{ .avx, .x87, null, null }, |
| 28997 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 28998 | .patterns = &.{ |
| 28999 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29000 | }, |
| 29001 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29002 | .extra_temps = .{ |
| 29003 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29004 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29005 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29006 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrtx" } } }, |
| 29007 | .unused, |
| 29008 | .unused, |
| 29009 | .unused, |
| 29010 | .unused, |
| 29011 | .unused, |
| 29012 | }, |
| 29013 | .dst_temps = .{.mem}, |
| 29014 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29015 | .each = .{ .once = &.{ |
| 29016 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29017 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29018 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 29019 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 29020 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 29021 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 29022 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29023 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29024 | } }, |
| 29025 | }, .{ |
| 29026 | .required_features = .{ .sse2, .x87, null, null }, |
| 29027 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29028 | .patterns = &.{ |
| 29029 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29030 | }, |
| 29031 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29032 | .extra_temps = .{ |
| 29033 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29034 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29035 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29036 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrtx" } } }, |
| 29037 | .unused, |
| 29038 | .unused, |
| 29039 | .unused, |
| 29040 | .unused, |
| 29041 | .unused, |
| 29042 | }, |
| 29043 | .dst_temps = .{.mem}, |
| 29044 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29045 | .each = .{ .once = &.{ |
| 29046 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29047 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29048 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 29049 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 29050 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 29051 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 29052 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29053 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29054 | } }, |
| 29055 | }, .{ |
| 29056 | .required_features = .{ .sse, .x87, null, null }, |
| 29057 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29058 | .patterns = &.{ |
| 29059 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29060 | }, |
| 29061 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29062 | .extra_temps = .{ |
| 29063 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29064 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29065 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29066 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__sqrtx" } } }, |
| 29067 | .unused, |
| 29068 | .unused, |
| 29069 | .unused, |
| 29070 | .unused, |
| 29071 | .unused, |
| 29072 | }, |
| 29073 | .dst_temps = .{.mem}, |
| 29074 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29075 | .each = .{ .once = &.{ |
| 29076 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29077 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29078 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 29079 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 29080 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 29081 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 29082 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29083 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29084 | } }, |
| 29085 | }, .{ |
| 29086 | .required_features = .{ .sse, null, null, null }, |
| 29087 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29088 | .patterns = &.{ |
| 29089 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 29090 | }, |
| 29091 | .call_frame = .{ .alignment = .@"16" }, |
| 29092 | .extra_temps = .{ |
| 29093 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtq" } } }, |
| 29094 | .unused, |
| 29095 | .unused, |
| 29096 | .unused, |
| 29097 | .unused, |
| 29098 | .unused, |
| 29099 | .unused, |
| 29100 | .unused, |
| 29101 | .unused, |
| 29102 | }, |
| 29103 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29104 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29105 | .each = .{ .once = &.{ |
| 29106 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 29107 | } }, |
| 29108 | }, .{ |
| 29109 | .required_features = .{ .avx, null, null, null }, |
| 29110 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29111 | .patterns = &.{ |
| 29112 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29113 | }, |
| 29114 | .call_frame = .{ .alignment = .@"16" }, |
| 29115 | .extra_temps = .{ |
| 29116 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29117 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 29118 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtq" } } }, |
| 29119 | .unused, |
| 29120 | .unused, |
| 29121 | .unused, |
| 29122 | .unused, |
| 29123 | .unused, |
| 29124 | .unused, |
| 29125 | }, |
| 29126 | .dst_temps = .{.mem}, |
| 29127 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29128 | .each = .{ .once = &.{ |
| 29129 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29130 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29131 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29132 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29133 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29134 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29135 | } }, |
| 29136 | }, .{ |
| 29137 | .required_features = .{ .sse2, null, null, null }, |
| 29138 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29139 | .patterns = &.{ |
| 29140 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29141 | }, |
| 29142 | .call_frame = .{ .alignment = .@"16" }, |
| 29143 | .extra_temps = .{ |
| 29144 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29145 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 29146 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtq" } } }, |
| 29147 | .unused, |
| 29148 | .unused, |
| 29149 | .unused, |
| 29150 | .unused, |
| 29151 | .unused, |
| 29152 | .unused, |
| 29153 | }, |
| 29154 | .dst_temps = .{.mem}, |
| 29155 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29156 | .each = .{ .once = &.{ |
| 29157 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29158 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29159 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29160 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29161 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29162 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29163 | } }, |
| 29164 | }, .{ |
| 29165 | .required_features = .{ .sse, null, null, null }, |
| 29166 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29167 | .patterns = &.{ |
| 29168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29169 | }, |
| 29170 | .call_frame = .{ .alignment = .@"16" }, |
| 29171 | .extra_temps = .{ |
| 29172 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29173 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 29174 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "sqrtq" } } }, |
| 29175 | .unused, |
| 29176 | .unused, |
| 29177 | .unused, |
| 29178 | .unused, |
| 29179 | .unused, |
| 29180 | .unused, |
| 29181 | }, |
| 29182 | .dst_temps = .{.mem}, |
| 29183 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29184 | .each = .{ .once = &.{ |
| 29185 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29186 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29187 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29188 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29189 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29190 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29191 | } }, |
| 29192 | } }) catch |err| switch (err) { |
| 29193 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 29194 | @tagName(air_tag), |
| 29195 | cg.typeOf(un_op).fmt(pt), |
| 29196 | ops[0].tracking(cg), |
| 29197 | }), |
| 29198 | else => |e| return e, |
| 29199 | }; |
| 29200 | try res[0].finish(inst, &.{un_op}, &ops, cg); |
| 29201 | }, |
| 29202 | .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| if (use_old) try cg.airUnaryMath(inst, air_tag) else { |
| 29203 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 29204 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 29205 | var res: [1]Temp = undefined; |
| 29206 | cg.select(&res, &.{cg.typeOf(un_op)}, &ops, switch (air_tag) { |
| 29207 | else => unreachable, |
| 29208 | inline .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |name| comptime &.{ .{ |
| 29209 | .required_features = .{ .sse, null, null, null }, |
| 29210 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29211 | .patterns = &.{ |
| 29212 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 29213 | }, |
| 29214 | .call_frame = .{ .alignment = .@"16" }, |
| 29215 | .extra_temps = .{ |
| 29216 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "h" } } }, |
| 29217 | .unused, |
| 29218 | .unused, |
| 29219 | .unused, |
| 29220 | .unused, |
| 29221 | .unused, |
| 29222 | .unused, |
| 29223 | .unused, |
| 29224 | .unused, |
| 29225 | }, |
| 29226 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29227 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29228 | .each = .{ .once = &.{ |
| 29229 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 29230 | } }, |
| 29231 | }, .{ |
| 29232 | .required_features = .{ .avx, null, null, null }, |
| 29233 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29234 | .patterns = &.{ |
| 29235 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29236 | }, |
| 29237 | .call_frame = .{ .alignment = .@"16" }, |
| 29238 | .extra_temps = .{ |
| 29239 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29240 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 29241 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "h" } } }, |
| 29242 | .unused, |
| 29243 | .unused, |
| 29244 | .unused, |
| 29245 | .unused, |
| 29246 | .unused, |
| 29247 | .unused, |
| 29248 | }, |
| 29249 | .dst_temps = .{.mem}, |
| 29250 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29251 | .each = .{ .once = &.{ |
| 29252 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29253 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 29254 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 29255 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29256 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 29257 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 29258 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29259 | } }, |
| 29260 | }, .{ |
| 29261 | .required_features = .{ .sse4_1, null, null, null }, |
| 29262 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29263 | .patterns = &.{ |
| 29264 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29265 | }, |
| 29266 | .call_frame = .{ .alignment = .@"16" }, |
| 29267 | .extra_temps = .{ |
| 29268 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29269 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 29270 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "h" } } }, |
| 29271 | .unused, |
| 29272 | .unused, |
| 29273 | .unused, |
| 29274 | .unused, |
| 29275 | .unused, |
| 29276 | .unused, |
| 29277 | }, |
| 29278 | .dst_temps = .{.mem}, |
| 29279 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29280 | .each = .{ .once = &.{ |
| 29281 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29282 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 29283 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 29284 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29285 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 29286 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 29287 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29288 | } }, |
| 29289 | }, .{ |
| 29290 | .required_features = .{ .sse2, null, null, null }, |
| 29291 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29292 | .patterns = &.{ |
| 29293 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29294 | }, |
| 29295 | .call_frame = .{ .alignment = .@"16" }, |
| 29296 | .extra_temps = .{ |
| 29297 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29298 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 29299 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "h" } } }, |
| 29300 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 29301 | .unused, |
| 29302 | .unused, |
| 29303 | .unused, |
| 29304 | .unused, |
| 29305 | .unused, |
| 29306 | }, |
| 29307 | .dst_temps = .{.mem}, |
| 29308 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29309 | .each = .{ .once = &.{ |
| 29310 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29311 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 29312 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 29313 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29314 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 29315 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 29316 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 29317 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29318 | } }, |
| 29319 | }, .{ |
| 29320 | .required_features = .{ .sse, null, null, null }, |
| 29321 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29322 | .patterns = &.{ |
| 29323 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29324 | }, |
| 29325 | .call_frame = .{ .alignment = .@"16" }, |
| 29326 | .extra_temps = .{ |
| 29327 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29328 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 29329 | .{ .type = .f32, .kind = .mem }, |
| 29330 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 29331 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "h" } } }, |
| 29332 | .unused, |
| 29333 | .unused, |
| 29334 | .unused, |
| 29335 | .unused, |
| 29336 | }, |
| 29337 | .dst_temps = .{.mem}, |
| 29338 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29339 | .each = .{ .once = &.{ |
| 29340 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29341 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29342 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 29343 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 29344 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 29345 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 29346 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 29347 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 29348 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 29349 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29350 | } }, |
| 29351 | }, .{ |
| 29352 | .required_features = .{ .sse, null, null, null }, |
| 29353 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29354 | .patterns = &.{ |
| 29355 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 29356 | }, |
| 29357 | .call_frame = .{ .alignment = .@"16" }, |
| 29358 | .extra_temps = .{ |
| 29359 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "f" } } }, |
| 29360 | .unused, |
| 29361 | .unused, |
| 29362 | .unused, |
| 29363 | .unused, |
| 29364 | .unused, |
| 29365 | .unused, |
| 29366 | .unused, |
| 29367 | .unused, |
| 29368 | }, |
| 29369 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29370 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29371 | .each = .{ .once = &.{ |
| 29372 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 29373 | } }, |
| 29374 | }, .{ |
| 29375 | .required_features = .{ .avx, null, null, null }, |
| 29376 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29377 | .patterns = &.{ |
| 29378 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29379 | }, |
| 29380 | .call_frame = .{ .alignment = .@"16" }, |
| 29381 | .extra_temps = .{ |
| 29382 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29383 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 29384 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "f" } } }, |
| 29385 | .unused, |
| 29386 | .unused, |
| 29387 | .unused, |
| 29388 | .unused, |
| 29389 | .unused, |
| 29390 | .unused, |
| 29391 | }, |
| 29392 | .dst_temps = .{.mem}, |
| 29393 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29394 | .each = .{ .once = &.{ |
| 29395 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29396 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29397 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29398 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29399 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 29400 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29401 | } }, |
| 29402 | }, .{ |
| 29403 | .required_features = .{ .sse, null, null, null }, |
| 29404 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29405 | .patterns = &.{ |
| 29406 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29407 | }, |
| 29408 | .call_frame = .{ .alignment = .@"16" }, |
| 29409 | .extra_temps = .{ |
| 29410 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29411 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 29412 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "f" } } }, |
| 29413 | .unused, |
| 29414 | .unused, |
| 29415 | .unused, |
| 29416 | .unused, |
| 29417 | .unused, |
| 29418 | .unused, |
| 29419 | }, |
| 29420 | .dst_temps = .{.mem}, |
| 29421 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29422 | .each = .{ .once = &.{ |
| 29423 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29424 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29425 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29426 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29427 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 29428 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29429 | } }, |
| 29430 | }, .{ |
| 29431 | .required_features = .{ .sse, null, null, null }, |
| 29432 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29433 | .patterns = &.{ |
| 29434 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 29435 | }, |
| 29436 | .call_frame = .{ .alignment = .@"16" }, |
| 29437 | .extra_temps = .{ |
| 29438 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) } } }, |
| 29439 | .unused, |
| 29440 | .unused, |
| 29441 | .unused, |
| 29442 | .unused, |
| 29443 | .unused, |
| 29444 | .unused, |
| 29445 | .unused, |
| 29446 | .unused, |
| 29447 | }, |
| 29448 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29449 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29450 | .each = .{ .once = &.{ |
| 29451 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 29452 | } }, |
| 29453 | }, .{ |
| 29454 | .required_features = .{ .avx, null, null, null }, |
| 29455 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29456 | .patterns = &.{ |
| 29457 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29458 | }, |
| 29459 | .call_frame = .{ .alignment = .@"16" }, |
| 29460 | .extra_temps = .{ |
| 29461 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29462 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 29463 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) } } }, |
| 29464 | .unused, |
| 29465 | .unused, |
| 29466 | .unused, |
| 29467 | .unused, |
| 29468 | .unused, |
| 29469 | .unused, |
| 29470 | }, |
| 29471 | .dst_temps = .{.mem}, |
| 29472 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29473 | .each = .{ .once = &.{ |
| 29474 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29475 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29476 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29477 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29478 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 29479 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29480 | } }, |
| 29481 | }, .{ |
| 29482 | .required_features = .{ .sse2, null, null, null }, |
| 29483 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29484 | .patterns = &.{ |
| 29485 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29486 | }, |
| 29487 | .call_frame = .{ .alignment = .@"16" }, |
| 29488 | .extra_temps = .{ |
| 29489 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29490 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 29491 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) } } }, |
| 29492 | .unused, |
| 29493 | .unused, |
| 29494 | .unused, |
| 29495 | .unused, |
| 29496 | .unused, |
| 29497 | .unused, |
| 29498 | }, |
| 29499 | .dst_temps = .{.mem}, |
| 29500 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29501 | .each = .{ .once = &.{ |
| 29502 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29503 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29504 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29505 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29506 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 29507 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29508 | } }, |
| 29509 | }, .{ |
| 29510 | .required_features = .{ .sse, null, null, null }, |
| 29511 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29512 | .patterns = &.{ |
| 29513 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29514 | }, |
| 29515 | .call_frame = .{ .alignment = .@"16" }, |
| 29516 | .extra_temps = .{ |
| 29517 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29518 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 29519 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) } } }, |
| 29520 | .unused, |
| 29521 | .unused, |
| 29522 | .unused, |
| 29523 | .unused, |
| 29524 | .unused, |
| 29525 | .unused, |
| 29526 | }, |
| 29527 | .dst_temps = .{.mem}, |
| 29528 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29529 | .each = .{ .once = &.{ |
| 29530 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29531 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 29532 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29533 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29534 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29535 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 29536 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29537 | } }, |
| 29538 | }, .{ |
| 29539 | .required_features = .{ .avx, .x87, null, null }, |
| 29540 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29541 | .patterns = &.{ |
| 29542 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29543 | }, |
| 29544 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29545 | .extra_temps = .{ |
| 29546 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29547 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29548 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "x" } } }, |
| 29549 | .unused, |
| 29550 | .unused, |
| 29551 | .unused, |
| 29552 | .unused, |
| 29553 | .unused, |
| 29554 | .unused, |
| 29555 | }, |
| 29556 | .dst_temps = .{.{ .reg = .st0 }}, |
| 29557 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29558 | .each = .{ .once = &.{ |
| 29559 | .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 29560 | .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 29561 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29562 | } }, |
| 29563 | }, .{ |
| 29564 | .required_features = .{ .sse2, .x87, null, null }, |
| 29565 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29566 | .patterns = &.{ |
| 29567 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29568 | }, |
| 29569 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29570 | .extra_temps = .{ |
| 29571 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29572 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29573 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "x" } } }, |
| 29574 | .unused, |
| 29575 | .unused, |
| 29576 | .unused, |
| 29577 | .unused, |
| 29578 | .unused, |
| 29579 | .unused, |
| 29580 | }, |
| 29581 | .dst_temps = .{.{ .reg = .st0 }}, |
| 29582 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29583 | .each = .{ .once = &.{ |
| 29584 | .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 29585 | .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 29586 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29587 | } }, |
| 29588 | }, .{ |
| 29589 | .required_features = .{ .sse, .x87, null, null }, |
| 29590 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29591 | .patterns = &.{ |
| 29592 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29593 | }, |
| 29594 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29595 | .extra_temps = .{ |
| 29596 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29597 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29598 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "x" } } }, |
| 29599 | .unused, |
| 29600 | .unused, |
| 29601 | .unused, |
| 29602 | .unused, |
| 29603 | .unused, |
| 29604 | .unused, |
| 29605 | }, |
| 29606 | .dst_temps = .{.{ .reg = .st0 }}, |
| 29607 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29608 | .each = .{ .once = &.{ |
| 29609 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ }, |
| 29610 | .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 29611 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29612 | } }, |
| 29613 | }, .{ |
| 29614 | .required_features = .{ .avx, .x87, null, null }, |
| 29615 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29616 | .patterns = &.{ |
| 29617 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29618 | }, |
| 29619 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29620 | .extra_temps = .{ |
| 29621 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29622 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29623 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29624 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "x" } } }, |
| 29625 | .unused, |
| 29626 | .unused, |
| 29627 | .unused, |
| 29628 | .unused, |
| 29629 | .unused, |
| 29630 | }, |
| 29631 | .dst_temps = .{.mem}, |
| 29632 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29633 | .each = .{ .once = &.{ |
| 29634 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29635 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29636 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 29637 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 29638 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 29639 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 29640 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29641 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29642 | } }, |
| 29643 | }, .{ |
| 29644 | .required_features = .{ .sse2, .x87, null, null }, |
| 29645 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29646 | .patterns = &.{ |
| 29647 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29648 | }, |
| 29649 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29650 | .extra_temps = .{ |
| 29651 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29652 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29653 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29654 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "x" } } }, |
| 29655 | .unused, |
| 29656 | .unused, |
| 29657 | .unused, |
| 29658 | .unused, |
| 29659 | .unused, |
| 29660 | }, |
| 29661 | .dst_temps = .{.mem}, |
| 29662 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29663 | .each = .{ .once = &.{ |
| 29664 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29665 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29666 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 29667 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 29668 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 29669 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 29670 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29671 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29672 | } }, |
| 29673 | }, .{ |
| 29674 | .required_features = .{ .sse, .x87, null, null }, |
| 29675 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 29676 | .patterns = &.{ |
| 29677 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29678 | }, |
| 29679 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 29680 | .extra_temps = .{ |
| 29681 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29682 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 29683 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 29684 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__" ++ @tagName(name) ++ "x" } } }, |
| 29685 | .unused, |
| 29686 | .unused, |
| 29687 | .unused, |
| 29688 | .unused, |
| 29689 | .unused, |
| 29690 | }, |
| 29691 | .dst_temps = .{.mem}, |
| 29692 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29693 | .each = .{ .once = &.{ |
| 29694 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29695 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29696 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 29697 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 29698 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 29699 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 29700 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29701 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29702 | } }, |
| 29703 | }, .{ |
| 29704 | .required_features = .{ .sse, null, null, null }, |
| 29705 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29706 | .patterns = &.{ |
| 29707 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 29708 | }, |
| 29709 | .call_frame = .{ .alignment = .@"16" }, |
| 29710 | .extra_temps = .{ |
| 29711 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "q" } } }, |
| 29712 | .unused, |
| 29713 | .unused, |
| 29714 | .unused, |
| 29715 | .unused, |
| 29716 | .unused, |
| 29717 | .unused, |
| 29718 | .unused, |
| 29719 | .unused, |
| 29720 | }, |
| 29721 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29722 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29723 | .each = .{ .once = &.{ |
| 29724 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 29725 | } }, |
| 29726 | }, .{ |
| 29727 | .required_features = .{ .avx, null, null, null }, |
| 29728 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29729 | .patterns = &.{ |
| 29730 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29731 | }, |
| 29732 | .call_frame = .{ .alignment = .@"16" }, |
| 29733 | .extra_temps = .{ |
| 29734 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29735 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 29736 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "q" } } }, |
| 29737 | .unused, |
| 29738 | .unused, |
| 29739 | .unused, |
| 29740 | .unused, |
| 29741 | .unused, |
| 29742 | .unused, |
| 29743 | }, |
| 29744 | .dst_temps = .{.mem}, |
| 29745 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29746 | .each = .{ .once = &.{ |
| 29747 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29748 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29749 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29750 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29751 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29752 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29753 | } }, |
| 29754 | }, .{ |
| 29755 | .required_features = .{ .sse2, null, null, null }, |
| 29756 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29757 | .patterns = &.{ |
| 29758 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29759 | }, |
| 29760 | .call_frame = .{ .alignment = .@"16" }, |
| 29761 | .extra_temps = .{ |
| 29762 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29763 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 29764 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "q" } } }, |
| 29765 | .unused, |
| 29766 | .unused, |
| 29767 | .unused, |
| 29768 | .unused, |
| 29769 | .unused, |
| 29770 | .unused, |
| 29771 | }, |
| 29772 | .dst_temps = .{.mem}, |
| 29773 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29774 | .each = .{ .once = &.{ |
| 29775 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29776 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29777 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29778 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29779 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29780 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29781 | } }, |
| 29782 | }, .{ |
| 29783 | .required_features = .{ .sse, null, null, null }, |
| 29784 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 29785 | .patterns = &.{ |
| 29786 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29787 | }, |
| 29788 | .call_frame = .{ .alignment = .@"16" }, |
| 29789 | .extra_temps = .{ |
| 29790 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29791 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 29792 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = @tagName(name) ++ "q" } } }, |
| 29793 | .unused, |
| 29794 | .unused, |
| 29795 | .unused, |
| 29796 | .unused, |
| 29797 | .unused, |
| 29798 | .unused, |
| 29799 | }, |
| 29800 | .dst_temps = .{.mem}, |
| 29801 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 29802 | .each = .{ .once = &.{ |
| 29803 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 29804 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29805 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 29806 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 29807 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29808 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29809 | } }, |
| 29810 | } }, |
| 29811 | }) catch |err| switch (err) { |
| 29812 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 29813 | @tagName(air_tag), |
| 29814 | cg.typeOf(un_op).fmt(pt), |
| 29815 | ops[0].tracking(cg), |
| 29816 | }), |
| 29817 | else => |e| return e, |
| 29818 | }; |
| 29819 | try res[0].finish(inst, &.{un_op}, &ops, cg); |
| 19283 | 29820 | }, |
| 19284 | | |
| 19285 | 29821 | .abs => |air_tag| if (use_old) try cg.airAbs(inst) else { |
| 19286 | 29822 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 19287 | 29823 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 19288 | 29824 | var res: [1]Temp = undefined; |
| 19289 | 29825 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 19290 | 29826 | .required_features = .{ .cmov, null, null, null }, |
| 19291 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 29827 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 19292 | 29828 | .patterns = &.{ |
| 19293 | | .{ .src = .{ .to_gpr, .none } }, |
| 29829 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19294 | 29830 | }, |
| 19295 | 29831 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19296 | 29832 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19300,9 +29836,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19300 | 29836 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, |
| 19301 | 29837 | } }, |
| 19302 | 29838 | }, .{ |
| 19303 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 29839 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 19304 | 29840 | .patterns = &.{ |
| 19305 | | .{ .src = .{ .mut_mem, .none } }, |
| 29841 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19306 | 29842 | }, |
| 19307 | 29843 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19308 | 29844 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19312,9 +29848,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19312 | 29848 | .{ ._, ._, .neg, .dst0b, ._, ._, ._ }, |
| 19313 | 29849 | } }, |
| 19314 | 29850 | }, .{ |
| 19315 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 29851 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 19316 | 29852 | .patterns = &.{ |
| 19317 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 29853 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19318 | 29854 | }, |
| 19319 | 29855 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19320 | 29856 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19325,9 +29861,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19325 | 29861 | } }, |
| 19326 | 29862 | }, .{ |
| 19327 | 29863 | .required_features = .{ .cmov, null, null, null }, |
| 19328 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 29864 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19329 | 29865 | .patterns = &.{ |
| 19330 | | .{ .src = .{ .mem, .none } }, |
| 29866 | .{ .src = .{ .mem, .none, .none } }, |
| 19331 | 29867 | }, |
| 19332 | 29868 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19333 | 29869 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19338,9 +29874,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19338 | 29874 | } }, |
| 19339 | 29875 | }, .{ |
| 19340 | 29876 | .required_features = .{ .cmov, null, null, null }, |
| 19341 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 29877 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19342 | 29878 | .patterns = &.{ |
| 19343 | | .{ .src = .{ .to_gpr, .none } }, |
| 29879 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19344 | 29880 | }, |
| 19345 | 29881 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19346 | 29882 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19350,9 +29886,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19350 | 29886 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, |
| 19351 | 29887 | } }, |
| 19352 | 29888 | }, .{ |
| 19353 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 29889 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19354 | 29890 | .patterns = &.{ |
| 19355 | | .{ .src = .{ .mut_mem, .none } }, |
| 29891 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19356 | 29892 | }, |
| 19357 | 29893 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19358 | 29894 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19362,9 +29898,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19362 | 29898 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 19363 | 29899 | } }, |
| 19364 | 29900 | }, .{ |
| 19365 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 29901 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19366 | 29902 | .patterns = &.{ |
| 19367 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 29903 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19368 | 29904 | }, |
| 19369 | 29905 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19370 | 29906 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19375,10 +29911,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19375 | 29911 | } }, |
| 19376 | 29912 | }, .{ |
| 19377 | 29913 | .required_features = .{ .cmov, null, null, null }, |
| 19378 | | .src_constraints = .{ .{ .int = .dword }, .any }, |
| 29914 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 19379 | 29915 | .patterns = &.{ |
| 19380 | | .{ .src = .{ .mem, .none } }, |
| 19381 | | .{ .src = .{ .to_gpr, .none } }, |
| 29916 | .{ .src = .{ .mem, .none, .none } }, |
| 29917 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19382 | 29918 | }, |
| 19383 | 29919 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19384 | 29920 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19388,9 +29924,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19388 | 29924 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, |
| 19389 | 29925 | } }, |
| 19390 | 29926 | }, .{ |
| 19391 | | .src_constraints = .{ .{ .int = .dword }, .any }, |
| 29927 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 19392 | 29928 | .patterns = &.{ |
| 19393 | | .{ .src = .{ .mut_mem, .none } }, |
| 29929 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19394 | 29930 | }, |
| 19395 | 29931 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19396 | 29932 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19400,9 +29936,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19400 | 29936 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 19401 | 29937 | } }, |
| 19402 | 29938 | }, .{ |
| 19403 | | .src_constraints = .{ .{ .int = .dword }, .any }, |
| 29939 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 19404 | 29940 | .patterns = &.{ |
| 19405 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 29941 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19406 | 29942 | }, |
| 19407 | 29943 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19408 | 29944 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19413,10 +29949,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19413 | 29949 | } }, |
| 19414 | 29950 | }, .{ |
| 19415 | 29951 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 19416 | | .src_constraints = .{ .{ .int = .qword }, .any }, |
| 29952 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 19417 | 29953 | .patterns = &.{ |
| 19418 | | .{ .src = .{ .mem, .none } }, |
| 19419 | | .{ .src = .{ .to_gpr, .none } }, |
| 29954 | .{ .src = .{ .mem, .none, .none } }, |
| 29955 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19420 | 29956 | }, |
| 19421 | 29957 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19422 | 29958 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19427,9 +29963,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19427 | 29963 | } }, |
| 19428 | 29964 | }, .{ |
| 19429 | 29965 | .required_features = .{ .@"64bit", null, null, null }, |
| 19430 | | .src_constraints = .{ .{ .int = .qword }, .any }, |
| 29966 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 19431 | 29967 | .patterns = &.{ |
| 19432 | | .{ .src = .{ .mut_mem, .none } }, |
| 29968 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19433 | 29969 | }, |
| 19434 | 29970 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19435 | 29971 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19440,9 +29976,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19440 | 29976 | } }, |
| 19441 | 29977 | }, .{ |
| 19442 | 29978 | .required_features = .{ .@"64bit", null, null, null }, |
| 19443 | | .src_constraints = .{ .{ .int = .qword }, .any }, |
| 29979 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 19444 | 29980 | .patterns = &.{ |
| 19445 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 29981 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19446 | 29982 | }, |
| 19447 | 29983 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19448 | 29984 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -19453,9 +29989,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19453 | 29989 | } }, |
| 19454 | 29990 | }, .{ |
| 19455 | 29991 | .required_features = .{ .@"64bit", null, null, null }, |
| 19456 | | .src_constraints = .{ .any_int, .any }, |
| 29992 | .src_constraints = .{ .any_int, .any, .any }, |
| 19457 | 29993 | .patterns = &.{ |
| 19458 | | .{ .src = .{ .to_mem, .none } }, |
| 29994 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19459 | 29995 | }, |
| 19460 | 29996 | .extra_temps = .{ |
| 19461 | 29997 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19486,10 +30022,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19486 | 30022 | } }, |
| 19487 | 30023 | }, .{ |
| 19488 | 30024 | .required_features = .{ .mmx, .ssse3, null, null }, |
| 19489 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 30025 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 19490 | 30026 | .patterns = &.{ |
| 19491 | | .{ .src = .{ .mem, .none } }, |
| 19492 | | .{ .src = .{ .to_mm, .none } }, |
| 30027 | .{ .src = .{ .mem, .none, .none } }, |
| 30028 | .{ .src = .{ .to_mm, .none, .none } }, |
| 19493 | 30029 | }, |
| 19494 | 30030 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, |
| 19495 | 30031 | .each = .{ .once = &.{ |
| ... | ... | @@ -19497,10 +30033,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19497 | 30033 | } }, |
| 19498 | 30034 | }, .{ |
| 19499 | 30035 | .required_features = .{ .mmx, .ssse3, null, null }, |
| 19500 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 30036 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 19501 | 30037 | .patterns = &.{ |
| 19502 | | .{ .src = .{ .mem, .none } }, |
| 19503 | | .{ .src = .{ .to_mm, .none } }, |
| 30038 | .{ .src = .{ .mem, .none, .none } }, |
| 30039 | .{ .src = .{ .to_mm, .none, .none } }, |
| 19504 | 30040 | }, |
| 19505 | 30041 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, |
| 19506 | 30042 | .each = .{ .once = &.{ |
| ... | ... | @@ -19508,10 +30044,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19508 | 30044 | } }, |
| 19509 | 30045 | }, .{ |
| 19510 | 30046 | .required_features = .{ .mmx, .ssse3, null, null }, |
| 19511 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 30047 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 19512 | 30048 | .patterns = &.{ |
| 19513 | | .{ .src = .{ .mem, .none } }, |
| 19514 | | .{ .src = .{ .to_mm, .none } }, |
| 30049 | .{ .src = .{ .mem, .none, .none } }, |
| 30050 | .{ .src = .{ .to_mm, .none, .none } }, |
| 19515 | 30051 | }, |
| 19516 | 30052 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, |
| 19517 | 30053 | .each = .{ .once = &.{ |
| ... | ... | @@ -19519,10 +30055,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19519 | 30055 | } }, |
| 19520 | 30056 | }, .{ |
| 19521 | 30057 | .required_features = .{ .ssse3, null, null, null }, |
| 19522 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 30058 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 19523 | 30059 | .patterns = &.{ |
| 19524 | | .{ .src = .{ .mem, .none } }, |
| 19525 | | .{ .src = .{ .to_sse, .none } }, |
| 30060 | .{ .src = .{ .mem, .none, .none } }, |
| 30061 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19526 | 30062 | }, |
| 19527 | 30063 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19528 | 30064 | .each = .{ .once = &.{ |
| ... | ... | @@ -19530,10 +30066,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19530 | 30066 | } }, |
| 19531 | 30067 | }, .{ |
| 19532 | 30068 | .required_features = .{ .ssse3, null, null, null }, |
| 19533 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30069 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 19534 | 30070 | .patterns = &.{ |
| 19535 | | .{ .src = .{ .mem, .none } }, |
| 19536 | | .{ .src = .{ .to_sse, .none } }, |
| 30071 | .{ .src = .{ .mem, .none, .none } }, |
| 30072 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19537 | 30073 | }, |
| 19538 | 30074 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19539 | 30075 | .each = .{ .once = &.{ |
| ... | ... | @@ -19541,10 +30077,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19541 | 30077 | } }, |
| 19542 | 30078 | }, .{ |
| 19543 | 30079 | .required_features = .{ .ssse3, null, null, null }, |
| 19544 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 30080 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 19545 | 30081 | .patterns = &.{ |
| 19546 | | .{ .src = .{ .mem, .none } }, |
| 19547 | | .{ .src = .{ .to_sse, .none } }, |
| 30082 | .{ .src = .{ .mem, .none, .none } }, |
| 30083 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19548 | 30084 | }, |
| 19549 | 30085 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19550 | 30086 | .each = .{ .once = &.{ |
| ... | ... | @@ -19552,10 +30088,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19552 | 30088 | } }, |
| 19553 | 30089 | }, .{ |
| 19554 | 30090 | .required_features = .{ .avx, null, null, null }, |
| 19555 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 30091 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 19556 | 30092 | .patterns = &.{ |
| 19557 | | .{ .src = .{ .mem, .none } }, |
| 19558 | | .{ .src = .{ .to_sse, .none } }, |
| 30093 | .{ .src = .{ .mem, .none, .none } }, |
| 30094 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19559 | 30095 | }, |
| 19560 | 30096 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19561 | 30097 | .each = .{ .once = &.{ |
| ... | ... | @@ -19563,10 +30099,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19563 | 30099 | } }, |
| 19564 | 30100 | }, .{ |
| 19565 | 30101 | .required_features = .{ .avx, null, null, null }, |
| 19566 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30102 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 19567 | 30103 | .patterns = &.{ |
| 19568 | | .{ .src = .{ .mem, .none } }, |
| 19569 | | .{ .src = .{ .to_sse, .none } }, |
| 30104 | .{ .src = .{ .mem, .none, .none } }, |
| 30105 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19570 | 30106 | }, |
| 19571 | 30107 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19572 | 30108 | .each = .{ .once = &.{ |
| ... | ... | @@ -19574,10 +30110,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19574 | 30110 | } }, |
| 19575 | 30111 | }, .{ |
| 19576 | 30112 | .required_features = .{ .avx, null, null, null }, |
| 19577 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 30113 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 19578 | 30114 | .patterns = &.{ |
| 19579 | | .{ .src = .{ .mem, .none } }, |
| 19580 | | .{ .src = .{ .to_sse, .none } }, |
| 30115 | .{ .src = .{ .mem, .none, .none } }, |
| 30116 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19581 | 30117 | }, |
| 19582 | 30118 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19583 | 30119 | .each = .{ .once = &.{ |
| ... | ... | @@ -19585,10 +30121,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19585 | 30121 | } }, |
| 19586 | 30122 | }, .{ |
| 19587 | 30123 | .required_features = .{ .avx2, null, null, null }, |
| 19588 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 30124 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 19589 | 30125 | .patterns = &.{ |
| 19590 | | .{ .src = .{ .mem, .none } }, |
| 19591 | | .{ .src = .{ .to_sse, .none } }, |
| 30126 | .{ .src = .{ .mem, .none, .none } }, |
| 30127 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19592 | 30128 | }, |
| 19593 | 30129 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19594 | 30130 | .each = .{ .once = &.{ |
| ... | ... | @@ -19596,10 +30132,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19596 | 30132 | } }, |
| 19597 | 30133 | }, .{ |
| 19598 | 30134 | .required_features = .{ .avx2, null, null, null }, |
| 19599 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any }, |
| 30135 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 19600 | 30136 | .patterns = &.{ |
| 19601 | | .{ .src = .{ .mem, .none } }, |
| 19602 | | .{ .src = .{ .to_sse, .none } }, |
| 30137 | .{ .src = .{ .mem, .none, .none } }, |
| 30138 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19603 | 30139 | }, |
| 19604 | 30140 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19605 | 30141 | .each = .{ .once = &.{ |
| ... | ... | @@ -19607,10 +30143,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19607 | 30143 | } }, |
| 19608 | 30144 | }, .{ |
| 19609 | 30145 | .required_features = .{ .avx2, null, null, null }, |
| 19610 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 30146 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 19611 | 30147 | .patterns = &.{ |
| 19612 | | .{ .src = .{ .mem, .none } }, |
| 19613 | | .{ .src = .{ .to_sse, .none } }, |
| 30148 | .{ .src = .{ .mem, .none, .none } }, |
| 30149 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19614 | 30150 | }, |
| 19615 | 30151 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19616 | 30152 | .each = .{ .once = &.{ |
| ... | ... | @@ -19618,9 +30154,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19618 | 30154 | } }, |
| 19619 | 30155 | }, .{ |
| 19620 | 30156 | .required_features = .{ .avx2, null, null, null }, |
| 19621 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 30157 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 19622 | 30158 | .patterns = &.{ |
| 19623 | | .{ .src = .{ .to_mem, .none } }, |
| 30159 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19624 | 30160 | }, |
| 19625 | 30161 | .extra_temps = .{ |
| 19626 | 30162 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19644,9 +30180,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19644 | 30180 | } }, |
| 19645 | 30181 | }, .{ |
| 19646 | 30182 | .required_features = .{ .avx2, null, null, null }, |
| 19647 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any }, |
| 30183 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 19648 | 30184 | .patterns = &.{ |
| 19649 | | .{ .src = .{ .to_mem, .none } }, |
| 30185 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19650 | 30186 | }, |
| 19651 | 30187 | .extra_temps = .{ |
| 19652 | 30188 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19670,9 +30206,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19670 | 30206 | } }, |
| 19671 | 30207 | }, .{ |
| 19672 | 30208 | .required_features = .{ .avx2, null, null, null }, |
| 19673 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 30209 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 19674 | 30210 | .patterns = &.{ |
| 19675 | | .{ .src = .{ .to_mem, .none } }, |
| 30211 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19676 | 30212 | }, |
| 19677 | 30213 | .extra_temps = .{ |
| 19678 | 30214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19696,9 +30232,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19696 | 30232 | } }, |
| 19697 | 30233 | }, .{ |
| 19698 | 30234 | .required_features = .{ .avx, null, null, null }, |
| 19699 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 30235 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 19700 | 30236 | .patterns = &.{ |
| 19701 | | .{ .src = .{ .to_mem, .none } }, |
| 30237 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19702 | 30238 | }, |
| 19703 | 30239 | .extra_temps = .{ |
| 19704 | 30240 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19722,9 +30258,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19722 | 30258 | } }, |
| 19723 | 30259 | }, .{ |
| 19724 | 30260 | .required_features = .{ .avx, null, null, null }, |
| 19725 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30261 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 19726 | 30262 | .patterns = &.{ |
| 19727 | | .{ .src = .{ .to_mem, .none } }, |
| 30263 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19728 | 30264 | }, |
| 19729 | 30265 | .extra_temps = .{ |
| 19730 | 30266 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19748,9 +30284,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19748 | 30284 | } }, |
| 19749 | 30285 | }, .{ |
| 19750 | 30286 | .required_features = .{ .avx, null, null, null }, |
| 19751 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 30287 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 19752 | 30288 | .patterns = &.{ |
| 19753 | | .{ .src = .{ .to_mem, .none } }, |
| 30289 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19754 | 30290 | }, |
| 19755 | 30291 | .extra_temps = .{ |
| 19756 | 30292 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19774,9 +30310,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19774 | 30310 | } }, |
| 19775 | 30311 | }, .{ |
| 19776 | 30312 | .required_features = .{ .ssse3, null, null, null }, |
| 19777 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 30313 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 19778 | 30314 | .patterns = &.{ |
| 19779 | | .{ .src = .{ .to_mem, .none } }, |
| 30315 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19780 | 30316 | }, |
| 19781 | 30317 | .extra_temps = .{ |
| 19782 | 30318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19800,9 +30336,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19800 | 30336 | } }, |
| 19801 | 30337 | }, .{ |
| 19802 | 30338 | .required_features = .{ .ssse3, null, null, null }, |
| 19803 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30339 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 19804 | 30340 | .patterns = &.{ |
| 19805 | | .{ .src = .{ .to_mem, .none } }, |
| 30341 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19806 | 30342 | }, |
| 19807 | 30343 | .extra_temps = .{ |
| 19808 | 30344 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19826,9 +30362,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19826 | 30362 | } }, |
| 19827 | 30363 | }, .{ |
| 19828 | 30364 | .required_features = .{ .ssse3, null, null, null }, |
| 19829 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 30365 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 19830 | 30366 | .patterns = &.{ |
| 19831 | | .{ .src = .{ .to_mem, .none } }, |
| 30367 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19832 | 30368 | }, |
| 19833 | 30369 | .extra_temps = .{ |
| 19834 | 30370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19852,9 +30388,61 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19852 | 30388 | } }, |
| 19853 | 30389 | }, .{ |
| 19854 | 30390 | .required_features = .{ .mmx, .ssse3, null, null }, |
| 19855 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 30391 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 30392 | .patterns = &.{ |
| 30393 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30394 | }, |
| 30395 | .extra_temps = .{ |
| 30396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30397 | .{ .kind = .{ .rc = .sse } }, |
| 30398 | .unused, |
| 30399 | .unused, |
| 30400 | .unused, |
| 30401 | .unused, |
| 30402 | .unused, |
| 30403 | .unused, |
| 30404 | .unused, |
| 30405 | }, |
| 30406 | .dst_temps = .{.mem}, |
| 30407 | .clobbers = .{ .eflags = true }, |
| 30408 | .each = .{ .once = &.{ |
| 30409 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30410 | .{ .@"0:", .p_b, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 30411 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 30412 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30413 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30414 | } }, |
| 30415 | }, .{ |
| 30416 | .required_features = .{ .mmx, .ssse3, null, null }, |
| 30417 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 30418 | .patterns = &.{ |
| 30419 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30420 | }, |
| 30421 | .extra_temps = .{ |
| 30422 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30423 | .{ .kind = .{ .rc = .sse } }, |
| 30424 | .unused, |
| 30425 | .unused, |
| 30426 | .unused, |
| 30427 | .unused, |
| 30428 | .unused, |
| 30429 | .unused, |
| 30430 | .unused, |
| 30431 | }, |
| 30432 | .dst_temps = .{.mem}, |
| 30433 | .clobbers = .{ .eflags = true }, |
| 30434 | .each = .{ .once = &.{ |
| 30435 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30436 | .{ .@"0:", .p_w, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 30437 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 30438 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30439 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30440 | } }, |
| 30441 | }, .{ |
| 30442 | .required_features = .{ .mmx, .ssse3, null, null }, |
| 30443 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 19856 | 30444 | .patterns = &.{ |
| 19857 | | .{ .src = .{ .to_mem, .none } }, |
| 30445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19858 | 30446 | }, |
| 19859 | 30447 | .extra_temps = .{ |
| 19860 | 30448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -19870,21 +30458,498 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19870 | 30458 | .dst_temps = .{.mem}, |
| 19871 | 30459 | .clobbers = .{ .eflags = true }, |
| 19872 | 30460 | .each = .{ .once = &.{ |
| 19873 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 19874 | | .{ .@"0:", .p_b, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 19875 | | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 19876 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 19877 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30461 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30462 | .{ .@"0:", .p_d, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 30463 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 30464 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30465 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30466 | } }, |
| 30467 | }, .{ |
| 30468 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| 30469 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 30470 | .patterns = &.{ |
| 30471 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30472 | }, |
| 30473 | .extra_temps = .{ |
| 30474 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30475 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30476 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30477 | .unused, |
| 30478 | .unused, |
| 30479 | .unused, |
| 30480 | .unused, |
| 30481 | .unused, |
| 30482 | .unused, |
| 30483 | }, |
| 30484 | .dst_temps = .{.mem}, |
| 30485 | .clobbers = .{ .eflags = true }, |
| 30486 | .each = .{ .once = &.{ |
| 30487 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30488 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30489 | .{ ._, ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 30490 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| 30491 | .{ ._, ._s, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 30492 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 30493 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 30494 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30495 | } }, |
| 30496 | }, .{ |
| 30497 | .required_features = .{ .cmov, null, null, null }, |
| 30498 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 30499 | .patterns = &.{ |
| 30500 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30501 | }, |
| 30502 | .extra_temps = .{ |
| 30503 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30504 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30505 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30506 | .unused, |
| 30507 | .unused, |
| 30508 | .unused, |
| 30509 | .unused, |
| 30510 | .unused, |
| 30511 | .unused, |
| 30512 | }, |
| 30513 | .dst_temps = .{.mem}, |
| 30514 | .clobbers = .{ .eflags = true }, |
| 30515 | .each = .{ .once = &.{ |
| 30516 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30517 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30518 | .{ ._, ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 30519 | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| 30520 | .{ ._, ._s, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 30521 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 30522 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30523 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 30524 | } }, |
| 30525 | }, .{ |
| 30526 | .required_features = .{ .slow_incdec, null, null, null }, |
| 30527 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 30528 | .patterns = &.{ |
| 30529 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30530 | }, |
| 30531 | .extra_temps = .{ |
| 30532 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30533 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30534 | .unused, |
| 30535 | .unused, |
| 30536 | .unused, |
| 30537 | .unused, |
| 30538 | .unused, |
| 30539 | .unused, |
| 30540 | .unused, |
| 30541 | }, |
| 30542 | .dst_temps = .{.mem}, |
| 30543 | .clobbers = .{ .eflags = true }, |
| 30544 | .each = .{ .once = &.{ |
| 30545 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30546 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 30547 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| 30548 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 30549 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 30550 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 30551 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 30552 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30553 | } }, |
| 30554 | }, .{ |
| 30555 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 30556 | .patterns = &.{ |
| 30557 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30558 | }, |
| 30559 | .extra_temps = .{ |
| 30560 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30561 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30562 | .unused, |
| 30563 | .unused, |
| 30564 | .unused, |
| 30565 | .unused, |
| 30566 | .unused, |
| 30567 | .unused, |
| 30568 | .unused, |
| 30569 | }, |
| 30570 | .dst_temps = .{.mem}, |
| 30571 | .clobbers = .{ .eflags = true }, |
| 30572 | .each = .{ .once = &.{ |
| 30573 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30574 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 30575 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| 30576 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 30577 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 30578 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 30579 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30580 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 30581 | } }, |
| 30582 | }, .{ |
| 30583 | .required_features = .{ .cmov, null, null, null }, |
| 30584 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 30585 | .patterns = &.{ |
| 30586 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30587 | }, |
| 30588 | .extra_temps = .{ |
| 30589 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30590 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30591 | .unused, |
| 30592 | .unused, |
| 30593 | .unused, |
| 30594 | .unused, |
| 30595 | .unused, |
| 30596 | .unused, |
| 30597 | .unused, |
| 30598 | }, |
| 30599 | .dst_temps = .{.mem}, |
| 30600 | .clobbers = .{ .eflags = true }, |
| 30601 | .each = .{ .once = &.{ |
| 30602 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30603 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30604 | .{ ._, ._, .sub, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 30605 | .{ ._, ._s, .cmov, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 30606 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 30607 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30608 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30609 | } }, |
| 30610 | }, .{ |
| 30611 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 30612 | .patterns = &.{ |
| 30613 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30614 | }, |
| 30615 | .extra_temps = .{ |
| 30616 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30617 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30618 | .unused, |
| 30619 | .unused, |
| 30620 | .unused, |
| 30621 | .unused, |
| 30622 | .unused, |
| 30623 | .unused, |
| 30624 | .unused, |
| 30625 | }, |
| 30626 | .dst_temps = .{.mem}, |
| 30627 | .clobbers = .{ .eflags = true }, |
| 30628 | .each = .{ .once = &.{ |
| 30629 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30630 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 30631 | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, |
| 30632 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 30633 | .{ ._, ._, .neg, .tmp1d, ._, ._, ._ }, |
| 30634 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 30635 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30636 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30637 | } }, |
| 30638 | }, .{ |
| 30639 | .required_features = .{ .cmov, null, null, null }, |
| 30640 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 30641 | .patterns = &.{ |
| 30642 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30643 | }, |
| 30644 | .extra_temps = .{ |
| 30645 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30646 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30647 | .unused, |
| 30648 | .unused, |
| 30649 | .unused, |
| 30650 | .unused, |
| 30651 | .unused, |
| 30652 | .unused, |
| 30653 | .unused, |
| 30654 | }, |
| 30655 | .dst_temps = .{.mem}, |
| 30656 | .clobbers = .{ .eflags = true }, |
| 30657 | .each = .{ .once = &.{ |
| 30658 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30659 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30660 | .{ ._, ._, .sub, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 30661 | .{ ._, ._s, .cmov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 30662 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 30663 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 30664 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30665 | } }, |
| 30666 | }, .{ |
| 30667 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 30668 | .patterns = &.{ |
| 30669 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30670 | }, |
| 30671 | .extra_temps = .{ |
| 30672 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30673 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30674 | .unused, |
| 30675 | .unused, |
| 30676 | .unused, |
| 30677 | .unused, |
| 30678 | .unused, |
| 30679 | .unused, |
| 30680 | .unused, |
| 30681 | }, |
| 30682 | .dst_temps = .{.mem}, |
| 30683 | .clobbers = .{ .eflags = true }, |
| 30684 | .each = .{ .once = &.{ |
| 30685 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30686 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 30687 | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, |
| 30688 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 30689 | .{ ._, ._, .neg, .tmp1d, ._, ._, ._ }, |
| 30690 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 30691 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 30692 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30693 | } }, |
| 30694 | }, .{ |
| 30695 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 30696 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 30697 | .patterns = &.{ |
| 30698 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30699 | }, |
| 30700 | .extra_temps = .{ |
| 30701 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30702 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 30703 | .unused, |
| 30704 | .unused, |
| 30705 | .unused, |
| 30706 | .unused, |
| 30707 | .unused, |
| 30708 | .unused, |
| 30709 | .unused, |
| 30710 | }, |
| 30711 | .dst_temps = .{.mem}, |
| 30712 | .clobbers = .{ .eflags = true }, |
| 30713 | .each = .{ .once = &.{ |
| 30714 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30715 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30716 | .{ ._, ._, .sub, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 30717 | .{ ._, ._s, .cmov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 30718 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 30719 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 30720 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30721 | } }, |
| 30722 | }, .{ |
| 30723 | .required_features = .{ .@"64bit", null, null, null }, |
| 30724 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 30725 | .patterns = &.{ |
| 30726 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30727 | }, |
| 30728 | .extra_temps = .{ |
| 30729 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30730 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 30731 | .unused, |
| 30732 | .unused, |
| 30733 | .unused, |
| 30734 | .unused, |
| 30735 | .unused, |
| 30736 | .unused, |
| 30737 | .unused, |
| 30738 | }, |
| 30739 | .dst_temps = .{.mem}, |
| 30740 | .clobbers = .{ .eflags = true }, |
| 30741 | .each = .{ .once = &.{ |
| 30742 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 30743 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 30744 | .{ ._, ._, .@"test", .tmp1q, .tmp1q, ._, ._ }, |
| 30745 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 30746 | .{ ._, ._, .neg, .tmp1q, ._, ._, ._ }, |
| 30747 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 30748 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 30749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30750 | } }, |
| 30751 | }, .{ |
| 30752 | .required_features = .{ .@"64bit", null, null, null }, |
| 30753 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 30754 | .patterns = &.{ |
| 30755 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30756 | }, |
| 30757 | .extra_temps = .{ |
| 30758 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30759 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30760 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 30761 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30762 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 30763 | .unused, |
| 30764 | .unused, |
| 30765 | .unused, |
| 30766 | .unused, |
| 30767 | }, |
| 30768 | .dst_temps = .{.mem}, |
| 30769 | .clobbers = .{ .eflags = true }, |
| 30770 | .each = .{ .once = &.{ |
| 30771 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 30772 | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size), ._, ._ }, |
| 30773 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_src0_elem_size, -8), ._, ._ }, |
| 30774 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| 30775 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 30776 | .{ .@"1:", ._, .mov, .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, |
| 30777 | .{ ._, ._, .xor, .tmp4q, .tmp2q, ._, ._ }, |
| 30778 | .{ ._, ._r, .sh, .tmp3b, .ui(1), ._, ._ }, |
| 30779 | .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ }, |
| 30780 | .{ ._, ._c, .set, .tmp3b, ._, ._, ._ }, |
| 30781 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, |
| 30782 | .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 8), ._, ._ }, |
| 30783 | .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, |
| 30784 | .{ ._, ._a, .j, .@"1b", ._, ._, ._ }, |
| 30785 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_unaligned_size), ._, ._ }, |
| 30786 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 30787 | } }, |
| 30788 | }, .{ |
| 30789 | .required_features = .{ .avx, null, null, null }, |
| 30790 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30791 | .patterns = &.{ |
| 30792 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30793 | }, |
| 30794 | .extra_temps = .{ |
| 30795 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30796 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 30797 | .unused, |
| 30798 | .unused, |
| 30799 | .unused, |
| 30800 | .unused, |
| 30801 | .unused, |
| 30802 | .unused, |
| 30803 | .unused, |
| 30804 | }, |
| 30805 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30806 | .each = .{ .once = &.{ |
| 30807 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30808 | .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 30809 | } }, |
| 30810 | }, .{ |
| 30811 | .required_features = .{ .sse, null, null, null }, |
| 30812 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30813 | .patterns = &.{ |
| 30814 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30815 | }, |
| 30816 | .extra_temps = .{ |
| 30817 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30818 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 30819 | .unused, |
| 30820 | .unused, |
| 30821 | .unused, |
| 30822 | .unused, |
| 30823 | .unused, |
| 30824 | .unused, |
| 30825 | .unused, |
| 30826 | }, |
| 30827 | .dst_temps = .{.{ .ref = .src0 }}, |
| 30828 | .each = .{ .once = &.{ |
| 30829 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30830 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 30831 | } }, |
| 30832 | }, .{ |
| 30833 | .required_features = .{ .avx, null, null, null }, |
| 30834 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 30835 | .patterns = &.{ |
| 30836 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30837 | }, |
| 30838 | .extra_temps = .{ |
| 30839 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30840 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 30841 | .unused, |
| 30842 | .unused, |
| 30843 | .unused, |
| 30844 | .unused, |
| 30845 | .unused, |
| 30846 | .unused, |
| 30847 | .unused, |
| 30848 | }, |
| 30849 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30850 | .each = .{ .once = &.{ |
| 30851 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30852 | .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 30853 | } }, |
| 30854 | }, .{ |
| 30855 | .required_features = .{ .avx, null, null, null }, |
| 30856 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 30857 | .patterns = &.{ |
| 30858 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30859 | }, |
| 30860 | .extra_temps = .{ |
| 30861 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30862 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 30863 | .unused, |
| 30864 | .unused, |
| 30865 | .unused, |
| 30866 | .unused, |
| 30867 | .unused, |
| 30868 | .unused, |
| 30869 | .unused, |
| 30870 | }, |
| 30871 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30872 | .each = .{ .once = &.{ |
| 30873 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30874 | .{ ._, .v_pd, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 30875 | } }, |
| 30876 | }, .{ |
| 30877 | .required_features = .{ .sse2, null, null, null }, |
| 30878 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 30879 | .patterns = &.{ |
| 30880 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30881 | }, |
| 30882 | .extra_temps = .{ |
| 30883 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30884 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 30885 | .unused, |
| 30886 | .unused, |
| 30887 | .unused, |
| 30888 | .unused, |
| 30889 | .unused, |
| 30890 | .unused, |
| 30891 | .unused, |
| 30892 | }, |
| 30893 | .dst_temps = .{.{ .ref = .src0 }}, |
| 30894 | .each = .{ .once = &.{ |
| 30895 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30896 | .{ ._, ._pd, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 30897 | } }, |
| 30898 | }, .{ |
| 30899 | .required_features = .{ .avx, null, null, null }, |
| 30900 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 30901 | .patterns = &.{ |
| 30902 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30903 | }, |
| 30904 | .extra_temps = .{ |
| 30905 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30906 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 30907 | .unused, |
| 30908 | .unused, |
| 30909 | .unused, |
| 30910 | .unused, |
| 30911 | .unused, |
| 30912 | .unused, |
| 30913 | .unused, |
| 30914 | }, |
| 30915 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30916 | .each = .{ .once = &.{ |
| 30917 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30918 | .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 30919 | } }, |
| 30920 | }, .{ |
| 30921 | .required_features = .{ .x87, null, null, null }, |
| 30922 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 30923 | .patterns = &.{ |
| 30924 | .{ .src = .{ .mem, .none, .none } }, |
| 30925 | .{ .src = .{ .to_x87, .none, .none } }, |
| 30926 | }, |
| 30927 | .extra_temps = .{ |
| 30928 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 30929 | .unused, |
| 30930 | .unused, |
| 30931 | .unused, |
| 30932 | .unused, |
| 30933 | .unused, |
| 30934 | .unused, |
| 30935 | .unused, |
| 30936 | .unused, |
| 30937 | }, |
| 30938 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }}, |
| 30939 | .each = .{ .once = &.{ |
| 30940 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 30941 | .{ ._, .f_, .abs, ._, ._, ._, ._ }, |
| 30942 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 19878 | 30943 | } }, |
| 19879 | 30944 | }, .{ |
| 19880 | | .required_features = .{ .mmx, .ssse3, null, null }, |
| 19881 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 30945 | .required_features = .{ .avx, null, null, null }, |
| 30946 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 19882 | 30947 | .patterns = &.{ |
| 19883 | | .{ .src = .{ .to_mem, .none } }, |
| 30948 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19884 | 30949 | }, |
| 19885 | 30950 | .extra_temps = .{ |
| 19886 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 19887 | | .{ .kind = .{ .rc = .sse } }, |
| 30951 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30952 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 19888 | 30953 | .unused, |
| 19889 | 30954 | .unused, |
| 19890 | 30955 | .unused, |
| ... | ... | @@ -19893,24 +30958,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19893 | 30958 | .unused, |
| 19894 | 30959 | .unused, |
| 19895 | 30960 | }, |
| 19896 | | .dst_temps = .{.mem}, |
| 19897 | | .clobbers = .{ .eflags = true }, |
| 30961 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19898 | 30962 | .each = .{ .once = &.{ |
| 19899 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 19900 | | .{ .@"0:", .p_w, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 19901 | | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 19902 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 19903 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30963 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30964 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 19904 | 30965 | } }, |
| 19905 | 30966 | }, .{ |
| 19906 | | .required_features = .{ .mmx, .ssse3, null, null }, |
| 19907 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 30967 | .required_features = .{ .sse2, null, null, null }, |
| 30968 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 19908 | 30969 | .patterns = &.{ |
| 19909 | | .{ .src = .{ .to_mem, .none } }, |
| 30970 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 19910 | 30971 | }, |
| 19911 | 30972 | .extra_temps = .{ |
| 19912 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 19913 | | .{ .kind = .{ .rc = .sse } }, |
| 30973 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30974 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 19914 | 30975 | .unused, |
| 19915 | 30976 | .unused, |
| 19916 | 30977 | .unused, |
| ... | ... | @@ -19919,25 +30980,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19919 | 30980 | .unused, |
| 19920 | 30981 | .unused, |
| 19921 | 30982 | }, |
| 19922 | | .dst_temps = .{.mem}, |
| 19923 | | .clobbers = .{ .eflags = true }, |
| 30983 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19924 | 30984 | .each = .{ .once = &.{ |
| 19925 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 19926 | | .{ .@"0:", .p_d, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 19927 | | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 19928 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 19929 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30985 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30986 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 19930 | 30987 | } }, |
| 19931 | 30988 | }, .{ |
| 19932 | | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| 19933 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 30989 | .required_features = .{ .sse, null, null, null }, |
| 30990 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 19934 | 30991 | .patterns = &.{ |
| 19935 | | .{ .src = .{ .to_mem, .none } }, |
| 30992 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 19936 | 30993 | }, |
| 19937 | 30994 | .extra_temps = .{ |
| 19938 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 19939 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 19940 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30995 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30996 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 30997 | .unused, |
| 19941 | 30998 | .unused, |
| 19942 | 30999 | .unused, |
| 19943 | 31000 | .unused, |
| ... | ... | @@ -19945,28 +31002,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19945 | 31002 | .unused, |
| 19946 | 31003 | .unused, |
| 19947 | 31004 | }, |
| 19948 | | .dst_temps = .{.mem}, |
| 19949 | | .clobbers = .{ .eflags = true }, |
| 31005 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19950 | 31006 | .each = .{ .once = &.{ |
| 19951 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 19952 | | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 19953 | | .{ ._, ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 19954 | | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| 19955 | | .{ ._, ._s, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 19956 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 19957 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 19958 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31007 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31008 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 19959 | 31009 | } }, |
| 19960 | 31010 | }, .{ |
| 19961 | | .required_features = .{ .cmov, null, null, null }, |
| 19962 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 31011 | .required_features = .{ .avx2, null, null, null }, |
| 31012 | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any }, |
| 19963 | 31013 | .patterns = &.{ |
| 19964 | | .{ .src = .{ .to_mem, .none } }, |
| 31014 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19965 | 31015 | }, |
| 19966 | 31016 | .extra_temps = .{ |
| 19967 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 19968 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 19969 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31017 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 31018 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 31019 | .unused, |
| 19970 | 31020 | .unused, |
| 19971 | 31021 | .unused, |
| 19972 | 31022 | .unused, |
| ... | ... | @@ -19974,27 +31024,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19974 | 31024 | .unused, |
| 19975 | 31025 | .unused, |
| 19976 | 31026 | }, |
| 19977 | | .dst_temps = .{.mem}, |
| 19978 | | .clobbers = .{ .eflags = true }, |
| 31027 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19979 | 31028 | .each = .{ .once = &.{ |
| 19980 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 19981 | | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 19982 | | .{ ._, ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 19983 | | .{ ._, ._, .sub, .tmp1b, .tmp2b, ._, ._ }, |
| 19984 | | .{ ._, ._s, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 19985 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 19986 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 19987 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 31029 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31030 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 19988 | 31031 | } }, |
| 19989 | 31032 | }, .{ |
| 19990 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 19991 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 31033 | .required_features = .{ .avx, null, null, null }, |
| 31034 | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any }, |
| 19992 | 31035 | .patterns = &.{ |
| 19993 | | .{ .src = .{ .to_mem, .none } }, |
| 31036 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19994 | 31037 | }, |
| 19995 | 31038 | .extra_temps = .{ |
| 19996 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 19997 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31039 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 31040 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 19998 | 31041 | .unused, |
| 19999 | 31042 | .unused, |
| 20000 | 31043 | .unused, |
| ... | ... | @@ -20003,28 +31046,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20003 | 31046 | .unused, |
| 20004 | 31047 | .unused, |
| 20005 | 31048 | }, |
| 20006 | | .dst_temps = .{.mem}, |
| 20007 | | .clobbers = .{ .eflags = true }, |
| 31049 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20008 | 31050 | .each = .{ .once = &.{ |
| 20009 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20010 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 20011 | | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| 20012 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 20013 | | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 20014 | | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 20015 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 20016 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31051 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31052 | .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 20017 | 31053 | } }, |
| 20018 | 31054 | }, .{ |
| 20019 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 31055 | .required_features = .{ .avx, null, null, null }, |
| 31056 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 20020 | 31057 | .patterns = &.{ |
| 20021 | | .{ .src = .{ .to_mem, .none } }, |
| 31058 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20022 | 31059 | }, |
| 20023 | 31060 | .extra_temps = .{ |
| 20024 | 31061 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20025 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 20026 | | .unused, |
| 20027 | | .unused, |
| 31062 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 31063 | .{ .kind = .{ .rc = .sse } }, |
| 31064 | .{ .kind = .{ .rc = .sse } }, |
| 20028 | 31065 | .unused, |
| 20029 | 31066 | .unused, |
| 20030 | 31067 | .unused, |
| ... | ... | @@ -20032,28 +31069,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20032 | 31069 | .unused, |
| 20033 | 31070 | }, |
| 20034 | 31071 | .dst_temps = .{.mem}, |
| 20035 | | .clobbers = .{ .eflags = true }, |
| 20036 | 31072 | .each = .{ .once = &.{ |
| 31073 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31074 | .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20037 | 31075 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20038 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, |
| 20039 | | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| 20040 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 20041 | | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 20042 | | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, |
| 20043 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 20044 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 31076 | .{ .@"0:", .v_ps, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 31077 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 31078 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 31079 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20045 | 31080 | } }, |
| 20046 | 31081 | }, .{ |
| 20047 | | .required_features = .{ .cmov, null, null, null }, |
| 20048 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 31082 | .required_features = .{ .sse, null, null, null }, |
| 31083 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 20049 | 31084 | .patterns = &.{ |
| 20050 | | .{ .src = .{ .to_mem, .none } }, |
| 31085 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20051 | 31086 | }, |
| 20052 | 31087 | .extra_temps = .{ |
| 20053 | 31088 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20054 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 20055 | | .unused, |
| 20056 | | .unused, |
| 31089 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 31090 | .{ .kind = .{ .rc = .sse } }, |
| 31091 | .{ .kind = .{ .rc = .sse } }, |
| 20057 | 31092 | .unused, |
| 20058 | 31093 | .unused, |
| 20059 | 31094 | .unused, |
| ... | ... | @@ -20061,26 +31096,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20061 | 31096 | .unused, |
| 20062 | 31097 | }, |
| 20063 | 31098 | .dst_temps = .{.mem}, |
| 20064 | | .clobbers = .{ .eflags = true }, |
| 20065 | 31099 | .each = .{ .once = &.{ |
| 31100 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31101 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20066 | 31102 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20067 | | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 20068 | | .{ ._, ._, .sub, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 20069 | | .{ ._, ._s, .cmov, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 20070 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 20071 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31103 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 31104 | .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 31105 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 31106 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20072 | 31107 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20073 | 31108 | } }, |
| 20074 | 31109 | }, .{ |
| 20075 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 31110 | .required_features = .{ .avx, null, null, null }, |
| 31111 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 20076 | 31112 | .patterns = &.{ |
| 20077 | | .{ .src = .{ .to_mem, .none } }, |
| 31113 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20078 | 31114 | }, |
| 20079 | 31115 | .extra_temps = .{ |
| 20080 | 31116 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20081 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 20082 | | .unused, |
| 20083 | | .unused, |
| 31117 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 31118 | .{ .kind = .{ .rc = .sse } }, |
| 31119 | .{ .kind = .{ .rc = .sse } }, |
| 20084 | 31120 | .unused, |
| 20085 | 31121 | .unused, |
| 20086 | 31122 | .unused, |
| ... | ... | @@ -20088,28 +31124,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20088 | 31124 | .unused, |
| 20089 | 31125 | }, |
| 20090 | 31126 | .dst_temps = .{.mem}, |
| 20091 | | .clobbers = .{ .eflags = true }, |
| 20092 | 31127 | .each = .{ .once = &.{ |
| 31128 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31129 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20093 | 31130 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20094 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 20095 | | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, |
| 20096 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 20097 | | .{ ._, ._, .neg, .tmp1d, ._, ._, ._ }, |
| 20098 | | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, |
| 20099 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31131 | .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 31132 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 31133 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20100 | 31134 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20101 | 31135 | } }, |
| 20102 | 31136 | }, .{ |
| 20103 | | .required_features = .{ .cmov, null, null, null }, |
| 20104 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31137 | .required_features = .{ .sse2, null, null, null }, |
| 31138 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 20105 | 31139 | .patterns = &.{ |
| 20106 | | .{ .src = .{ .to_mem, .none } }, |
| 31140 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20107 | 31141 | }, |
| 20108 | 31142 | .extra_temps = .{ |
| 20109 | 31143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20110 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 20111 | | .unused, |
| 20112 | | .unused, |
| 31144 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 31145 | .{ .kind = .{ .rc = .sse } }, |
| 31146 | .{ .kind = .{ .rc = .sse } }, |
| 20113 | 31147 | .unused, |
| 20114 | 31148 | .unused, |
| 20115 | 31149 | .unused, |
| ... | ... | @@ -20117,26 +31151,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20117 | 31151 | .unused, |
| 20118 | 31152 | }, |
| 20119 | 31153 | .dst_temps = .{.mem}, |
| 20120 | | .clobbers = .{ .eflags = true }, |
| 20121 | 31154 | .each = .{ .once = &.{ |
| 31155 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31156 | .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20122 | 31157 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20123 | | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 20124 | | .{ ._, ._, .sub, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 20125 | | .{ ._, ._s, .cmov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 20126 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 20127 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31158 | .{ .@"0:", ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 31159 | .{ ._, ._pd, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 31160 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 31161 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20128 | 31162 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20129 | 31163 | } }, |
| 20130 | 31164 | }, .{ |
| 20131 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31165 | .required_features = .{ .avx2, null, null, null }, |
| 31166 | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any }, |
| 20132 | 31167 | .patterns = &.{ |
| 20133 | | .{ .src = .{ .to_mem, .none } }, |
| 31168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20134 | 31169 | }, |
| 20135 | 31170 | .extra_temps = .{ |
| 20136 | 31171 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20137 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 20138 | | .unused, |
| 20139 | | .unused, |
| 31172 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 31173 | .{ .kind = .{ .rc = .sse } }, |
| 31174 | .{ .kind = .{ .rc = .sse } }, |
| 20140 | 31175 | .unused, |
| 20141 | 31176 | .unused, |
| 20142 | 31177 | .unused, |
| ... | ... | @@ -20144,28 +31179,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20144 | 31179 | .unused, |
| 20145 | 31180 | }, |
| 20146 | 31181 | .dst_temps = .{.mem}, |
| 20147 | | .clobbers = .{ .eflags = true }, |
| 20148 | 31182 | .each = .{ .once = &.{ |
| 31183 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31184 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20149 | 31185 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20150 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 20151 | | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, |
| 20152 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 20153 | | .{ ._, ._, .neg, .tmp1d, ._, ._, ._ }, |
| 20154 | | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, |
| 20155 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31186 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 31187 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 31188 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20156 | 31189 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20157 | 31190 | } }, |
| 20158 | 31191 | }, .{ |
| 20159 | | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 20160 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31192 | .required_features = .{ .avx, null, null, null }, |
| 31193 | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any }, |
| 20161 | 31194 | .patterns = &.{ |
| 20162 | | .{ .src = .{ .to_mem, .none } }, |
| 31195 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20163 | 31196 | }, |
| 20164 | 31197 | .extra_temps = .{ |
| 20165 | 31198 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20166 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 20167 | | .unused, |
| 20168 | | .unused, |
| 31199 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 31200 | .{ .kind = .{ .rc = .sse } }, |
| 31201 | .{ .kind = .{ .rc = .sse } }, |
| 20169 | 31202 | .unused, |
| 20170 | 31203 | .unused, |
| 20171 | 31204 | .unused, |
| ... | ... | @@ -20173,27 +31206,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20173 | 31206 | .unused, |
| 20174 | 31207 | }, |
| 20175 | 31208 | .dst_temps = .{.mem}, |
| 20176 | | .clobbers = .{ .eflags = true }, |
| 20177 | 31209 | .each = .{ .once = &.{ |
| 31210 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31211 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20178 | 31212 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20179 | | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 20180 | | .{ ._, ._, .sub, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 20181 | | .{ ._, ._s, .cmov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 20182 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 20183 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 31213 | .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 31214 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 31215 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20184 | 31216 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20185 | 31217 | } }, |
| 20186 | 31218 | }, .{ |
| 20187 | | .required_features = .{ .@"64bit", null, null, null }, |
| 20188 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31219 | .required_features = .{ .sse2, null, null, null }, |
| 31220 | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any }, |
| 20189 | 31221 | .patterns = &.{ |
| 20190 | | .{ .src = .{ .to_mem, .none } }, |
| 31222 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20191 | 31223 | }, |
| 20192 | 31224 | .extra_temps = .{ |
| 20193 | 31225 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20194 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 20195 | | .unused, |
| 20196 | | .unused, |
| 31226 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 31227 | .{ .kind = .{ .rc = .sse } }, |
| 31228 | .{ .kind = .{ .rc = .sse } }, |
| 20197 | 31229 | .unused, |
| 20198 | 31230 | .unused, |
| 20199 | 31231 | .unused, |
| ... | ... | @@ -20201,63 +31233,1137 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20201 | 31233 | .unused, |
| 20202 | 31234 | }, |
| 20203 | 31235 | .dst_temps = .{.mem}, |
| 20204 | | .clobbers = .{ .eflags = true }, |
| 20205 | 31236 | .each = .{ .once = &.{ |
| 31237 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31238 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20206 | 31239 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20207 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 20208 | | .{ ._, ._, .@"test", .tmp1q, .tmp1q, ._, ._ }, |
| 20209 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 20210 | | .{ ._, ._, .neg, .tmp1q, ._, ._, ._ }, |
| 20211 | | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 20212 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 31240 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 31241 | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 31242 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 31243 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20213 | 31244 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20214 | 31245 | } }, |
| 20215 | 31246 | }, .{ |
| 20216 | | .required_features = .{ .@"64bit", null, null, null }, |
| 20217 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 31247 | .required_features = .{ .sse, null, null, null }, |
| 31248 | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any }, |
| 20218 | 31249 | .patterns = &.{ |
| 20219 | | .{ .src = .{ .to_mem, .none } }, |
| 31250 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20220 | 31251 | }, |
| 20221 | 31252 | .extra_temps = .{ |
| 20222 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20223 | 31253 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20224 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 20225 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 20226 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 31254 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 31255 | .{ .kind = .{ .rc = .sse } }, |
| 31256 | .{ .kind = .{ .rc = .sse } }, |
| 31257 | .unused, |
| 20227 | 31258 | .unused, |
| 20228 | 31259 | .unused, |
| 20229 | 31260 | .unused, |
| 20230 | 31261 | .unused, |
| 20231 | 31262 | }, |
| 20232 | 31263 | .dst_temps = .{.mem}, |
| 20233 | | .clobbers = .{ .eflags = true }, |
| 20234 | 31264 | .each = .{ .once = &.{ |
| 20235 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 20236 | | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size), ._, ._ }, |
| 20237 | | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_src0_elem_size, -8), ._, ._ }, |
| 20238 | | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| 20239 | | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 20240 | | .{ .@"1:", ._, .mov, .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, |
| 20241 | | .{ ._, ._, .xor, .tmp4q, .tmp2q, ._, ._ }, |
| 20242 | | .{ ._, ._r, .sh, .tmp3b, .ui(1), ._, ._ }, |
| 20243 | | .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ }, |
| 20244 | | .{ ._, ._c, .set, .tmp3b, ._, ._, ._ }, |
| 20245 | | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, |
| 20246 | | .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 8), ._, ._ }, |
| 20247 | | .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, |
| 20248 | | .{ ._, ._a, .j, .@"1b", ._, ._, ._ }, |
| 20249 | | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_unaligned_size), ._, ._ }, |
| 20250 | | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, |
| 31265 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31266 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 31267 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 31268 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 31269 | .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 31270 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 31271 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31272 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31273 | } }, |
| 31274 | } }) catch |err| switch (err) { |
| 31275 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 31276 | @tagName(air_tag), |
| 31277 | cg.typeOf(ty_op.operand).fmt(pt), |
| 31278 | ops[0].tracking(cg), |
| 31279 | }), |
| 31280 | else => |e| return e, |
| 31281 | }; |
| 31282 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 31283 | }, |
| 31284 | .floor, .ceil, .trunc_float => |air_tag| if (use_old) try cg.airRound(inst, .{ .direction = switch (air_tag) { |
| 31285 | else => unreachable, |
| 31286 | .floor => .down, |
| 31287 | .ceil => .up, |
| 31288 | .trunc_float => .zero, |
| 31289 | }, .precision = .inexact }) else { |
| 31290 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 31291 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 31292 | var res: [1]Temp = undefined; |
| 31293 | cg.select(&res, &.{cg.typeOf(un_op)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) { |
| 31294 | else => unreachable, |
| 31295 | .floor => .down, |
| 31296 | .ceil => .up, |
| 31297 | .trunc_float => .zero, |
| 31298 | })) { |
| 31299 | else => unreachable, |
| 31300 | inline .down, .up, .zero => |direction| comptime &.{ .{ |
| 31301 | .required_features = .{ .f16c, null, null, null }, |
| 31302 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 31303 | .patterns = &.{ |
| 31304 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31305 | }, |
| 31306 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31307 | .each = .{ .once = &.{ |
| 31308 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 31309 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 31310 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 31311 | } }, |
| 31312 | }, .{ |
| 31313 | .required_features = .{ .sse, null, null, null }, |
| 31314 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 31315 | .patterns = &.{ |
| 31316 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 31317 | }, |
| 31318 | .call_frame = .{ .alignment = .@"16" }, |
| 31319 | .extra_temps = .{ |
| 31320 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31321 | else => unreachable, |
| 31322 | .down => "__floorh", |
| 31323 | .up => "__ceilh", |
| 31324 | .zero => "__trunch", |
| 31325 | } } } }, |
| 31326 | .unused, |
| 31327 | .unused, |
| 31328 | .unused, |
| 31329 | .unused, |
| 31330 | .unused, |
| 31331 | .unused, |
| 31332 | .unused, |
| 31333 | .unused, |
| 31334 | }, |
| 31335 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31336 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31337 | .each = .{ .once = &.{ |
| 31338 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 31339 | } }, |
| 31340 | }, .{ |
| 31341 | .required_features = .{ .f16c, null, null, null }, |
| 31342 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 31343 | .patterns = &.{ |
| 31344 | .{ .src = .{ .mem, .none, .none } }, |
| 31345 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31346 | }, |
| 31347 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31348 | .each = .{ .once = &.{ |
| 31349 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 31350 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31351 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 31352 | } }, |
| 31353 | }, .{ |
| 31354 | .required_features = .{ .f16c, null, null, null }, |
| 31355 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 31356 | .patterns = &.{ |
| 31357 | .{ .src = .{ .mem, .none, .none } }, |
| 31358 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31359 | }, |
| 31360 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31361 | .each = .{ .once = &.{ |
| 31362 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 31363 | .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31364 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 31365 | } }, |
| 31366 | }, .{ |
| 31367 | .required_features = .{ .f16c, null, null, null }, |
| 31368 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 31369 | .patterns = &.{ |
| 31370 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31371 | }, |
| 31372 | .extra_temps = .{ |
| 31373 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31374 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 31375 | .unused, |
| 31376 | .unused, |
| 31377 | .unused, |
| 31378 | .unused, |
| 31379 | .unused, |
| 31380 | .unused, |
| 31381 | .unused, |
| 31382 | }, |
| 31383 | .dst_temps = .{.mem}, |
| 31384 | .clobbers = .{ .eflags = true }, |
| 31385 | .each = .{ .once = &.{ |
| 31386 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31387 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31388 | .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31389 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 31390 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31391 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31392 | } }, |
| 31393 | }, .{ |
| 31394 | .required_features = .{ .avx, null, null, null }, |
| 31395 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 31396 | .patterns = &.{ |
| 31397 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31398 | }, |
| 31399 | .call_frame = .{ .alignment = .@"16" }, |
| 31400 | .extra_temps = .{ |
| 31401 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31402 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 31403 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31404 | else => unreachable, |
| 31405 | .down => "__floorh", |
| 31406 | .up => "__ceilh", |
| 31407 | .zero => "__trunch", |
| 31408 | } } } }, |
| 31409 | .unused, |
| 31410 | .unused, |
| 31411 | .unused, |
| 31412 | .unused, |
| 31413 | .unused, |
| 31414 | .unused, |
| 31415 | }, |
| 31416 | .dst_temps = .{.mem}, |
| 31417 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31418 | .each = .{ .once = &.{ |
| 31419 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31420 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 31421 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 31422 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31423 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 31424 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31425 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31426 | } }, |
| 31427 | }, .{ |
| 31428 | .required_features = .{ .sse4_1, null, null, null }, |
| 31429 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 31430 | .patterns = &.{ |
| 31431 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31432 | }, |
| 31433 | .call_frame = .{ .alignment = .@"16" }, |
| 31434 | .extra_temps = .{ |
| 31435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31436 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 31437 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31438 | else => unreachable, |
| 31439 | .down => "__floorh", |
| 31440 | .up => "__ceilh", |
| 31441 | .zero => "__trunch", |
| 31442 | } } } }, |
| 31443 | .unused, |
| 31444 | .unused, |
| 31445 | .unused, |
| 31446 | .unused, |
| 31447 | .unused, |
| 31448 | .unused, |
| 31449 | }, |
| 31450 | .dst_temps = .{.mem}, |
| 31451 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31452 | .each = .{ .once = &.{ |
| 31453 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31454 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 31455 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 31456 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31457 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 31458 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31459 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31460 | } }, |
| 31461 | }, .{ |
| 31462 | .required_features = .{ .sse2, null, null, null }, |
| 31463 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 31464 | .patterns = &.{ |
| 31465 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31466 | }, |
| 31467 | .call_frame = .{ .alignment = .@"16" }, |
| 31468 | .extra_temps = .{ |
| 31469 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31470 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 31471 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31472 | else => unreachable, |
| 31473 | .down => "__floorh", |
| 31474 | .up => "__ceilh", |
| 31475 | .zero => "__trunch", |
| 31476 | } } } }, |
| 31477 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 31478 | .unused, |
| 31479 | .unused, |
| 31480 | .unused, |
| 31481 | .unused, |
| 31482 | .unused, |
| 31483 | }, |
| 31484 | .dst_temps = .{.mem}, |
| 31485 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31486 | .each = .{ .once = &.{ |
| 31487 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31488 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 31489 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 31490 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31491 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 31492 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 31493 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31494 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31495 | } }, |
| 31496 | }, .{ |
| 31497 | .required_features = .{ .sse, null, null, null }, |
| 31498 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 31499 | .patterns = &.{ |
| 31500 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31501 | }, |
| 31502 | .call_frame = .{ .alignment = .@"16" }, |
| 31503 | .extra_temps = .{ |
| 31504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31505 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 31506 | .{ .type = .f32, .kind = .mem }, |
| 31507 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 31508 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31509 | else => unreachable, |
| 31510 | .down => "__floorh", |
| 31511 | .up => "__ceilh", |
| 31512 | .zero => "__trunch", |
| 31513 | } } } }, |
| 31514 | .unused, |
| 31515 | .unused, |
| 31516 | .unused, |
| 31517 | .unused, |
| 31518 | }, |
| 31519 | .dst_temps = .{.mem}, |
| 31520 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31521 | .each = .{ .once = &.{ |
| 31522 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31523 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31524 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 31525 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 31526 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 31527 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 31528 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 31529 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31530 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31532 | } }, |
| 31533 | }, .{ |
| 31534 | .required_features = .{ .avx, null, null, null }, |
| 31535 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31536 | .patterns = &.{ |
| 31537 | .{ .src = .{ .mem, .none, .none } }, |
| 31538 | }, |
| 31539 | .dst_temps = .{.{ .rc = .sse }}, |
| 31540 | .each = .{ .once = &.{ |
| 31541 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 31542 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 31543 | } }, |
| 31544 | }, .{ |
| 31545 | .required_features = .{ .avx, null, null, null }, |
| 31546 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31547 | .patterns = &.{ |
| 31548 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31549 | }, |
| 31550 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31551 | .each = .{ .once = &.{ |
| 31552 | .{ ._, .v_ss, .round, .dst0x, .src0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 31553 | } }, |
| 31554 | }, .{ |
| 31555 | .required_features = .{ .sse4_1, null, null, null }, |
| 31556 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31557 | .patterns = &.{ |
| 31558 | .{ .src = .{ .mem, .none, .none } }, |
| 31559 | }, |
| 31560 | .dst_temps = .{.{ .rc = .sse }}, |
| 31561 | .each = .{ .once = &.{ |
| 31562 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 31563 | .{ ._, ._ss, .round, .dst0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31564 | } }, |
| 31565 | }, .{ |
| 31566 | .required_features = .{ .sse4_1, null, null, null }, |
| 31567 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31568 | .patterns = &.{ |
| 31569 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 31570 | }, |
| 31571 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31572 | .each = .{ .once = &.{ |
| 31573 | .{ ._, ._ss, .round, .dst0x, .src0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31574 | } }, |
| 31575 | }, .{ |
| 31576 | .required_features = .{ .sse, null, null, null }, |
| 31577 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31578 | .patterns = &.{ |
| 31579 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 31580 | }, |
| 31581 | .call_frame = .{ .alignment = .@"16" }, |
| 31582 | .extra_temps = .{ |
| 31583 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31584 | else => unreachable, |
| 31585 | .down => "floorf", |
| 31586 | .up => "ceilf", |
| 31587 | .zero => "truncf", |
| 31588 | } } } }, |
| 31589 | .unused, |
| 31590 | .unused, |
| 31591 | .unused, |
| 31592 | .unused, |
| 31593 | .unused, |
| 31594 | .unused, |
| 31595 | .unused, |
| 31596 | .unused, |
| 31597 | }, |
| 31598 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31600 | .each = .{ .once = &.{ |
| 31601 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 31602 | } }, |
| 31603 | }, .{ |
| 31604 | .required_features = .{ .avx, null, null, null }, |
| 31605 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31606 | .patterns = &.{ |
| 31607 | .{ .src = .{ .mem, .none, .none } }, |
| 31608 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31609 | }, |
| 31610 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31611 | .each = .{ .once = &.{ |
| 31612 | .{ ._, .v_ps, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31613 | } }, |
| 31614 | }, .{ |
| 31615 | .required_features = .{ .sse4_1, null, null, null }, |
| 31616 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31617 | .patterns = &.{ |
| 31618 | .{ .src = .{ .mem, .none, .none } }, |
| 31619 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31620 | }, |
| 31621 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31622 | .each = .{ .once = &.{ |
| 31623 | .{ ._, ._ps, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31624 | } }, |
| 31625 | }, .{ |
| 31626 | .required_features = .{ .avx, null, null, null }, |
| 31627 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 31628 | .patterns = &.{ |
| 31629 | .{ .src = .{ .mem, .none, .none } }, |
| 31630 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31631 | }, |
| 31632 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31633 | .each = .{ .once = &.{ |
| 31634 | .{ ._, .v_ps, .round, .dst0y, .src0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31635 | } }, |
| 31636 | }, .{ |
| 31637 | .required_features = .{ .avx, null, null, null }, |
| 31638 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 31639 | .patterns = &.{ |
| 31640 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31641 | }, |
| 31642 | .extra_temps = .{ |
| 31643 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31644 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 31645 | .unused, |
| 31646 | .unused, |
| 31647 | .unused, |
| 31648 | .unused, |
| 31649 | .unused, |
| 31650 | .unused, |
| 31651 | .unused, |
| 31652 | }, |
| 31653 | .dst_temps = .{.mem}, |
| 31654 | .clobbers = .{ .eflags = true }, |
| 31655 | .each = .{ .once = &.{ |
| 31656 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31657 | .{ .@"0:", .v_ps, .round, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), .rm(.{ |
| 31658 | .direction = direction, |
| 31659 | .precision = .inexact, |
| 31660 | }), ._ }, |
| 31661 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 31662 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 31663 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31664 | } }, |
| 31665 | }, .{ |
| 31666 | .required_features = .{ .sse4_1, null, null, null }, |
| 31667 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31668 | .patterns = &.{ |
| 31669 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31670 | }, |
| 31671 | .extra_temps = .{ |
| 31672 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31673 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 31674 | .unused, |
| 31675 | .unused, |
| 31676 | .unused, |
| 31677 | .unused, |
| 31678 | .unused, |
| 31679 | .unused, |
| 31680 | .unused, |
| 31681 | }, |
| 31682 | .dst_temps = .{.mem}, |
| 31683 | .clobbers = .{ .eflags = true }, |
| 31684 | .each = .{ .once = &.{ |
| 31685 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31686 | .{ .@"0:", ._ps, .round, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), .rm(.{ |
| 31687 | .direction = direction, |
| 31688 | .precision = .inexact, |
| 31689 | }), ._ }, |
| 31690 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31691 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31692 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31693 | } }, |
| 31694 | }, .{ |
| 31695 | .required_features = .{ .avx, null, null, null }, |
| 31696 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31697 | .patterns = &.{ |
| 31698 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31699 | }, |
| 31700 | .call_frame = .{ .alignment = .@"16" }, |
| 31701 | .extra_temps = .{ |
| 31702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31703 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 31704 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31705 | else => unreachable, |
| 31706 | .down => "floorf", |
| 31707 | .up => "ceilf", |
| 31708 | .zero => "truncf", |
| 31709 | } } } }, |
| 31710 | .unused, |
| 31711 | .unused, |
| 31712 | .unused, |
| 31713 | .unused, |
| 31714 | .unused, |
| 31715 | .unused, |
| 31716 | }, |
| 31717 | .dst_temps = .{.mem}, |
| 31718 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31719 | .each = .{ .once = &.{ |
| 31720 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31721 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31722 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31723 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31724 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31725 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31726 | } }, |
| 31727 | }, .{ |
| 31728 | .required_features = .{ .sse, null, null, null }, |
| 31729 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31730 | .patterns = &.{ |
| 31731 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31732 | }, |
| 31733 | .call_frame = .{ .alignment = .@"16" }, |
| 31734 | .extra_temps = .{ |
| 31735 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31736 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 31737 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31738 | else => unreachable, |
| 31739 | .down => "floorf", |
| 31740 | .up => "ceilf", |
| 31741 | .zero => "truncf", |
| 31742 | } } } }, |
| 31743 | .unused, |
| 31744 | .unused, |
| 31745 | .unused, |
| 31746 | .unused, |
| 31747 | .unused, |
| 31748 | .unused, |
| 31749 | }, |
| 31750 | .dst_temps = .{.mem}, |
| 31751 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31752 | .each = .{ .once = &.{ |
| 31753 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31754 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31755 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31756 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31757 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31758 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31759 | } }, |
| 31760 | }, .{ |
| 31761 | .required_features = .{ .avx, null, null, null }, |
| 31762 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31763 | .patterns = &.{ |
| 31764 | .{ .src = .{ .mem, .none, .none } }, |
| 31765 | }, |
| 31766 | .dst_temps = .{.{ .rc = .sse }}, |
| 31767 | .each = .{ .once = &.{ |
| 31768 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 31769 | .{ ._, .v_sd, .round, .dst0x, .dst0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 31770 | } }, |
| 31771 | }, .{ |
| 31772 | .required_features = .{ .avx, null, null, null }, |
| 31773 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31774 | .patterns = &.{ |
| 31775 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31776 | }, |
| 31777 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31778 | .each = .{ .once = &.{ |
| 31779 | .{ ._, .v_sd, .round, .dst0x, .src0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 31780 | } }, |
| 31781 | }, .{ |
| 31782 | .required_features = .{ .sse4_1, null, null, null }, |
| 31783 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31784 | .patterns = &.{ |
| 31785 | .{ .src = .{ .mem, .none, .none } }, |
| 31786 | }, |
| 31787 | .dst_temps = .{.{ .rc = .sse }}, |
| 31788 | .each = .{ .once = &.{ |
| 31789 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 31790 | .{ ._, ._sd, .round, .dst0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31791 | } }, |
| 31792 | }, .{ |
| 31793 | .required_features = .{ .sse4_1, null, null, null }, |
| 31794 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31795 | .patterns = &.{ |
| 31796 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 31797 | }, |
| 31798 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31799 | .each = .{ .once = &.{ |
| 31800 | .{ ._, ._sd, .round, .dst0x, .src0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31801 | } }, |
| 31802 | }, .{ |
| 31803 | .required_features = .{ .sse, null, null, null }, |
| 31804 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31805 | .patterns = &.{ |
| 31806 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 31807 | }, |
| 31808 | .call_frame = .{ .alignment = .@"16" }, |
| 31809 | .extra_temps = .{ |
| 31810 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31811 | else => unreachable, |
| 31812 | .down => "floor", |
| 31813 | .up => "ceil", |
| 31814 | .zero => "trunc", |
| 31815 | } } } }, |
| 31816 | .unused, |
| 31817 | .unused, |
| 31818 | .unused, |
| 31819 | .unused, |
| 31820 | .unused, |
| 31821 | .unused, |
| 31822 | .unused, |
| 31823 | .unused, |
| 31824 | }, |
| 31825 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31826 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31827 | .each = .{ .once = &.{ |
| 31828 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 31829 | } }, |
| 31830 | }, .{ |
| 31831 | .required_features = .{ .avx, null, null, null }, |
| 31832 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31833 | .patterns = &.{ |
| 31834 | .{ .src = .{ .mem, .none, .none } }, |
| 31835 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31836 | }, |
| 31837 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31838 | .each = .{ .once = &.{ |
| 31839 | .{ ._, .v_pd, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31840 | } }, |
| 31841 | }, .{ |
| 31842 | .required_features = .{ .sse4_1, null, null, null }, |
| 31843 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31844 | .patterns = &.{ |
| 31845 | .{ .src = .{ .mem, .none, .none } }, |
| 31846 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31847 | }, |
| 31848 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31849 | .each = .{ .once = &.{ |
| 31850 | .{ ._, ._pd, .round, .dst0x, .src0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31851 | } }, |
| 31852 | }, .{ |
| 31853 | .required_features = .{ .avx, null, null, null }, |
| 31854 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 31855 | .patterns = &.{ |
| 31856 | .{ .src = .{ .mem, .none, .none } }, |
| 31857 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31858 | }, |
| 31859 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31860 | .each = .{ .once = &.{ |
| 31861 | .{ ._, .v_pd, .round, .dst0y, .src0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 31862 | } }, |
| 31863 | }, .{ |
| 31864 | .required_features = .{ .avx, null, null, null }, |
| 31865 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 31866 | .patterns = &.{ |
| 31867 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31868 | }, |
| 31869 | .extra_temps = .{ |
| 31870 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31871 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 31872 | .unused, |
| 31873 | .unused, |
| 31874 | .unused, |
| 31875 | .unused, |
| 31876 | .unused, |
| 31877 | .unused, |
| 31878 | .unused, |
| 31879 | }, |
| 31880 | .dst_temps = .{.mem}, |
| 31881 | .clobbers = .{ .eflags = true }, |
| 31882 | .each = .{ .once = &.{ |
| 31883 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31884 | .{ .@"0:", .v_pd, .round, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), .rm(.{ |
| 31885 | .direction = direction, |
| 31886 | .precision = .inexact, |
| 31887 | }), ._ }, |
| 31888 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 31889 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 31890 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31891 | } }, |
| 31892 | }, .{ |
| 31893 | .required_features = .{ .sse4_1, null, null, null }, |
| 31894 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31895 | .patterns = &.{ |
| 31896 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31897 | }, |
| 31898 | .extra_temps = .{ |
| 31899 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31900 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 31901 | .unused, |
| 31902 | .unused, |
| 31903 | .unused, |
| 31904 | .unused, |
| 31905 | .unused, |
| 31906 | .unused, |
| 31907 | .unused, |
| 31908 | }, |
| 31909 | .dst_temps = .{.mem}, |
| 31910 | .clobbers = .{ .eflags = true }, |
| 31911 | .each = .{ .once = &.{ |
| 31912 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31913 | .{ .@"0:", ._pd, .round, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), .rm(.{ |
| 31914 | .direction = direction, |
| 31915 | .precision = .inexact, |
| 31916 | }), ._ }, |
| 31917 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31918 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31919 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31920 | } }, |
| 31921 | }, .{ |
| 31922 | .required_features = .{ .avx, null, null, null }, |
| 31923 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31924 | .patterns = &.{ |
| 31925 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31926 | }, |
| 31927 | .call_frame = .{ .alignment = .@"16" }, |
| 31928 | .extra_temps = .{ |
| 31929 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31930 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 31931 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31932 | else => unreachable, |
| 31933 | .down => "floor", |
| 31934 | .up => "ceil", |
| 31935 | .zero => "trunc", |
| 31936 | } } } }, |
| 31937 | .unused, |
| 31938 | .unused, |
| 31939 | .unused, |
| 31940 | .unused, |
| 31941 | .unused, |
| 31942 | .unused, |
| 31943 | }, |
| 31944 | .dst_temps = .{.mem}, |
| 31945 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31946 | .each = .{ .once = &.{ |
| 31947 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31948 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31949 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31950 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31951 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 31952 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31953 | } }, |
| 31954 | }, .{ |
| 31955 | .required_features = .{ .sse2, null, null, null }, |
| 31956 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31957 | .patterns = &.{ |
| 31958 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31959 | }, |
| 31960 | .call_frame = .{ .alignment = .@"16" }, |
| 31961 | .extra_temps = .{ |
| 31962 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31963 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 31964 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31965 | else => unreachable, |
| 31966 | .down => "floor", |
| 31967 | .up => "ceil", |
| 31968 | .zero => "trunc", |
| 31969 | } } } }, |
| 31970 | .unused, |
| 31971 | .unused, |
| 31972 | .unused, |
| 31973 | .unused, |
| 31974 | .unused, |
| 31975 | .unused, |
| 31976 | }, |
| 31977 | .dst_temps = .{.mem}, |
| 31978 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 31979 | .each = .{ .once = &.{ |
| 31980 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 31981 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31982 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 31983 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31984 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 31985 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31986 | } }, |
| 31987 | }, .{ |
| 31988 | .required_features = .{ .sse, null, null, null }, |
| 31989 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31990 | .patterns = &.{ |
| 31991 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31992 | }, |
| 31993 | .call_frame = .{ .alignment = .@"16" }, |
| 31994 | .extra_temps = .{ |
| 31995 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31996 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 31997 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 31998 | else => unreachable, |
| 31999 | .down => "floor", |
| 32000 | .up => "ceil", |
| 32001 | .zero => "trunc", |
| 32002 | } } } }, |
| 32003 | .unused, |
| 32004 | .unused, |
| 32005 | .unused, |
| 32006 | .unused, |
| 32007 | .unused, |
| 32008 | .unused, |
| 32009 | }, |
| 32010 | .dst_temps = .{.mem}, |
| 32011 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32012 | .each = .{ .once = &.{ |
| 32013 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32014 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 32015 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32016 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32017 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 32018 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32019 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32020 | } }, |
| 32021 | }, .{ |
| 32022 | .required_features = .{ .avx, .x87, null, null }, |
| 32023 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 32024 | .patterns = &.{ |
| 32025 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32026 | }, |
| 32027 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 32028 | .extra_temps = .{ |
| 32029 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 32030 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 32031 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32032 | else => unreachable, |
| 32033 | .down => "__floorx", |
| 32034 | .up => "__ceilx", |
| 32035 | .zero => "__truncx", |
| 32036 | } } } }, |
| 32037 | .unused, |
| 32038 | .unused, |
| 32039 | .unused, |
| 32040 | .unused, |
| 32041 | .unused, |
| 32042 | .unused, |
| 32043 | }, |
| 32044 | .dst_temps = .{.{ .reg = .st0 }}, |
| 32045 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32046 | .each = .{ .once = &.{ |
| 32047 | .{ ._, .v_dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 32048 | .{ ._, .v_dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 32049 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32050 | } }, |
| 32051 | }, .{ |
| 32052 | .required_features = .{ .sse2, .x87, null, null }, |
| 32053 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 32054 | .patterns = &.{ |
| 32055 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32056 | }, |
| 32057 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 32058 | .extra_temps = .{ |
| 32059 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 32060 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 32061 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32062 | else => unreachable, |
| 32063 | .down => "__floorx", |
| 32064 | .up => "__ceilx", |
| 32065 | .zero => "__truncx", |
| 32066 | } } } }, |
| 32067 | .unused, |
| 32068 | .unused, |
| 32069 | .unused, |
| 32070 | .unused, |
| 32071 | .unused, |
| 32072 | .unused, |
| 32073 | }, |
| 32074 | .dst_temps = .{.{ .reg = .st0 }}, |
| 32075 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32076 | .each = .{ .once = &.{ |
| 32077 | .{ ._, ._dqa, .mov, .tmp0x, .mem(.src0x), ._, ._ }, |
| 32078 | .{ ._, ._dqa, .mov, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 32079 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32080 | } }, |
| 32081 | }, .{ |
| 32082 | .required_features = .{ .sse, .x87, null, null }, |
| 32083 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 32084 | .patterns = &.{ |
| 32085 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32086 | }, |
| 32087 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 32088 | .extra_temps = .{ |
| 32089 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 32090 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 32091 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32092 | else => unreachable, |
| 32093 | .down => "__floorx", |
| 32094 | .up => "__ceilx", |
| 32095 | .zero => "__truncx", |
| 32096 | } } } }, |
| 32097 | .unused, |
| 32098 | .unused, |
| 32099 | .unused, |
| 32100 | .unused, |
| 32101 | .unused, |
| 32102 | .unused, |
| 32103 | }, |
| 32104 | .dst_temps = .{.{ .reg = .st0 }}, |
| 32105 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32106 | .each = .{ .once = &.{ |
| 32107 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ }, |
| 32108 | .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 32109 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32110 | } }, |
| 32111 | }, .{ |
| 32112 | .required_features = .{ .avx, .x87, null, null }, |
| 32113 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 32114 | .patterns = &.{ |
| 32115 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32116 | }, |
| 32117 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 32118 | .extra_temps = .{ |
| 32119 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32120 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 32121 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 32122 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32123 | else => unreachable, |
| 32124 | .down => "__floorx", |
| 32125 | .up => "__ceilx", |
| 32126 | .zero => "__truncx", |
| 32127 | } } } }, |
| 32128 | .unused, |
| 32129 | .unused, |
| 32130 | .unused, |
| 32131 | .unused, |
| 32132 | .unused, |
| 32133 | }, |
| 32134 | .dst_temps = .{.mem}, |
| 32135 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32136 | .each = .{ .once = &.{ |
| 32137 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32138 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32139 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 32140 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 32141 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 32142 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 32143 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32144 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32145 | } }, |
| 32146 | }, .{ |
| 32147 | .required_features = .{ .sse2, .x87, null, null }, |
| 32148 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 32149 | .patterns = &.{ |
| 32150 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32151 | }, |
| 32152 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 32153 | .extra_temps = .{ |
| 32154 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32155 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 32156 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 32157 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32158 | else => unreachable, |
| 32159 | .down => "__floorx", |
| 32160 | .up => "__ceilx", |
| 32161 | .zero => "__truncx", |
| 32162 | } } } }, |
| 32163 | .unused, |
| 32164 | .unused, |
| 32165 | .unused, |
| 32166 | .unused, |
| 32167 | .unused, |
| 32168 | }, |
| 32169 | .dst_temps = .{.mem}, |
| 32170 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32171 | .each = .{ .once = &.{ |
| 32172 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32173 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32174 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 32175 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 32176 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 32177 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 32178 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32179 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32180 | } }, |
| 32181 | }, .{ |
| 32182 | .required_features = .{ .sse, .x87, null, null }, |
| 32183 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 32184 | .patterns = &.{ |
| 32185 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32186 | }, |
| 32187 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 32188 | .extra_temps = .{ |
| 32189 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32190 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 32191 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 32192 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32193 | else => unreachable, |
| 32194 | .down => "__floorx", |
| 32195 | .up => "__ceilx", |
| 32196 | .zero => "__truncx", |
| 32197 | } } } }, |
| 32198 | .unused, |
| 32199 | .unused, |
| 32200 | .unused, |
| 32201 | .unused, |
| 32202 | .unused, |
| 32203 | }, |
| 32204 | .dst_temps = .{.mem}, |
| 32205 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32206 | .each = .{ .once = &.{ |
| 32207 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32208 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32209 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 32210 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 32211 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 32212 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 32213 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32214 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32215 | } }, |
| 32216 | }, .{ |
| 32217 | .required_features = .{ .sse, null, null, null }, |
| 32218 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 32219 | .patterns = &.{ |
| 32220 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 32221 | }, |
| 32222 | .call_frame = .{ .alignment = .@"16" }, |
| 32223 | .extra_temps = .{ |
| 32224 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32225 | else => unreachable, |
| 32226 | .down => "floorq", |
| 32227 | .up => "ceilq", |
| 32228 | .zero => "truncq", |
| 32229 | } } } }, |
| 32230 | .unused, |
| 32231 | .unused, |
| 32232 | .unused, |
| 32233 | .unused, |
| 32234 | .unused, |
| 32235 | .unused, |
| 32236 | .unused, |
| 32237 | .unused, |
| 32238 | }, |
| 32239 | .dst_temps = .{.{ .ref = .src0 }}, |
| 32240 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32241 | .each = .{ .once = &.{ |
| 32242 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 32243 | } }, |
| 32244 | }, .{ |
| 32245 | .required_features = .{ .avx, null, null, null }, |
| 32246 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 32247 | .patterns = &.{ |
| 32248 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32249 | }, |
| 32250 | .call_frame = .{ .alignment = .@"16" }, |
| 32251 | .extra_temps = .{ |
| 32252 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32253 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 32254 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32255 | else => unreachable, |
| 32256 | .down => "floorq", |
| 32257 | .up => "ceilq", |
| 32258 | .zero => "truncq", |
| 32259 | } } } }, |
| 32260 | .unused, |
| 32261 | .unused, |
| 32262 | .unused, |
| 32263 | .unused, |
| 32264 | .unused, |
| 32265 | .unused, |
| 32266 | }, |
| 32267 | .dst_temps = .{.mem}, |
| 32268 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32269 | .each = .{ .once = &.{ |
| 32270 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32271 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32272 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32273 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 32274 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32275 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32276 | } }, |
| 32277 | }, .{ |
| 32278 | .required_features = .{ .sse2, null, null, null }, |
| 32279 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 32280 | .patterns = &.{ |
| 32281 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32282 | }, |
| 32283 | .call_frame = .{ .alignment = .@"16" }, |
| 32284 | .extra_temps = .{ |
| 32285 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32286 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 32287 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32288 | else => unreachable, |
| 32289 | .down => "floorq", |
| 32290 | .up => "ceilq", |
| 32291 | .zero => "truncq", |
| 32292 | } } } }, |
| 32293 | .unused, |
| 32294 | .unused, |
| 32295 | .unused, |
| 32296 | .unused, |
| 32297 | .unused, |
| 32298 | .unused, |
| 32299 | }, |
| 32300 | .dst_temps = .{.mem}, |
| 32301 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32302 | .each = .{ .once = &.{ |
| 32303 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32304 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32305 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32306 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 32307 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32308 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32309 | } }, |
| 32310 | }, .{ |
| 32311 | .required_features = .{ .sse, null, null, null }, |
| 32312 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 32313 | .patterns = &.{ |
| 32314 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32315 | }, |
| 32316 | .call_frame = .{ .alignment = .@"16" }, |
| 32317 | .extra_temps = .{ |
| 32318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32319 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 32320 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 32321 | else => unreachable, |
| 32322 | .down => "floorq", |
| 32323 | .up => "ceilq", |
| 32324 | .zero => "truncq", |
| 32325 | } } } }, |
| 32326 | .unused, |
| 32327 | .unused, |
| 32328 | .unused, |
| 32329 | .unused, |
| 32330 | .unused, |
| 32331 | .unused, |
| 32332 | }, |
| 32333 | .dst_temps = .{.mem}, |
| 32334 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 32335 | .each = .{ .once = &.{ |
| 32336 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 32337 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32338 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 32339 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 32340 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32341 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32342 | } }, |
| 20251 | 32343 | } }, |
| 20252 | | }, .{ |
| 32344 | }) catch |err| switch (err) { |
| 32345 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 32346 | @tagName(air_tag), |
| 32347 | cg.typeOf(un_op).fmt(pt), |
| 32348 | ops[0].tracking(cg), |
| 32349 | }), |
| 32350 | else => |e| return e, |
| 32351 | }; |
| 32352 | try res[0].finish(inst, &.{un_op}, &ops, cg); |
| 32353 | }, |
| 32354 | .neg, .neg_optimized => |air_tag| if (use_old) try cg.airFloatSign(inst, .neg) else { |
| 32355 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 32356 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 32357 | var res: [1]Temp = undefined; |
| 32358 | cg.select(&res, &.{cg.typeOf(un_op)}, &ops, comptime &.{ .{ |
| 20253 | 32359 | .required_features = .{ .avx, null, null, null }, |
| 20254 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| 32360 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 20255 | 32361 | .patterns = &.{ |
| 20256 | | .{ .src = .{ .to_sse, .none } }, |
| 32362 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20257 | 32363 | }, |
| 20258 | 32364 | .extra_temps = .{ |
| 20259 | 32365 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20260 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32366 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20261 | 32367 | .unused, |
| 20262 | 32368 | .unused, |
| 20263 | 32369 | .unused, |
| ... | ... | @@ -20269,17 +32375,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20269 | 32375 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20270 | 32376 | .each = .{ .once = &.{ |
| 20271 | 32377 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20272 | | .{ ._, .v_ps, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 32378 | .{ ._, .v_ps, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 20273 | 32379 | } }, |
| 20274 | 32380 | }, .{ |
| 20275 | 32381 | .required_features = .{ .sse, null, null, null }, |
| 20276 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| 32382 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 20277 | 32383 | .patterns = &.{ |
| 20278 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 32384 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20279 | 32385 | }, |
| 20280 | 32386 | .extra_temps = .{ |
| 20281 | 32387 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20282 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32388 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20283 | 32389 | .unused, |
| 20284 | 32390 | .unused, |
| 20285 | 32391 | .unused, |
| ... | ... | @@ -20291,17 +32397,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20291 | 32397 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20292 | 32398 | .each = .{ .once = &.{ |
| 20293 | 32399 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20294 | | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 32400 | .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20295 | 32401 | } }, |
| 20296 | 32402 | }, .{ |
| 20297 | 32403 | .required_features = .{ .avx, null, null, null }, |
| 20298 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any }, |
| 32404 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 20299 | 32405 | .patterns = &.{ |
| 20300 | | .{ .src = .{ .to_sse, .none } }, |
| 32406 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20301 | 32407 | }, |
| 20302 | 32408 | .extra_temps = .{ |
| 20303 | 32409 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20304 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32410 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20305 | 32411 | .unused, |
| 20306 | 32412 | .unused, |
| 20307 | 32413 | .unused, |
| ... | ... | @@ -20313,17 +32419,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20313 | 32419 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20314 | 32420 | .each = .{ .once = &.{ |
| 20315 | 32421 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20316 | | .{ ._, .v_ps, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 32422 | .{ ._, .v_ps, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 20317 | 32423 | } }, |
| 20318 | 32424 | }, .{ |
| 20319 | 32425 | .required_features = .{ .avx, null, null, null }, |
| 20320 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| 32426 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 20321 | 32427 | .patterns = &.{ |
| 20322 | | .{ .src = .{ .to_sse, .none } }, |
| 32428 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20323 | 32429 | }, |
| 20324 | 32430 | .extra_temps = .{ |
| 20325 | 32431 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20326 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32432 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20327 | 32433 | .unused, |
| 20328 | 32434 | .unused, |
| 20329 | 32435 | .unused, |
| ... | ... | @@ -20335,17 +32441,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20335 | 32441 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20336 | 32442 | .each = .{ .once = &.{ |
| 20337 | 32443 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20338 | | .{ ._, .v_pd, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 32444 | .{ ._, .v_pd, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 20339 | 32445 | } }, |
| 20340 | 32446 | }, .{ |
| 20341 | 32447 | .required_features = .{ .sse2, null, null, null }, |
| 20342 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| 32448 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 20343 | 32449 | .patterns = &.{ |
| 20344 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 32450 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20345 | 32451 | }, |
| 20346 | 32452 | .extra_temps = .{ |
| 20347 | 32453 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20348 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32454 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20349 | 32455 | .unused, |
| 20350 | 32456 | .unused, |
| 20351 | 32457 | .unused, |
| ... | ... | @@ -20357,17 +32463,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20357 | 32463 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20358 | 32464 | .each = .{ .once = &.{ |
| 20359 | 32465 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20360 | | .{ ._, ._pd, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 32466 | .{ ._, ._pd, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20361 | 32467 | } }, |
| 20362 | 32468 | }, .{ |
| 20363 | 32469 | .required_features = .{ .avx, null, null, null }, |
| 20364 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any }, |
| 32470 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 20365 | 32471 | .patterns = &.{ |
| 20366 | | .{ .src = .{ .to_sse, .none } }, |
| 32472 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20367 | 32473 | }, |
| 20368 | 32474 | .extra_temps = .{ |
| 20369 | 32475 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20370 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32476 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20371 | 32477 | .unused, |
| 20372 | 32478 | .unused, |
| 20373 | 32479 | .unused, |
| ... | ... | @@ -20379,14 +32485,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20379 | 32485 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20380 | 32486 | .each = .{ .once = &.{ |
| 20381 | 32487 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20382 | | .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 32488 | .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 20383 | 32489 | } }, |
| 20384 | 32490 | }, .{ |
| 20385 | 32491 | .required_features = .{ .x87, null, null, null }, |
| 20386 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 32492 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 20387 | 32493 | .patterns = &.{ |
| 20388 | | .{ .src = .{ .mem, .none } }, |
| 20389 | | .{ .src = .{ .to_x87, .none } }, |
| 32494 | .{ .src = .{ .mem, .none, .none } }, |
| 32495 | .{ .src = .{ .to_x87, .none, .none } }, |
| 20390 | 32496 | }, |
| 20391 | 32497 | .extra_temps = .{ |
| 20392 | 32498 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | ... | @@ -20402,18 +32508,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20402 | 32508 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }}, |
| 20403 | 32509 | .each = .{ .once = &.{ |
| 20404 | 32510 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 20405 | | .{ ._, .f_, .abs, ._, ._, ._, ._ }, |
| 32511 | .{ ._, .f_, .chs, ._, ._, ._, ._ }, |
| 20406 | 32512 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 20407 | 32513 | } }, |
| 20408 | 32514 | }, .{ |
| 20409 | 32515 | .required_features = .{ .avx, null, null, null }, |
| 20410 | | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any }, |
| 32516 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 20411 | 32517 | .patterns = &.{ |
| 20412 | | .{ .src = .{ .to_sse, .none } }, |
| 32518 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20413 | 32519 | }, |
| 20414 | 32520 | .extra_temps = .{ |
| 20415 | 32521 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20416 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32522 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20417 | 32523 | .unused, |
| 20418 | 32524 | .unused, |
| 20419 | 32525 | .unused, |
| ... | ... | @@ -20425,17 +32531,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20425 | 32531 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20426 | 32532 | .each = .{ .once = &.{ |
| 20427 | 32533 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20428 | | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 32534 | .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 20429 | 32535 | } }, |
| 20430 | 32536 | }, .{ |
| 20431 | 32537 | .required_features = .{ .sse2, null, null, null }, |
| 20432 | | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any }, |
| 32538 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 20433 | 32539 | .patterns = &.{ |
| 20434 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 32540 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20435 | 32541 | }, |
| 20436 | 32542 | .extra_temps = .{ |
| 20437 | 32543 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20438 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32544 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20439 | 32545 | .unused, |
| 20440 | 32546 | .unused, |
| 20441 | 32547 | .unused, |
| ... | ... | @@ -20447,17 +32553,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20447 | 32553 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20448 | 32554 | .each = .{ .once = &.{ |
| 20449 | 32555 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20450 | | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 32556 | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20451 | 32557 | } }, |
| 20452 | 32558 | }, .{ |
| 20453 | 32559 | .required_features = .{ .sse, null, null, null }, |
| 20454 | | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any }, |
| 32560 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 20455 | 32561 | .patterns = &.{ |
| 20456 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 32562 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20457 | 32563 | }, |
| 20458 | 32564 | .extra_temps = .{ |
| 20459 | 32565 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20460 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32566 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20461 | 32567 | .unused, |
| 20462 | 32568 | .unused, |
| 20463 | 32569 | .unused, |
| ... | ... | @@ -20469,17 +32575,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20469 | 32575 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20470 | 32576 | .each = .{ .once = &.{ |
| 20471 | 32577 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20472 | | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 32578 | .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20473 | 32579 | } }, |
| 20474 | 32580 | }, .{ |
| 20475 | 32581 | .required_features = .{ .avx2, null, null, null }, |
| 20476 | | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any }, |
| 32582 | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any }, |
| 20477 | 32583 | .patterns = &.{ |
| 20478 | | .{ .src = .{ .to_sse, .none } }, |
| 32584 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20479 | 32585 | }, |
| 20480 | 32586 | .extra_temps = .{ |
| 20481 | 32587 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20482 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32588 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20483 | 32589 | .unused, |
| 20484 | 32590 | .unused, |
| 20485 | 32591 | .unused, |
| ... | ... | @@ -20491,17 +32597,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20491 | 32597 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20492 | 32598 | .each = .{ .once = &.{ |
| 20493 | 32599 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20494 | | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 32600 | .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 20495 | 32601 | } }, |
| 20496 | 32602 | }, .{ |
| 20497 | 32603 | .required_features = .{ .avx, null, null, null }, |
| 20498 | | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any }, |
| 32604 | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any }, |
| 20499 | 32605 | .patterns = &.{ |
| 20500 | | .{ .src = .{ .to_sse, .none } }, |
| 32606 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20501 | 32607 | }, |
| 20502 | 32608 | .extra_temps = .{ |
| 20503 | 32609 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 20504 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32610 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20505 | 32611 | .unused, |
| 20506 | 32612 | .unused, |
| 20507 | 32613 | .unused, |
| ... | ... | @@ -20513,17 +32619,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20513 | 32619 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20514 | 32620 | .each = .{ .once = &.{ |
| 20515 | 32621 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20516 | | .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 32622 | .{ ._, .v_pd, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 20517 | 32623 | } }, |
| 20518 | 32624 | }, .{ |
| 20519 | 32625 | .required_features = .{ .avx, null, null, null }, |
| 20520 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any }, |
| 32626 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 20521 | 32627 | .patterns = &.{ |
| 20522 | | .{ .src = .{ .to_mem, .none } }, |
| 32628 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20523 | 32629 | }, |
| 20524 | 32630 | .extra_temps = .{ |
| 20525 | 32631 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20526 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32632 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20527 | 32633 | .{ .kind = .{ .rc = .sse } }, |
| 20528 | 32634 | .{ .kind = .{ .rc = .sse } }, |
| 20529 | 32635 | .unused, |
| ... | ... | @@ -20537,20 +32643,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20537 | 32643 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20538 | 32644 | .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20539 | 32645 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20540 | | .{ .@"0:", .v_ps, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 32646 | .{ .@"0:", .v_ps, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20541 | 32647 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20542 | 32648 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20543 | 32649 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20544 | 32650 | } }, |
| 20545 | 32651 | }, .{ |
| 20546 | 32652 | .required_features = .{ .sse, null, null, null }, |
| 20547 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| 32653 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 20548 | 32654 | .patterns = &.{ |
| 20549 | | .{ .src = .{ .to_mem, .none } }, |
| 32655 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20550 | 32656 | }, |
| 20551 | 32657 | .extra_temps = .{ |
| 20552 | 32658 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20553 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32659 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20554 | 32660 | .{ .kind = .{ .rc = .sse } }, |
| 20555 | 32661 | .{ .kind = .{ .rc = .sse } }, |
| 20556 | 32662 | .unused, |
| ... | ... | @@ -20565,20 +32671,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20565 | 32671 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20566 | 32672 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20567 | 32673 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 20568 | | .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 32674 | .{ ._, ._ps, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20569 | 32675 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20570 | 32676 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20571 | 32677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20572 | 32678 | } }, |
| 20573 | 32679 | }, .{ |
| 20574 | 32680 | .required_features = .{ .avx, null, null, null }, |
| 20575 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any }, |
| 32681 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 20576 | 32682 | .patterns = &.{ |
| 20577 | | .{ .src = .{ .to_mem, .none } }, |
| 32683 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20578 | 32684 | }, |
| 20579 | 32685 | .extra_temps = .{ |
| 20580 | 32686 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20581 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32687 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20582 | 32688 | .{ .kind = .{ .rc = .sse } }, |
| 20583 | 32689 | .{ .kind = .{ .rc = .sse } }, |
| 20584 | 32690 | .unused, |
| ... | ... | @@ -20592,20 +32698,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20592 | 32698 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20593 | 32699 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20594 | 32700 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20595 | | .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 32701 | .{ .@"0:", .v_pd, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20596 | 32702 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20597 | 32703 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20598 | 32704 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20599 | 32705 | } }, |
| 20600 | 32706 | }, .{ |
| 20601 | 32707 | .required_features = .{ .sse2, null, null, null }, |
| 20602 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| 32708 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 20603 | 32709 | .patterns = &.{ |
| 20604 | | .{ .src = .{ .to_mem, .none } }, |
| 32710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20605 | 32711 | }, |
| 20606 | 32712 | .extra_temps = .{ |
| 20607 | 32713 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20608 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32714 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20609 | 32715 | .{ .kind = .{ .rc = .sse } }, |
| 20610 | 32716 | .{ .kind = .{ .rc = .sse } }, |
| 20611 | 32717 | .unused, |
| ... | ... | @@ -20620,20 +32726,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20620 | 32726 | .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20621 | 32727 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20622 | 32728 | .{ .@"0:", ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 20623 | | .{ ._, ._pd, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 32729 | .{ ._, ._pd, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20624 | 32730 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20625 | 32731 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20626 | 32732 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20627 | 32733 | } }, |
| 20628 | 32734 | }, .{ |
| 20629 | 32735 | .required_features = .{ .avx2, null, null, null }, |
| 20630 | | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any }, |
| 32736 | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any }, |
| 20631 | 32737 | .patterns = &.{ |
| 20632 | | .{ .src = .{ .to_mem, .none } }, |
| 32738 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20633 | 32739 | }, |
| 20634 | 32740 | .extra_temps = .{ |
| 20635 | 32741 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20636 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32742 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20637 | 32743 | .{ .kind = .{ .rc = .sse } }, |
| 20638 | 32744 | .{ .kind = .{ .rc = .sse } }, |
| 20639 | 32745 | .unused, |
| ... | ... | @@ -20647,20 +32753,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20647 | 32753 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20648 | 32754 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20649 | 32755 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20650 | | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 32756 | .{ .@"0:", .vp_, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20651 | 32757 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20652 | 32758 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20653 | 32759 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20654 | 32760 | } }, |
| 20655 | 32761 | }, .{ |
| 20656 | 32762 | .required_features = .{ .avx, null, null, null }, |
| 20657 | | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any }, |
| 32763 | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any }, |
| 20658 | 32764 | .patterns = &.{ |
| 20659 | | .{ .src = .{ .to_mem, .none } }, |
| 32765 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20660 | 32766 | }, |
| 20661 | 32767 | .extra_temps = .{ |
| 20662 | 32768 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20663 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 32769 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20664 | 32770 | .{ .kind = .{ .rc = .sse } }, |
| 20665 | 32771 | .{ .kind = .{ .rc = .sse } }, |
| 20666 | 32772 | .unused, |
| ... | ... | @@ -20674,20 +32780,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20674 | 32780 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20675 | 32781 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20676 | 32782 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20677 | | .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 32783 | .{ .@"0:", .v_pd, .xor, .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20678 | 32784 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20679 | 32785 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20680 | 32786 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20681 | 32787 | } }, |
| 20682 | 32788 | }, .{ |
| 20683 | 32789 | .required_features = .{ .sse2, null, null, null }, |
| 20684 | | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any }, |
| 32790 | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any }, |
| 20685 | 32791 | .patterns = &.{ |
| 20686 | | .{ .src = .{ .to_mem, .none } }, |
| 32792 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20687 | 32793 | }, |
| 20688 | 32794 | .extra_temps = .{ |
| 20689 | 32795 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20690 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32796 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20691 | 32797 | .{ .kind = .{ .rc = .sse } }, |
| 20692 | 32798 | .{ .kind = .{ .rc = .sse } }, |
| 20693 | 32799 | .unused, |
| ... | ... | @@ -20702,20 +32808,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20702 | 32808 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20703 | 32809 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20704 | 32810 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 20705 | | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 32811 | .{ ._, .p_, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20706 | 32812 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20707 | 32813 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20708 | 32814 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20709 | 32815 | } }, |
| 20710 | 32816 | }, .{ |
| 20711 | 32817 | .required_features = .{ .sse, null, null, null }, |
| 20712 | | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any }, |
| 32818 | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any }, |
| 20713 | 32819 | .patterns = &.{ |
| 20714 | | .{ .src = .{ .to_mem, .none } }, |
| 32820 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20715 | 32821 | }, |
| 20716 | 32822 | .extra_temps = .{ |
| 20717 | 32823 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20718 | | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 32824 | .{ .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20719 | 32825 | .{ .kind = .{ .rc = .sse } }, |
| 20720 | 32826 | .{ .kind = .{ .rc = .sse } }, |
| 20721 | 32827 | .unused, |
| ... | ... | @@ -20730,7 +32836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20730 | 32836 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20731 | 32837 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20732 | 32838 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 20733 | | .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 32839 | .{ ._, ._ps, .xor, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20734 | 32840 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20735 | 32841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20736 | 32842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| ... | ... | @@ -20738,12 +32844,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20738 | 32844 | } }) catch |err| switch (err) { |
| 20739 | 32845 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 20740 | 32846 | @tagName(air_tag), |
| 20741 | | cg.typeOf(ty_op.operand).fmt(pt), |
| 32847 | cg.typeOf(un_op).fmt(pt), |
| 20742 | 32848 | ops[0].tracking(cg), |
| 20743 | 32849 | }), |
| 20744 | 32850 | else => |e| return e, |
| 20745 | 32851 | }; |
| 20746 | | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 32852 | try res[0].finish(inst, &.{un_op}, &ops, cg); |
| 20747 | 32853 | }, |
| 20748 | 32854 | |
| 20749 | 32855 | .cmp_lt, |
| ... | ... | @@ -20772,9 +32878,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20772 | 32878 | }) { |
| 20773 | 32879 | inline false, true => |strict| comptime &.{ .{ |
| 20774 | 32880 | .required_features = .{ .f16c, null, null, null }, |
| 20775 | | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, |
| 32881 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 20776 | 32882 | .patterns = &.{ |
| 20777 | | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 32883 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20778 | 32884 | }, |
| 20779 | 32885 | .extra_temps = .{ |
| 20780 | 32886 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| ... | ... | @@ -20799,9 +32905,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20799 | 32905 | } }, |
| 20800 | 32906 | }, .{ |
| 20801 | 32907 | .required_features = .{ .sse, null, null, null }, |
| 20802 | | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, |
| 32908 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 20803 | 32909 | .patterns = &.{ |
| 20804 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 32910 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 20805 | 32911 | }, |
| 20806 | 32912 | .call_frame = .{ .alignment = .@"16" }, |
| 20807 | 32913 | .extra_temps = .{ |
| ... | ... | @@ -20826,10 +32932,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20826 | 32932 | } }, |
| 20827 | 32933 | }, .{ |
| 20828 | 32934 | .required_features = .{ .avx, null, null, null }, |
| 20829 | | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, |
| 32935 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 20830 | 32936 | .patterns = &.{ |
| 20831 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 20832 | | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 32937 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 32938 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20833 | 32939 | }, |
| 20834 | 32940 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20835 | 32941 | true => .a, |
| ... | ... | @@ -20841,10 +32947,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20841 | 32947 | } }, |
| 20842 | 32948 | }, .{ |
| 20843 | 32949 | .required_features = .{ .sse, null, null, null }, |
| 20844 | | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, |
| 32950 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 20845 | 32951 | .patterns = &.{ |
| 20846 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 20847 | | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 32952 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 32953 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20848 | 32954 | }, |
| 20849 | 32955 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20850 | 32956 | true => .a, |
| ... | ... | @@ -20856,10 +32962,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20856 | 32962 | } }, |
| 20857 | 32963 | }, .{ |
| 20858 | 32964 | .required_features = .{ .avx, null, null, null }, |
| 20859 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 32965 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20860 | 32966 | .patterns = &.{ |
| 20861 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 20862 | | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 32967 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 32968 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20863 | 32969 | }, |
| 20864 | 32970 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20865 | 32971 | true => .a, |
| ... | ... | @@ -20871,10 +32977,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20871 | 32977 | } }, |
| 20872 | 32978 | }, .{ |
| 20873 | 32979 | .required_features = .{ .sse2, null, null, null }, |
| 20874 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 32980 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20875 | 32981 | .patterns = &.{ |
| 20876 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 20877 | | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 32982 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 32983 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20878 | 32984 | }, |
| 20879 | 32985 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20880 | 32986 | true => .a, |
| ... | ... | @@ -20886,13 +32992,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20886 | 32992 | } }, |
| 20887 | 32993 | }, .{ |
| 20888 | 32994 | .required_features = .{ .x87, .cmov, null, null }, |
| 20889 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 32995 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20890 | 32996 | .patterns = &.{ |
| 20891 | | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, |
| 32997 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 20892 | 32998 | }, |
| 20893 | 32999 | .extra_temps = .{ |
| 20894 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 20895 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 33000 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 33001 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 20896 | 33002 | .unused, |
| 20897 | 33003 | .unused, |
| 20898 | 33004 | .unused, |
| ... | ... | @@ -20914,13 +33020,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20914 | 33020 | } }, |
| 20915 | 33021 | }, .{ |
| 20916 | 33022 | .required_features = .{ .sahf, .x87, null, null }, |
| 20917 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33023 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20918 | 33024 | .patterns = &.{ |
| 20919 | | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, |
| 33025 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 20920 | 33026 | }, |
| 20921 | 33027 | .extra_temps = .{ |
| 20922 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 20923 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 33028 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 33029 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 20924 | 33030 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 20925 | 33031 | .unused, |
| 20926 | 33032 | .unused, |
| ... | ... | @@ -20943,13 +33049,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20943 | 33049 | } }, |
| 20944 | 33050 | }, .{ |
| 20945 | 33051 | .required_features = .{ .x87, null, null, null }, |
| 20946 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33052 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20947 | 33053 | .patterns = &.{ |
| 20948 | | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, |
| 33054 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 20949 | 33055 | }, |
| 20950 | 33056 | .extra_temps = .{ |
| 20951 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 20952 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 33057 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 33058 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 20953 | 33059 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 20954 | 33060 | .unused, |
| 20955 | 33061 | .unused, |
| ... | ... | @@ -20975,10 +33081,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20975 | 33081 | } }, |
| 20976 | 33082 | }, .{ |
| 20977 | 33083 | .required_features = .{ .x87, .cmov, null, null }, |
| 20978 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33084 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 20979 | 33085 | .patterns = &.{ |
| 20980 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 20981 | | .{ .src = .{ .to_x87, .to_x87 }, .commute = .{ 0, 1 } }, |
| 33086 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33087 | .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } }, |
| 20982 | 33088 | }, |
| 20983 | 33089 | .extra_temps = .{ |
| 20984 | 33090 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | ... | @@ -21002,9 +33108,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21002 | 33108 | } }, |
| 21003 | 33109 | }, .{ |
| 21004 | 33110 | .required_features = .{ .sahf, .x87, null, null }, |
| 21005 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33111 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21006 | 33112 | .patterns = &.{ |
| 21007 | | .{ .src = .{ .mem, .mem }, .commute = .{ 0, 1 } }, |
| 33113 | .{ .src = .{ .mem, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21008 | 33114 | }, |
| 21009 | 33115 | .extra_temps = .{ |
| 21010 | 33116 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21031,10 +33137,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21031 | 33137 | } }, |
| 21032 | 33138 | }, .{ |
| 21033 | 33139 | .required_features = .{ .sahf, .x87, null, null }, |
| 21034 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33140 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21035 | 33141 | .patterns = &.{ |
| 21036 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 21037 | | .{ .src = .{ .to_x87, .to_x87 }, .commute = .{ 0, 1 } }, |
| 33142 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33143 | .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } }, |
| 21038 | 33144 | }, |
| 21039 | 33145 | .extra_temps = .{ |
| 21040 | 33146 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21060,9 +33166,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21060 | 33166 | } }, |
| 21061 | 33167 | }, .{ |
| 21062 | 33168 | .required_features = .{ .x87, null, null, null }, |
| 21063 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33169 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21064 | 33170 | .patterns = &.{ |
| 21065 | | .{ .src = .{ .mem, .mem }, .commute = .{ 0, 1 } }, |
| 33171 | .{ .src = .{ .mem, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21066 | 33172 | }, |
| 21067 | 33173 | .extra_temps = .{ |
| 21068 | 33174 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21092,10 +33198,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21092 | 33198 | } }, |
| 21093 | 33199 | }, .{ |
| 21094 | 33200 | .required_features = .{ .x87, null, null, null }, |
| 21095 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33201 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21096 | 33202 | .patterns = &.{ |
| 21097 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 21098 | | .{ .src = .{ .to_x87, .to_x87 }, .commute = .{ 0, 1 } }, |
| 33203 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33204 | .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } }, |
| 21099 | 33205 | }, |
| 21100 | 33206 | .extra_temps = .{ |
| 21101 | 33207 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21124,9 +33230,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21124 | 33230 | } }, |
| 21125 | 33231 | }, .{ |
| 21126 | 33232 | .required_features = .{ .sse, null, null, null }, |
| 21127 | | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword } }, |
| 33233 | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any }, |
| 21128 | 33234 | .patterns = &.{ |
| 21129 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 33235 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 21130 | 33236 | }, |
| 21131 | 33237 | .call_frame = .{ .alignment = .@"16" }, |
| 21132 | 33238 | .extra_temps = .{ |
| ... | ... | @@ -21204,15 +33310,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21204 | 33310 | switch (Condition.fromCompareOperatorUnsigned(cmp_op)) { |
| 21205 | 33311 | else => unreachable, |
| 21206 | 33312 | inline .e, .ne => |cc| comptime &.{.{ |
| 21207 | | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte } }, |
| 33313 | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte }, .any }, |
| 21208 | 33314 | .patterns = &.{ |
| 21209 | | .{ .src = .{ .mem, .imm8 } }, |
| 21210 | | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, |
| 21211 | | .{ .src = .{ .to_gpr, .imm8 } }, |
| 21212 | | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, |
| 21213 | | .{ .src = .{ .mem, .to_gpr } }, |
| 21214 | | .{ .src = .{ .to_gpr, .mem }, .commute = .{ 0, 1 } }, |
| 21215 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 33315 | .{ .src = .{ .mem, .imm8, .none } }, |
| 33316 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33317 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 33318 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 33319 | .{ .src = .{ .mem, .to_gpr, .none } }, |
| 33320 | .{ .src = .{ .to_gpr, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33321 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 21216 | 33322 | }, |
| 21217 | 33323 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 21218 | 33324 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -21254,9 +33360,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21254 | 33360 | }) { |
| 21255 | 33361 | inline false, true => |optimized| comptime &.{ .{ |
| 21256 | 33362 | .required_features = .{ .f16c, null, null, null }, |
| 21257 | | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, |
| 33363 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 21258 | 33364 | .patterns = &.{ |
| 21259 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 33365 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21260 | 33366 | }, |
| 21261 | 33367 | .extra_temps = .{ |
| 21262 | 33368 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| ... | ... | @@ -21277,13 +33383,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21277 | 33383 | .each = .{ .once = &.{ |
| 21278 | 33384 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 21279 | 33385 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ }, |
| 21280 | | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, |
| 33386 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1d, ._, ._ }, |
| 21281 | 33387 | } }, |
| 21282 | 33388 | }, .{ |
| 21283 | 33389 | .required_features = .{ .sse, null, null, null }, |
| 21284 | | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, |
| 33390 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 21285 | 33391 | .patterns = &.{ |
| 21286 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 33392 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 21287 | 33393 | }, |
| 21288 | 33394 | .call_frame = .{ .alignment = .@"16" }, |
| 21289 | 33395 | .extra_temps = .{ |
| ... | ... | @@ -21305,11 +33411,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21305 | 33411 | } }, |
| 21306 | 33412 | }, .{ |
| 21307 | 33413 | .required_features = .{ .avx, null, null, null }, |
| 21308 | | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, |
| 33414 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 21309 | 33415 | .patterns = &.{ |
| 21310 | | .{ .src = .{ .to_sse, .mem } }, |
| 21311 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 21312 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 33416 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 33417 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 33418 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21313 | 33419 | }, |
| 21314 | 33420 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21315 | 33421 | false => .z_and_np, |
| ... | ... | @@ -21321,11 +33427,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21321 | 33427 | } }, |
| 21322 | 33428 | }, .{ |
| 21323 | 33429 | .required_features = .{ .sse, null, null, null }, |
| 21324 | | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, |
| 33430 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 21325 | 33431 | .patterns = &.{ |
| 21326 | | .{ .src = .{ .to_sse, .mem } }, |
| 21327 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 21328 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 33432 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 33433 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 33434 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21329 | 33435 | }, |
| 21330 | 33436 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21331 | 33437 | false => .z_and_np, |
| ... | ... | @@ -21337,11 +33443,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21337 | 33443 | } }, |
| 21338 | 33444 | }, .{ |
| 21339 | 33445 | .required_features = .{ .avx, null, null, null }, |
| 21340 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33446 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21341 | 33447 | .patterns = &.{ |
| 21342 | | .{ .src = .{ .to_sse, .mem } }, |
| 21343 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 21344 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 33448 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 33449 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 33450 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21345 | 33451 | }, |
| 21346 | 33452 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21347 | 33453 | false => .z_and_np, |
| ... | ... | @@ -21353,11 +33459,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21353 | 33459 | } }, |
| 21354 | 33460 | }, .{ |
| 21355 | 33461 | .required_features = .{ .sse2, null, null, null }, |
| 21356 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33462 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21357 | 33463 | .patterns = &.{ |
| 21358 | | .{ .src = .{ .to_sse, .mem } }, |
| 21359 | | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, |
| 21360 | | .{ .src = .{ .to_sse, .to_sse } }, |
| 33464 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 33465 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 33466 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21361 | 33467 | }, |
| 21362 | 33468 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21363 | 33469 | false => .z_and_np, |
| ... | ... | @@ -21369,13 +33475,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21369 | 33475 | } }, |
| 21370 | 33476 | }, .{ |
| 21371 | 33477 | .required_features = .{ .x87, .cmov, null, null }, |
| 21372 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33478 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21373 | 33479 | .patterns = &.{ |
| 21374 | | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, |
| 33480 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 21375 | 33481 | }, |
| 21376 | 33482 | .extra_temps = .{ |
| 21377 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 21378 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 33483 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 33484 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 21379 | 33485 | .unused, |
| 21380 | 33486 | .unused, |
| 21381 | 33487 | .unused, |
| ... | ... | @@ -21397,13 +33503,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21397 | 33503 | } }, |
| 21398 | 33504 | }, .{ |
| 21399 | 33505 | .required_features = .{ .sahf, .x87, null, null }, |
| 21400 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33506 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21401 | 33507 | .patterns = &.{ |
| 21402 | | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, |
| 33508 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 21403 | 33509 | }, |
| 21404 | 33510 | .extra_temps = .{ |
| 21405 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 21406 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 33511 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 33512 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 21407 | 33513 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 21408 | 33514 | .unused, |
| 21409 | 33515 | .unused, |
| ... | ... | @@ -21426,13 +33532,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21426 | 33532 | } }, |
| 21427 | 33533 | }, .{ |
| 21428 | 33534 | .required_features = .{ .x87, null, null, null }, |
| 21429 | | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, |
| 33535 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21430 | 33536 | .patterns = &.{ |
| 21431 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 33537 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 21432 | 33538 | }, |
| 21433 | 33539 | .extra_temps = .{ |
| 21434 | | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 21435 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 33540 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 33541 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 21436 | 33542 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 21437 | 33543 | .unused, |
| 21438 | 33544 | .unused, |
| ... | ... | @@ -21465,11 +33571,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21465 | 33571 | } }, |
| 21466 | 33572 | }, .{ |
| 21467 | 33573 | .required_features = .{ .x87, .cmov, null, null }, |
| 21468 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33574 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21469 | 33575 | .patterns = &.{ |
| 21470 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 21471 | | .{ .src = .{ .mem, .to_x87 } }, |
| 21472 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 33576 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33577 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 33578 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 21473 | 33579 | }, |
| 21474 | 33580 | .extra_temps = .{ |
| 21475 | 33581 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | ... | @@ -21493,9 +33599,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21493 | 33599 | } }, |
| 21494 | 33600 | }, .{ |
| 21495 | 33601 | .required_features = .{ .sahf, .x87, null, null }, |
| 21496 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33602 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21497 | 33603 | .patterns = &.{ |
| 21498 | | .{ .src = .{ .mem, .mem } }, |
| 33604 | .{ .src = .{ .mem, .mem, .none } }, |
| 21499 | 33605 | }, |
| 21500 | 33606 | .extra_temps = .{ |
| 21501 | 33607 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21522,11 +33628,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21522 | 33628 | } }, |
| 21523 | 33629 | }, .{ |
| 21524 | 33630 | .required_features = .{ .sahf, .x87, null, null }, |
| 21525 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33631 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21526 | 33632 | .patterns = &.{ |
| 21527 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 21528 | | .{ .src = .{ .mem, .to_x87 } }, |
| 21529 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 33633 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33634 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 33635 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 21530 | 33636 | }, |
| 21531 | 33637 | .extra_temps = .{ |
| 21532 | 33638 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21552,9 +33658,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21552 | 33658 | } }, |
| 21553 | 33659 | }, .{ |
| 21554 | 33660 | .required_features = .{ .x87, null, null, null }, |
| 21555 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33661 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21556 | 33662 | .patterns = &.{ |
| 21557 | | .{ .src = .{ .mem, .mem } }, |
| 33663 | .{ .src = .{ .mem, .mem, .none } }, |
| 21558 | 33664 | }, |
| 21559 | 33665 | .extra_temps = .{ |
| 21560 | 33666 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21591,11 +33697,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21591 | 33697 | } }, |
| 21592 | 33698 | }, .{ |
| 21593 | 33699 | .required_features = .{ .x87, null, null, null }, |
| 21594 | | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, |
| 33700 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21595 | 33701 | .patterns = &.{ |
| 21596 | | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, |
| 21597 | | .{ .src = .{ .mem, .to_x87 } }, |
| 21598 | | .{ .src = .{ .to_x87, .to_x87 } }, |
| 33702 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 33703 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 33704 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 21599 | 33705 | }, |
| 21600 | 33706 | .extra_temps = .{ |
| 21601 | 33707 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | ... | @@ -21630,9 +33736,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21630 | 33736 | } }, |
| 21631 | 33737 | }, .{ |
| 21632 | 33738 | .required_features = .{ .sse, null, null, null }, |
| 21633 | | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword } }, |
| 33739 | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any }, |
| 21634 | 33740 | .patterns = &.{ |
| 21635 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, |
| 33741 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 21636 | 33742 | }, |
| 21637 | 33743 | .call_frame = .{ .alignment = .@"16" }, |
| 21638 | 33744 | .extra_temps = .{ |
| ... | ... | @@ -21663,278 +33769,1020 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21663 | 33769 | }, |
| 21664 | 33770 | } |
| 21665 | 33771 | }, |
| 21666 | | .int => res[0] = ops[0].cmpInts(cmp_op, &ops[1], cg) catch |err| break :err err, |
| 21667 | | }) catch |err| switch (err) { |
| 21668 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 21669 | | @tagName(air_tag), |
| 21670 | | cg.typeOf(bin_op.lhs).fmt(pt), |
| 21671 | | ops[0].tracking(cg), |
| 21672 | | ops[1].tracking(cg), |
| 21673 | | }), |
| 21674 | | else => |e| return e, |
| 21675 | | }; |
| 21676 | | if (opt_info) |*oi| { |
| 21677 | | for (ops) |op| for (res) |r| { |
| 21678 | | if (op.index == r.index) break; |
| 21679 | | } else try op.die(cg); |
| 21680 | | try cg.genCopy(.bool, oi.res[0].tracking(cg).short, res[0].tracking(cg).short, .{}); |
| 21681 | | try res[0].die(cg); |
| 21682 | | res[0] = oi.res[0]; |
| 21683 | | try cg.restoreState(oi.state, &oi.deaths, .{ |
| 21684 | | .emit_instructions = true, |
| 21685 | | .update_tracking = true, |
| 21686 | | .resurrect = true, |
| 21687 | | .close_scope = true, |
| 21688 | | }); |
| 21689 | | cg.performReloc(oi.reloc); |
| 21690 | | @memset(&ops, res[0]); |
| 21691 | | } |
| 21692 | | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 21693 | | }, |
| 21694 | | |
| 21695 | | .cond_br => try cg.airCondBr(inst), |
| 21696 | | .switch_br => try cg.airSwitchBr(inst), |
| 21697 | | .loop_switch_br => try cg.airLoopSwitchBr(inst), |
| 21698 | | .switch_dispatch => try cg.airSwitchDispatch(inst), |
| 21699 | | .@"try", .try_cold => try cg.airTry(inst), |
| 21700 | | .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), |
| 21701 | | .dbg_stmt => if (cg.debug_output != .none) { |
| 21702 | | const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; |
| 21703 | | _ = try cg.addInst(.{ |
| 21704 | | .tag = .pseudo, |
| 21705 | | .ops = .pseudo_dbg_line_stmt_line_column, |
| 21706 | | .data = .{ .line_column = .{ |
| 21707 | | .line = dbg_stmt.line, |
| 21708 | | .column = dbg_stmt.column, |
| 33772 | .int => res[0] = ops[0].cmpInts(cmp_op, &ops[1], cg) catch |err| break :err err, |
| 33773 | }) catch |err| switch (err) { |
| 33774 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 33775 | @tagName(air_tag), |
| 33776 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 33777 | ops[0].tracking(cg), |
| 33778 | ops[1].tracking(cg), |
| 33779 | }), |
| 33780 | else => |e| return e, |
| 33781 | }; |
| 33782 | if (opt_info) |*oi| { |
| 33783 | for (ops) |op| for (res) |r| { |
| 33784 | if (op.index == r.index) break; |
| 33785 | } else try op.die(cg); |
| 33786 | try cg.genCopy(.bool, oi.res[0].tracking(cg).short, res[0].tracking(cg).short, .{}); |
| 33787 | try res[0].die(cg); |
| 33788 | res[0] = oi.res[0]; |
| 33789 | try cg.restoreState(oi.state, &oi.deaths, .{ |
| 33790 | .emit_instructions = true, |
| 33791 | .update_tracking = true, |
| 33792 | .resurrect = true, |
| 33793 | .close_scope = true, |
| 33794 | }); |
| 33795 | cg.performReloc(oi.reloc); |
| 33796 | @memset(&ops, res[0]); |
| 33797 | } |
| 33798 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 33799 | }, |
| 33800 | |
| 33801 | .cond_br => try cg.airCondBr(inst), |
| 33802 | .switch_br => try cg.airSwitchBr(inst), |
| 33803 | .loop_switch_br => try cg.airLoopSwitchBr(inst), |
| 33804 | .switch_dispatch => try cg.airSwitchDispatch(inst), |
| 33805 | .@"try", .try_cold => try cg.airTry(inst), |
| 33806 | .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), |
| 33807 | .dbg_stmt => if (cg.debug_output != .none) { |
| 33808 | const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; |
| 33809 | _ = try cg.addInst(.{ |
| 33810 | .tag = .pseudo, |
| 33811 | .ops = .pseudo_dbg_line_stmt_line_column, |
| 33812 | .data = .{ .line_column = .{ |
| 33813 | .line = dbg_stmt.line, |
| 33814 | .column = dbg_stmt.column, |
| 33815 | } }, |
| 33816 | }); |
| 33817 | }, |
| 33818 | .dbg_empty_stmt => if (cg.debug_output != .none) { |
| 33819 | if (cg.mir_instructions.len > 0) { |
| 33820 | const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1]; |
| 33821 | if (prev_mir_op.* == .pseudo_dbg_line_line_column) |
| 33822 | prev_mir_op.* = .pseudo_dbg_line_stmt_line_column; |
| 33823 | } |
| 33824 | try cg.asmOpOnly(.{ ._, .nop }); |
| 33825 | }, |
| 33826 | .dbg_inline_block => { |
| 33827 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 33828 | const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); |
| 33829 | const old_inline_func = cg.inline_func; |
| 33830 | defer cg.inline_func = old_inline_func; |
| 33831 | cg.inline_func = extra.data.func; |
| 33832 | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 33833 | .tag = .pseudo, |
| 33834 | .ops = .pseudo_dbg_enter_inline_func, |
| 33835 | .data = .{ .func = extra.data.func }, |
| 33836 | }); |
| 33837 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); |
| 33838 | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 33839 | .tag = .pseudo, |
| 33840 | .ops = .pseudo_dbg_leave_inline_func, |
| 33841 | .data = .{ .func = old_inline_func }, |
| 33842 | }); |
| 33843 | }, |
| 33844 | .dbg_var_ptr, |
| 33845 | .dbg_var_val, |
| 33846 | .dbg_arg_inline, |
| 33847 | => if (use_old) try cg.airDbgVar(inst) else if (cg.debug_output != .none) { |
| 33848 | const pl_op = air_datas[@intFromEnum(inst)].pl_op; |
| 33849 | var ops = try cg.tempsFromOperands(inst, .{pl_op.operand}); |
| 33850 | var mcv = ops[0].tracking(cg).short; |
| 33851 | switch (mcv) { |
| 33852 | else => {}, |
| 33853 | .eflags => |cc| switch (cc) { |
| 33854 | else => {}, |
| 33855 | // These values would self destruct. Maybe we make them use their |
| 33856 | // turing complete dwarf expression interpreters for once? |
| 33857 | .z_and_np, .nz_or_p => { |
| 33858 | try cg.spillEflagsIfOccupied(); |
| 33859 | mcv = ops[0].tracking(cg).short; |
| 33860 | }, |
| 33861 | }, |
| 33862 | } |
| 33863 | try cg.genLocalDebugInfo(inst, ops[0].tracking(cg).short); |
| 33864 | try ops[0].die(cg); |
| 33865 | }, |
| 33866 | .is_null_ptr => if (use_old) try cg.airIsNullPtr(inst) else { |
| 33867 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 33868 | const opt_ty = cg.typeOf(un_op).childType(zcu); |
| 33869 | const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); |
| 33870 | const opt_child_ty = opt_ty.optionalChild(zcu); |
| 33871 | const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu)); |
| 33872 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 33873 | if (!opt_repr_is_pl) try ops[0].toOffset(opt_child_abi_size, cg); |
| 33874 | while (try ops[0].toLea(cg)) {} |
| 33875 | try cg.asmMemoryImmediate( |
| 33876 | .{ ._, .cmp }, |
| 33877 | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = if (!opt_repr_is_pl) |
| 33878 | .byte |
| 33879 | else if (opt_child_ty.isSlice(zcu)) |
| 33880 | .qword |
| 33881 | else |
| 33882 | .fromSize(opt_child_abi_size) }), |
| 33883 | .u(0), |
| 33884 | ); |
| 33885 | const is_null = try cg.tempInit(.bool, .{ .eflags = .e }); |
| 33886 | try is_null.finish(inst, &.{un_op}, &ops, cg); |
| 33887 | }, |
| 33888 | .is_non_null_ptr => if (use_old) try cg.airIsNonNullPtr(inst) else { |
| 33889 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 33890 | const opt_ty = cg.typeOf(un_op).childType(zcu); |
| 33891 | const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); |
| 33892 | const opt_child_ty = opt_ty.optionalChild(zcu); |
| 33893 | const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu)); |
| 33894 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 33895 | if (!opt_repr_is_pl) try ops[0].toOffset(opt_child_abi_size, cg); |
| 33896 | while (try ops[0].toLea(cg)) {} |
| 33897 | try cg.asmMemoryImmediate( |
| 33898 | .{ ._, .cmp }, |
| 33899 | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = if (!opt_repr_is_pl) |
| 33900 | .byte |
| 33901 | else if (opt_child_ty.isSlice(zcu)) |
| 33902 | .qword |
| 33903 | else |
| 33904 | .fromSize(opt_child_abi_size) }), |
| 33905 | .u(0), |
| 33906 | ); |
| 33907 | const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne }); |
| 33908 | try is_non_null.finish(inst, &.{un_op}, &ops, cg); |
| 33909 | }, |
| 33910 | .is_err_ptr => if (use_old) try cg.airIsErrPtr(inst) else { |
| 33911 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 33912 | const eu_ty = cg.typeOf(un_op).childType(zcu); |
| 33913 | const eu_err_ty = eu_ty.errorUnionSet(zcu); |
| 33914 | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 33915 | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 33916 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 33917 | try ops[0].toOffset(eu_err_off, cg); |
| 33918 | while (try ops[0].toLea(cg)) {} |
| 33919 | try cg.asmMemoryImmediate( |
| 33920 | .{ ._, .cmp }, |
| 33921 | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }), |
| 33922 | .u(0), |
| 33923 | ); |
| 33924 | const is_err = try cg.tempInit(.bool, .{ .eflags = .ne }); |
| 33925 | try is_err.finish(inst, &.{un_op}, &ops, cg); |
| 33926 | }, |
| 33927 | .is_non_err_ptr => if (use_old) try cg.airIsNonErrPtr(inst) else { |
| 33928 | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 33929 | const eu_ty = cg.typeOf(un_op).childType(zcu); |
| 33930 | const eu_err_ty = eu_ty.errorUnionSet(zcu); |
| 33931 | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 33932 | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 33933 | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 33934 | try ops[0].toOffset(eu_err_off, cg); |
| 33935 | while (try ops[0].toLea(cg)) {} |
| 33936 | try cg.asmMemoryImmediate( |
| 33937 | .{ ._, .cmp }, |
| 33938 | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }), |
| 33939 | .u(0), |
| 33940 | ); |
| 33941 | const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); |
| 33942 | try is_non_err.finish(inst, &.{un_op}, &ops, cg); |
| 33943 | }, |
| 33944 | .load => if (use_old) try cg.airLoad(inst) else fallback: { |
| 33945 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 33946 | const val_ty = ty_op.ty.toType(); |
| 33947 | const ptr_ty = cg.typeOf(ty_op.operand); |
| 33948 | const ptr_info = ptr_ty.ptrInfo(zcu); |
| 33949 | if (ptr_info.packed_offset.host_size > 0 and |
| 33950 | (ptr_info.flags.vector_index == .none or val_ty.toIntern() == .bool_type)) |
| 33951 | break :fallback try cg.airLoad(inst); |
| 33952 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 33953 | const res = try ops[0].load(val_ty, .{ |
| 33954 | .disp = switch (ptr_info.flags.vector_index) { |
| 33955 | .none => 0, |
| 33956 | .runtime => unreachable, |
| 33957 | else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), |
| 33958 | }, |
| 33959 | }, cg); |
| 33960 | try res.finish(inst, &.{ty_op.operand}, &ops, cg); |
| 33961 | }, |
| 33962 | .ret => try cg.airRet(inst, false), |
| 33963 | .ret_safe => try cg.airRet(inst, true), |
| 33964 | .ret_load => try cg.airRetLoad(inst), |
| 33965 | .store, .store_safe => |air_tag| if (use_old) try cg.airStore(inst, switch (air_tag) { |
| 33966 | else => unreachable, |
| 33967 | .store => false, |
| 33968 | .store_safe => true, |
| 33969 | }) else fallback: { |
| 33970 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 33971 | const ptr_ty = cg.typeOf(bin_op.lhs); |
| 33972 | const ptr_info = ptr_ty.ptrInfo(zcu); |
| 33973 | const val_ty = cg.typeOf(bin_op.rhs); |
| 33974 | if (ptr_info.packed_offset.host_size > 0 and |
| 33975 | (ptr_info.flags.vector_index == .none or val_ty.toIntern() == .bool_type)) |
| 33976 | break :fallback try cg.airStore(inst, switch (air_tag) { |
| 33977 | else => unreachable, |
| 33978 | .store => false, |
| 33979 | .store_safe => true, |
| 33980 | }); |
| 33981 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 33982 | try ops[0].store(&ops[1], .{ |
| 33983 | .disp = switch (ptr_info.flags.vector_index) { |
| 33984 | .none => 0, |
| 33985 | .runtime => unreachable, |
| 33986 | else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), |
| 33987 | }, |
| 33988 | .safe = switch (air_tag) { |
| 33989 | else => unreachable, |
| 33990 | .store => false, |
| 33991 | .store_safe => true, |
| 33992 | }, |
| 33993 | }, cg); |
| 33994 | for (ops) |op| try op.die(cg); |
| 33995 | }, |
| 33996 | .unreach => {}, |
| 33997 | .fptrunc => |air_tag| if (use_old) try cg.airFptrunc(inst) else { |
| 33998 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 33999 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34000 | var res: [1]Temp = undefined; |
| 34001 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 34002 | .required_features = .{ .f16c, null, null, null }, |
| 34003 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 34004 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34005 | .patterns = &.{ |
| 34006 | .{ .src = .{ .to_sse, .none, .none } }, |
| 34007 | }, |
| 34008 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34009 | .each = .{ .once = &.{ |
| 34010 | .{ ._, .v_, .cvtps2ph, .dst0q, .src0x, .rm(.{}), ._ }, |
| 34011 | } }, |
| 34012 | }, .{ |
| 34013 | .required_features = .{ .f16c, null, null, null }, |
| 34014 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 34015 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 34016 | .patterns = &.{ |
| 34017 | .{ .src = .{ .to_sse, .none, .none } }, |
| 34018 | }, |
| 34019 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34020 | .each = .{ .once = &.{ |
| 34021 | .{ ._, .v_, .cvtps2ph, .dst0q, .src0x, .rm(.{}), ._ }, |
| 34022 | } }, |
| 34023 | }, .{ |
| 34024 | .required_features = .{ .f16c, null, null, null }, |
| 34025 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 34026 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 34027 | .patterns = &.{ |
| 34028 | .{ .src = .{ .to_sse, .none, .none } }, |
| 34029 | }, |
| 34030 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34031 | .each = .{ .once = &.{ |
| 34032 | .{ ._, .v_, .cvtps2ph, .dst0x, .src0y, .rm(.{}), ._ }, |
| 34033 | } }, |
| 34034 | }, .{ |
| 34035 | .required_features = .{ .sse, null, null, null }, |
| 34036 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 34037 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34038 | .patterns = &.{ |
| 34039 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 34040 | }, |
| 34041 | .call_frame = .{ .alignment = .@"16" }, |
| 34042 | .extra_temps = .{ |
| 34043 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34044 | .unused, |
| 34045 | .unused, |
| 34046 | .unused, |
| 34047 | .unused, |
| 34048 | .unused, |
| 34049 | .unused, |
| 34050 | .unused, |
| 34051 | .unused, |
| 34052 | }, |
| 34053 | .dst_temps = .{.{ .ref = .src0 }}, |
| 34054 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34055 | .each = .{ .once = &.{ |
| 34056 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 34057 | } }, |
| 34058 | }, .{ |
| 34059 | .required_features = .{ .f16c, null, null, null }, |
| 34060 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 34061 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 34062 | .patterns = &.{ |
| 34063 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34064 | }, |
| 34065 | .extra_temps = .{ |
| 34066 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34067 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 34068 | .unused, |
| 34069 | .unused, |
| 34070 | .unused, |
| 34071 | .unused, |
| 34072 | .unused, |
| 34073 | .unused, |
| 34074 | .unused, |
| 34075 | }, |
| 34076 | .dst_temps = .{.mem}, |
| 34077 | .clobbers = .{ .eflags = true }, |
| 34078 | .each = .{ .once = &.{ |
| 34079 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34080 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34081 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 34082 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 34083 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34084 | } }, |
| 34085 | }, .{ |
| 34086 | .required_features = .{ .avx, null, null, null }, |
| 34087 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 34088 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34089 | .patterns = &.{ |
| 34090 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34091 | }, |
| 34092 | .call_frame = .{ .alignment = .@"16" }, |
| 34093 | .extra_temps = .{ |
| 34094 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34095 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 34096 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34097 | .unused, |
| 34098 | .unused, |
| 34099 | .unused, |
| 34100 | .unused, |
| 34101 | .unused, |
| 34102 | .unused, |
| 34103 | }, |
| 34104 | .dst_temps = .{.mem}, |
| 34105 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34106 | .each = .{ .once = &.{ |
| 34107 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34108 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34109 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34110 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 34111 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34112 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34113 | } }, |
| 34114 | }, .{ |
| 34115 | .required_features = .{ .sse4_1, null, null, null }, |
| 34116 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 34117 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34118 | .patterns = &.{ |
| 34119 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34120 | }, |
| 34121 | .call_frame = .{ .alignment = .@"16" }, |
| 34122 | .extra_temps = .{ |
| 34123 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34124 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 34125 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34126 | .unused, |
| 34127 | .unused, |
| 34128 | .unused, |
| 34129 | .unused, |
| 34130 | .unused, |
| 34131 | .unused, |
| 34132 | }, |
| 34133 | .dst_temps = .{.mem}, |
| 34134 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34135 | .each = .{ .once = &.{ |
| 34136 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34137 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34138 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34139 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 34140 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34141 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34142 | } }, |
| 34143 | }, .{ |
| 34144 | .required_features = .{ .sse2, null, null, null }, |
| 34145 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 34146 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34147 | .patterns = &.{ |
| 34148 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34149 | }, |
| 34150 | .call_frame = .{ .alignment = .@"16" }, |
| 34151 | .extra_temps = .{ |
| 34152 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34153 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 34154 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34155 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 34156 | .unused, |
| 34157 | .unused, |
| 34158 | .unused, |
| 34159 | .unused, |
| 34160 | .unused, |
| 34161 | }, |
| 34162 | .dst_temps = .{.mem}, |
| 34163 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34164 | .each = .{ .once = &.{ |
| 34165 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34166 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34167 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34168 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 34169 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 34170 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34171 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34172 | } }, |
| 34173 | }, .{ |
| 34174 | .required_features = .{ .sse, null, null, null }, |
| 34175 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 34176 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34177 | .patterns = &.{ |
| 34178 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34179 | }, |
| 34180 | .call_frame = .{ .alignment = .@"16" }, |
| 34181 | .extra_temps = .{ |
| 34182 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34183 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 34184 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34185 | .{ .type = .f32, .kind = .mem }, |
| 34186 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 34187 | .unused, |
| 34188 | .unused, |
| 34189 | .unused, |
| 34190 | .unused, |
| 34191 | }, |
| 34192 | .dst_temps = .{.mem}, |
| 34193 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34194 | .each = .{ .once = &.{ |
| 34195 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34196 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34197 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34198 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, |
| 34199 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, |
| 34200 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 34201 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34202 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34203 | } }, |
| 34204 | }, .{ |
| 34205 | .required_features = .{ .sse, null, null, null }, |
| 34206 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34207 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34208 | .patterns = &.{ |
| 34209 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 34210 | }, |
| 34211 | .call_frame = .{ .alignment = .@"16" }, |
| 34212 | .extra_temps = .{ |
| 34213 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 34214 | .unused, |
| 34215 | .unused, |
| 34216 | .unused, |
| 34217 | .unused, |
| 34218 | .unused, |
| 34219 | .unused, |
| 34220 | .unused, |
| 34221 | .unused, |
| 34222 | }, |
| 34223 | .dst_temps = .{.{ .ref = .src0 }}, |
| 34224 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34225 | .each = .{ .once = &.{ |
| 34226 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 34227 | } }, |
| 34228 | }, .{ |
| 34229 | .required_features = .{ .avx, null, null, null }, |
| 34230 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34231 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34232 | .patterns = &.{ |
| 34233 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34234 | }, |
| 34235 | .call_frame = .{ .alignment = .@"16" }, |
| 34236 | .extra_temps = .{ |
| 34237 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34238 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 34239 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 34240 | .unused, |
| 34241 | .unused, |
| 34242 | .unused, |
| 34243 | .unused, |
| 34244 | .unused, |
| 34245 | .unused, |
| 34246 | }, |
| 34247 | .dst_temps = .{.mem}, |
| 34248 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34249 | .each = .{ .once = &.{ |
| 34250 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34251 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34252 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34253 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 34254 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34255 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34256 | } }, |
| 34257 | }, .{ |
| 34258 | .required_features = .{ .sse4_1, null, null, null }, |
| 34259 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34260 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34261 | .patterns = &.{ |
| 34262 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34263 | }, |
| 34264 | .call_frame = .{ .alignment = .@"16" }, |
| 34265 | .extra_temps = .{ |
| 34266 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34267 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 34268 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 34269 | .unused, |
| 34270 | .unused, |
| 34271 | .unused, |
| 34272 | .unused, |
| 34273 | .unused, |
| 34274 | .unused, |
| 34275 | }, |
| 34276 | .dst_temps = .{.mem}, |
| 34277 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34278 | .each = .{ .once = &.{ |
| 34279 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34280 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34281 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34282 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 34283 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34284 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34285 | } }, |
| 34286 | }, .{ |
| 34287 | .required_features = .{ .sse2, null, null, null }, |
| 34288 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34289 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34290 | .patterns = &.{ |
| 34291 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34292 | }, |
| 34293 | .call_frame = .{ .alignment = .@"16" }, |
| 34294 | .extra_temps = .{ |
| 34295 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34296 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 34297 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 34298 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 34299 | .unused, |
| 34300 | .unused, |
| 34301 | .unused, |
| 34302 | .unused, |
| 34303 | .unused, |
| 34304 | }, |
| 34305 | .dst_temps = .{.mem}, |
| 34306 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34307 | .each = .{ .once = &.{ |
| 34308 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34309 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34310 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34311 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 34312 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 34313 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34314 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34315 | } }, |
| 34316 | }, .{ |
| 34317 | .required_features = .{ .sse, null, null, null }, |
| 34318 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34319 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34320 | .patterns = &.{ |
| 34321 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34322 | }, |
| 34323 | .call_frame = .{ .alignment = .@"16" }, |
| 34324 | .extra_temps = .{ |
| 34325 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34326 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 34327 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 34328 | .{ .type = .f32, .kind = .mem }, |
| 34329 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 34330 | .unused, |
| 34331 | .unused, |
| 34332 | .unused, |
| 34333 | .unused, |
| 34334 | }, |
| 34335 | .dst_temps = .{.mem}, |
| 34336 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34337 | .each = .{ .once = &.{ |
| 34338 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34339 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 34340 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34341 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34342 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, |
| 34343 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, |
| 34344 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 34345 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34346 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34347 | } }, |
| 34348 | }, .{ |
| 34349 | .required_features = .{ .avx, null, null, null }, |
| 34350 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34351 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 34352 | .patterns = &.{ |
| 34353 | .{ .src = .{ .mem, .none, .none } }, |
| 34354 | }, |
| 34355 | .dst_temps = .{.{ .rc = .sse }}, |
| 34356 | .each = .{ .once = &.{ |
| 34357 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 34358 | .{ ._, .v_ss, .cvtsd2, .dst0x, .dst0x, .src0q, ._ }, |
| 34359 | } }, |
| 34360 | }, .{ |
| 34361 | .required_features = .{ .avx, null, null, null }, |
| 34362 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34363 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 34364 | .patterns = &.{ |
| 34365 | .{ .src = .{ .to_sse, .none, .none } }, |
| 34366 | }, |
| 34367 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34368 | .each = .{ .once = &.{ |
| 34369 | .{ ._, .v_ss, .cvtsd2, .dst0x, .src0x, .src0q, ._ }, |
| 34370 | } }, |
| 34371 | }, .{ |
| 34372 | .required_features = .{ .sse2, null, null, null }, |
| 34373 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34374 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 34375 | .patterns = &.{ |
| 34376 | .{ .src = .{ .mem, .none, .none } }, |
| 34377 | .{ .src = .{ .to_sse, .none, .none } }, |
| 34378 | }, |
| 34379 | .dst_temps = .{.{ .rc = .sse }}, |
| 34380 | .each = .{ .once = &.{ |
| 34381 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 34382 | .{ ._, ._ss, .cvtsd2, .dst0x, .src0q, ._, ._ }, |
| 34383 | } }, |
| 34384 | }, .{ |
| 34385 | .required_features = .{ .x87, null, null, null }, |
| 34386 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34387 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 34388 | .patterns = &.{ |
| 34389 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34390 | }, |
| 34391 | .extra_temps = .{ |
| 34392 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 34393 | .unused, |
| 34394 | .unused, |
| 34395 | .unused, |
| 34396 | .unused, |
| 34397 | .unused, |
| 34398 | .unused, |
| 34399 | .unused, |
| 34400 | .unused, |
| 34401 | }, |
| 34402 | .dst_temps = .{.mem}, |
| 34403 | .each = .{ .once = &.{ |
| 34404 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 34405 | .{ ._, .f_p, .st, .dst0d, ._, ._, ._ }, |
| 21709 | 34406 | } }, |
| 21710 | | }); |
| 21711 | | }, |
| 21712 | | .dbg_empty_stmt => if (cg.debug_output != .none) { |
| 21713 | | if (cg.mir_instructions.len > 0) { |
| 21714 | | const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1]; |
| 21715 | | if (prev_mir_op.* == .pseudo_dbg_line_line_column) |
| 21716 | | prev_mir_op.* = .pseudo_dbg_line_stmt_line_column; |
| 21717 | | } |
| 21718 | | try cg.asmOpOnly(.{ ._, .nop }); |
| 21719 | | }, |
| 21720 | | .dbg_inline_block => { |
| 21721 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 21722 | | const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); |
| 21723 | | const old_inline_func = cg.inline_func; |
| 21724 | | defer cg.inline_func = old_inline_func; |
| 21725 | | cg.inline_func = extra.data.func; |
| 21726 | | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 21727 | | .tag = .pseudo, |
| 21728 | | .ops = .pseudo_dbg_enter_inline_func, |
| 21729 | | .data = .{ .func = extra.data.func }, |
| 21730 | | }); |
| 21731 | | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); |
| 21732 | | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 21733 | | .tag = .pseudo, |
| 21734 | | .ops = .pseudo_dbg_leave_inline_func, |
| 21735 | | .data = .{ .func = old_inline_func }, |
| 21736 | | }); |
| 21737 | | }, |
| 21738 | | .dbg_var_ptr, |
| 21739 | | .dbg_var_val, |
| 21740 | | .dbg_arg_inline, |
| 21741 | | => if (use_old) try cg.airDbgVar(inst) else if (cg.debug_output != .none) { |
| 21742 | | const pl_op = air_datas[@intFromEnum(inst)].pl_op; |
| 21743 | | var ops = try cg.tempsFromOperands(inst, .{pl_op.operand}); |
| 21744 | | var mcv = ops[0].tracking(cg).short; |
| 21745 | | switch (mcv) { |
| 21746 | | else => {}, |
| 21747 | | .eflags => |cc| switch (cc) { |
| 21748 | | else => {}, |
| 21749 | | // These values would self destruct. Maybe we make them use their |
| 21750 | | // turing complete dwarf expression interpreters for once? |
| 21751 | | .z_and_np, .nz_or_p => { |
| 21752 | | try cg.spillEflagsIfOccupied(); |
| 21753 | | mcv = ops[0].tracking(cg).short; |
| 21754 | | }, |
| 34407 | }, .{ |
| 34408 | .required_features = .{ .avx, null, null, null }, |
| 34409 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 34410 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, |
| 34411 | .patterns = &.{ |
| 34412 | .{ .src = .{ .mem, .none, .none } }, |
| 34413 | .{ .src = .{ .to_sse, .none, .none } }, |
| 21755 | 34414 | }, |
| 21756 | | } |
| 21757 | | try cg.genLocalDebugInfo(inst, ops[0].tracking(cg).short); |
| 21758 | | try ops[0].die(cg); |
| 21759 | | }, |
| 21760 | | .is_null_ptr => if (use_old) try cg.airIsNullPtr(inst) else { |
| 21761 | | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 21762 | | const opt_ty = cg.typeOf(un_op).childType(zcu); |
| 21763 | | const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); |
| 21764 | | const opt_child_ty = opt_ty.optionalChild(zcu); |
| 21765 | | const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu)); |
| 21766 | | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 21767 | | if (!opt_repr_is_pl) try ops[0].toOffset(opt_child_abi_size, cg); |
| 21768 | | while (try ops[0].toLea(cg)) {} |
| 21769 | | try cg.asmMemoryImmediate( |
| 21770 | | .{ ._, .cmp }, |
| 21771 | | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = if (!opt_repr_is_pl) |
| 21772 | | .byte |
| 21773 | | else if (opt_child_ty.isSlice(zcu)) |
| 21774 | | .qword |
| 21775 | | else |
| 21776 | | .fromSize(opt_child_abi_size) }), |
| 21777 | | .u(0), |
| 21778 | | ); |
| 21779 | | const is_null = try cg.tempInit(.bool, .{ .eflags = .e }); |
| 21780 | | try is_null.finish(inst, &.{un_op}, &ops, cg); |
| 21781 | | }, |
| 21782 | | .is_non_null_ptr => if (use_old) try cg.airIsNonNullPtr(inst) else { |
| 21783 | | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 21784 | | const opt_ty = cg.typeOf(un_op).childType(zcu); |
| 21785 | | const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); |
| 21786 | | const opt_child_ty = opt_ty.optionalChild(zcu); |
| 21787 | | const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu)); |
| 21788 | | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 21789 | | if (!opt_repr_is_pl) try ops[0].toOffset(opt_child_abi_size, cg); |
| 21790 | | while (try ops[0].toLea(cg)) {} |
| 21791 | | try cg.asmMemoryImmediate( |
| 21792 | | .{ ._, .cmp }, |
| 21793 | | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = if (!opt_repr_is_pl) |
| 21794 | | .byte |
| 21795 | | else if (opt_child_ty.isSlice(zcu)) |
| 21796 | | .qword |
| 21797 | | else |
| 21798 | | .fromSize(opt_child_abi_size) }), |
| 21799 | | .u(0), |
| 21800 | | ); |
| 21801 | | const is_non_null = try cg.tempInit(.bool, .{ .eflags = .ne }); |
| 21802 | | try is_non_null.finish(inst, &.{un_op}, &ops, cg); |
| 21803 | | }, |
| 21804 | | .is_err_ptr => if (use_old) try cg.airIsErrPtr(inst) else { |
| 21805 | | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 21806 | | const eu_ty = cg.typeOf(un_op).childType(zcu); |
| 21807 | | const eu_err_ty = eu_ty.errorUnionSet(zcu); |
| 21808 | | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 21809 | | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 21810 | | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 21811 | | try ops[0].toOffset(eu_err_off, cg); |
| 21812 | | while (try ops[0].toLea(cg)) {} |
| 21813 | | try cg.asmMemoryImmediate( |
| 21814 | | .{ ._, .cmp }, |
| 21815 | | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }), |
| 21816 | | .u(0), |
| 21817 | | ); |
| 21818 | | const is_err = try cg.tempInit(.bool, .{ .eflags = .ne }); |
| 21819 | | try is_err.finish(inst, &.{un_op}, &ops, cg); |
| 21820 | | }, |
| 21821 | | .is_non_err_ptr => if (use_old) try cg.airIsNonErrPtr(inst) else { |
| 21822 | | const un_op = air_datas[@intFromEnum(inst)].un_op; |
| 21823 | | const eu_ty = cg.typeOf(un_op).childType(zcu); |
| 21824 | | const eu_err_ty = eu_ty.errorUnionSet(zcu); |
| 21825 | | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 21826 | | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 21827 | | var ops = try cg.tempsFromOperands(inst, .{un_op}); |
| 21828 | | try ops[0].toOffset(eu_err_off, cg); |
| 21829 | | while (try ops[0].toLea(cg)) {} |
| 21830 | | try cg.asmMemoryImmediate( |
| 21831 | | .{ ._, .cmp }, |
| 21832 | | try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }), |
| 21833 | | .u(0), |
| 21834 | | ); |
| 21835 | | const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e }); |
| 21836 | | try is_non_err.finish(inst, &.{un_op}, &ops, cg); |
| 21837 | | }, |
| 21838 | | .load => if (use_old) try cg.airLoad(inst) else fallback: { |
| 21839 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 21840 | | const val_ty = ty_op.ty.toType(); |
| 21841 | | const ptr_ty = cg.typeOf(ty_op.operand); |
| 21842 | | const ptr_info = ptr_ty.ptrInfo(zcu); |
| 21843 | | if (ptr_info.packed_offset.host_size > 0 and |
| 21844 | | (ptr_info.flags.vector_index == .none or val_ty.toIntern() == .bool_type)) |
| 21845 | | break :fallback try cg.airLoad(inst); |
| 21846 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 21847 | | const res = try ops[0].load(val_ty, .{ |
| 21848 | | .disp = switch (ptr_info.flags.vector_index) { |
| 21849 | | .none => 0, |
| 21850 | | .runtime => unreachable, |
| 21851 | | else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), |
| 34415 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34416 | .each = .{ .once = &.{ |
| 34417 | .{ ._, .v_ps, .cvtpd2, .dst0x, .src0x, ._, ._ }, |
| 34418 | } }, |
| 34419 | }, .{ |
| 34420 | .required_features = .{ .sse2, null, null, null }, |
| 34421 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 34422 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, |
| 34423 | .patterns = &.{ |
| 34424 | .{ .src = .{ .mem, .none, .none } }, |
| 34425 | .{ .src = .{ .to_sse, .none, .none } }, |
| 21852 | 34426 | }, |
| 21853 | | }, cg); |
| 21854 | | try res.finish(inst, &.{ty_op.operand}, &ops, cg); |
| 21855 | | }, |
| 21856 | | .ret => try cg.airRet(inst, false), |
| 21857 | | .ret_safe => try cg.airRet(inst, true), |
| 21858 | | .ret_load => try cg.airRetLoad(inst), |
| 21859 | | .store, .store_safe => |air_tag| if (use_old) try cg.airStore(inst, switch (air_tag) { |
| 21860 | | else => unreachable, |
| 21861 | | .store => false, |
| 21862 | | .store_safe => true, |
| 21863 | | }) else fallback: { |
| 21864 | | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 21865 | | const ptr_ty = cg.typeOf(bin_op.lhs); |
| 21866 | | const ptr_info = ptr_ty.ptrInfo(zcu); |
| 21867 | | const val_ty = cg.typeOf(bin_op.rhs); |
| 21868 | | if (ptr_info.packed_offset.host_size > 0 and |
| 21869 | | (ptr_info.flags.vector_index == .none or val_ty.toIntern() == .bool_type)) |
| 21870 | | break :fallback try cg.airStore(inst, switch (air_tag) { |
| 21871 | | else => unreachable, |
| 21872 | | .store => false, |
| 21873 | | .store_safe => true, |
| 21874 | | }); |
| 21875 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 21876 | | try ops[0].store(&ops[1], .{ |
| 21877 | | .disp = switch (ptr_info.flags.vector_index) { |
| 21878 | | .none => 0, |
| 21879 | | .runtime => unreachable, |
| 21880 | | else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), |
| 34427 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34428 | .each = .{ .once = &.{ |
| 34429 | .{ ._, ._ps, .cvtpd2, .dst0x, .src0x, ._, ._ }, |
| 34430 | } }, |
| 34431 | }, .{ |
| 34432 | .required_features = .{ .avx, null, null, null }, |
| 34433 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 34434 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 34435 | .patterns = &.{ |
| 34436 | .{ .src = .{ .mem, .none, .none } }, |
| 34437 | .{ .src = .{ .to_sse, .none, .none } }, |
| 21881 | 34438 | }, |
| 21882 | | .safe = switch (air_tag) { |
| 21883 | | else => unreachable, |
| 21884 | | .store => false, |
| 21885 | | .store_safe => true, |
| 34439 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34440 | .each = .{ .once = &.{ |
| 34441 | .{ ._, .v_ps, .cvtpd2, .dst0x, .src0y, ._, ._ }, |
| 34442 | } }, |
| 34443 | }, .{ |
| 34444 | .required_features = .{ .avx, null, null, null }, |
| 34445 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 34446 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 34447 | .patterns = &.{ |
| 34448 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21886 | 34449 | }, |
| 21887 | | }, cg); |
| 21888 | | for (ops) |op| try op.die(cg); |
| 21889 | | }, |
| 21890 | | .unreach => {}, |
| 21891 | | .fptrunc => |air_tag| if (use_old) try cg.airFptrunc(inst) else { |
| 21892 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 21893 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 21894 | | var res: [1]Temp = undefined; |
| 21895 | | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 21896 | | .required_features = .{ .f16c, null, null, null }, |
| 21897 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 34450 | .extra_temps = .{ |
| 34451 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34452 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 34453 | .unused, |
| 34454 | .unused, |
| 34455 | .unused, |
| 34456 | .unused, |
| 34457 | .unused, |
| 34458 | .unused, |
| 34459 | .unused, |
| 34460 | }, |
| 34461 | .dst_temps = .{.mem}, |
| 34462 | .clobbers = .{ .eflags = true }, |
| 34463 | .each = .{ .once = &.{ |
| 34464 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34465 | .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34466 | .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 34467 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 34468 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34469 | } }, |
| 34470 | }, .{ |
| 34471 | .required_features = .{ .sse2, null, null, null }, |
| 34472 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 34473 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 34474 | .patterns = &.{ |
| 34475 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34476 | }, |
| 34477 | .extra_temps = .{ |
| 34478 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34479 | .{ .type = .vector_2_f32, .kind = .{ .rc = .sse } }, |
| 34480 | .unused, |
| 34481 | .unused, |
| 34482 | .unused, |
| 34483 | .unused, |
| 34484 | .unused, |
| 34485 | .unused, |
| 34486 | .unused, |
| 34487 | }, |
| 34488 | .dst_temps = .{.mem}, |
| 34489 | .clobbers = .{ .eflags = true }, |
| 34490 | .each = .{ .once = &.{ |
| 34491 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34492 | .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34493 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 34494 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 34495 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34496 | } }, |
| 34497 | }, .{ |
| 34498 | .required_features = .{ .x87, null, null, null }, |
| 34499 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 34500 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 34501 | .patterns = &.{ |
| 34502 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34503 | }, |
| 34504 | .extra_temps = .{ |
| 34505 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34506 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 34507 | .unused, |
| 34508 | .unused, |
| 34509 | .unused, |
| 34510 | .unused, |
| 34511 | .unused, |
| 34512 | .unused, |
| 34513 | .unused, |
| 34514 | }, |
| 34515 | .dst_temps = .{.mem}, |
| 34516 | .clobbers = .{ .eflags = true }, |
| 34517 | .each = .{ .once = &.{ |
| 34518 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34519 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34520 | .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34521 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 34522 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34523 | } }, |
| 34524 | }, .{ |
| 34525 | .required_features = .{ .avx, null, null, null }, |
| 34526 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 21898 | 34527 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 21899 | 34528 | .patterns = &.{ |
| 21900 | | .{ .src = .{ .to_sse, .none } }, |
| 34529 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21901 | 34530 | }, |
| 21902 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34531 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34532 | .extra_temps = .{ |
| 34533 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34534 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34535 | .unused, |
| 34536 | .unused, |
| 34537 | .unused, |
| 34538 | .unused, |
| 34539 | .unused, |
| 34540 | .unused, |
| 34541 | .unused, |
| 34542 | }, |
| 34543 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 34544 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 21903 | 34545 | .each = .{ .once = &.{ |
| 21904 | | .{ ._, .v_, .cvtps2ph, .dst0q, .src0x, .rm(.{}), ._ }, |
| 34546 | .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 34547 | .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 34548 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 34549 | } }, |
| 34550 | }, .{ |
| 34551 | .required_features = .{ .sse2, null, null, null }, |
| 34552 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34553 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34554 | .patterns = &.{ |
| 34555 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34556 | }, |
| 34557 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34558 | .extra_temps = .{ |
| 34559 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34560 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34561 | .unused, |
| 34562 | .unused, |
| 34563 | .unused, |
| 34564 | .unused, |
| 34565 | .unused, |
| 34566 | .unused, |
| 34567 | .unused, |
| 34568 | }, |
| 34569 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 34570 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34571 | .each = .{ .once = &.{ |
| 34572 | .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 34573 | .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 34574 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 34575 | } }, |
| 34576 | }, .{ |
| 34577 | .required_features = .{ .sse, null, null, null }, |
| 34578 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34579 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34580 | .patterns = &.{ |
| 34581 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34582 | }, |
| 34583 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34584 | .extra_temps = .{ |
| 34585 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34586 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34587 | .unused, |
| 34588 | .unused, |
| 34589 | .unused, |
| 34590 | .unused, |
| 34591 | .unused, |
| 34592 | .unused, |
| 34593 | .unused, |
| 34594 | }, |
| 34595 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 34596 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34597 | .each = .{ .once = &.{ |
| 34598 | .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, |
| 34599 | .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 34600 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 34601 | } }, |
| 34602 | }, .{ |
| 34603 | .required_features = .{ .avx, null, null, null }, |
| 34604 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34605 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34606 | .patterns = &.{ |
| 34607 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34608 | }, |
| 34609 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34610 | .extra_temps = .{ |
| 34611 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34612 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 34613 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34614 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34615 | .unused, |
| 34616 | .unused, |
| 34617 | .unused, |
| 34618 | .unused, |
| 34619 | .unused, |
| 34620 | }, |
| 34621 | .dst_temps = .{.mem}, |
| 34622 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34623 | .each = .{ .once = &.{ |
| 34624 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34625 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34626 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 34627 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 34628 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 34629 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34630 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34631 | } }, |
| 34632 | }, .{ |
| 34633 | .required_features = .{ .sse4_1, null, null, null }, |
| 34634 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34635 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34636 | .patterns = &.{ |
| 34637 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34638 | }, |
| 34639 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34640 | .extra_temps = .{ |
| 34641 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34642 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 34643 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34644 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34645 | .unused, |
| 34646 | .unused, |
| 34647 | .unused, |
| 34648 | .unused, |
| 34649 | .unused, |
| 34650 | }, |
| 34651 | .dst_temps = .{.mem}, |
| 34652 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34653 | .each = .{ .once = &.{ |
| 34654 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34655 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34656 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 34657 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 34658 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 34659 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34660 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34661 | } }, |
| 34662 | }, .{ |
| 34663 | .required_features = .{ .sse2, null, null, null }, |
| 34664 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34665 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34666 | .patterns = &.{ |
| 34667 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34668 | }, |
| 34669 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34670 | .extra_temps = .{ |
| 34671 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34672 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 34673 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34674 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34675 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 34676 | .unused, |
| 34677 | .unused, |
| 34678 | .unused, |
| 34679 | .unused, |
| 34680 | }, |
| 34681 | .dst_temps = .{.mem}, |
| 34682 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34683 | .each = .{ .once = &.{ |
| 34684 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34685 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34686 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 34687 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 34688 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 34689 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 34690 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34691 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34692 | } }, |
| 34693 | }, .{ |
| 34694 | .required_features = .{ .sse, null, null, null }, |
| 34695 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34696 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34697 | .patterns = &.{ |
| 34698 | .{ .src = .{ .to_mem, .none, .none } }, |
| 34699 | }, |
| 34700 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 34701 | .extra_temps = .{ |
| 34702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34703 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 34704 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34705 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 34706 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 34707 | .unused, |
| 34708 | .unused, |
| 34709 | .unused, |
| 34710 | .unused, |
| 34711 | }, |
| 34712 | .dst_temps = .{.mem}, |
| 34713 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34714 | .each = .{ .once = &.{ |
| 34715 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34716 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34717 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 34718 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 34719 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp1x, ._, ._ }, |
| 34720 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp2d), ._, ._ }, |
| 34721 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 34722 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 34723 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 21905 | 34724 | } }, |
| 21906 | 34725 | }, .{ |
| 21907 | | .required_features = .{ .f16c, null, null, null }, |
| 21908 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| 21909 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 34726 | .required_features = .{ .x87, null, null, null }, |
| 34727 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34728 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 21910 | 34729 | .patterns = &.{ |
| 21911 | | .{ .src = .{ .to_sse, .none } }, |
| 34730 | .{ .src = .{ .mem, .none, .none } }, |
| 34731 | .{ .src = .{ .to_x87, .none, .none } }, |
| 21912 | 34732 | }, |
| 21913 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34733 | .extra_temps = .{ |
| 34734 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 34735 | .unused, |
| 34736 | .unused, |
| 34737 | .unused, |
| 34738 | .unused, |
| 34739 | .unused, |
| 34740 | .unused, |
| 34741 | .unused, |
| 34742 | .unused, |
| 34743 | }, |
| 34744 | .dst_temps = .{.mem}, |
| 21914 | 34745 | .each = .{ .once = &.{ |
| 21915 | | .{ ._, .v_, .cvtps2ph, .dst0q, .src0x, .rm(.{}), ._ }, |
| 34746 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 34747 | .{ ._, .f_p, .st, .dst0d, ._, ._, ._ }, |
| 21916 | 34748 | } }, |
| 21917 | 34749 | }, .{ |
| 21918 | | .required_features = .{ .f16c, null, null, null }, |
| 21919 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any }, |
| 21920 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 34750 | .required_features = .{ .x87, null, null, null }, |
| 34751 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34752 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 21921 | 34753 | .patterns = &.{ |
| 21922 | | .{ .src = .{ .to_sse, .none } }, |
| 34754 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21923 | 34755 | }, |
| 21924 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 34756 | .extra_temps = .{ |
| 34757 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34758 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 34759 | .unused, |
| 34760 | .unused, |
| 34761 | .unused, |
| 34762 | .unused, |
| 34763 | .unused, |
| 34764 | .unused, |
| 34765 | .unused, |
| 34766 | }, |
| 34767 | .dst_temps = .{.mem}, |
| 34768 | .clobbers = .{ .eflags = true }, |
| 21925 | 34769 | .each = .{ .once = &.{ |
| 21926 | | .{ ._, .v_, .cvtps2ph, .dst0x, .src0y, .rm(.{}), ._ }, |
| 34770 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 34771 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34772 | .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34773 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 34774 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 21927 | 34775 | } }, |
| 21928 | 34776 | }, .{ |
| 21929 | | .required_features = .{ .sse, null, null, null }, |
| 21930 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 21931 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34777 | .required_features = .{ .x87, null, null, null }, |
| 34778 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34779 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 21932 | 34780 | .patterns = &.{ |
| 21933 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 34781 | .{ .src = .{ .mem, .none, .none } }, |
| 34782 | .{ .src = .{ .to_x87, .none, .none } }, |
| 21934 | 34783 | }, |
| 21935 | | .call_frame = .{ .alignment = .@"16" }, |
| 21936 | 34784 | .extra_temps = .{ |
| 21937 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34785 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 21938 | 34786 | .unused, |
| 21939 | 34787 | .unused, |
| 21940 | 34788 | .unused, |
| ... | ... | @@ -21944,21 +34792,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21944 | 34792 | .unused, |
| 21945 | 34793 | .unused, |
| 21946 | 34794 | }, |
| 21947 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 21948 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34795 | .dst_temps = .{.mem}, |
| 21949 | 34796 | .each = .{ .once = &.{ |
| 21950 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 34797 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 34798 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 21951 | 34799 | } }, |
| 21952 | 34800 | }, .{ |
| 21953 | | .required_features = .{ .f16c, null, null, null }, |
| 21954 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any }, |
| 21955 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 34801 | .required_features = .{ .x87, null, null, null }, |
| 34802 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 34803 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 21956 | 34804 | .patterns = &.{ |
| 21957 | | .{ .src = .{ .to_mem, .none } }, |
| 34805 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21958 | 34806 | }, |
| 21959 | 34807 | .extra_temps = .{ |
| 21960 | 34808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 21961 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 34809 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 21962 | 34810 | .unused, |
| 21963 | 34811 | .unused, |
| 21964 | 34812 | .unused, |
| ... | ... | @@ -21971,23 +34819,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21971 | 34819 | .clobbers = .{ .eflags = true }, |
| 21972 | 34820 | .each = .{ .once = &.{ |
| 21973 | 34821 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 21974 | | .{ .@"0:", .v_ps, .mova, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 21975 | | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 21976 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 34822 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34823 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34824 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 21977 | 34825 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 21978 | 34826 | } }, |
| 34827 | }, .{ |
| 34828 | .required_features = .{ .sse, null, null, null }, |
| 34829 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 34830 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34831 | .patterns = &.{ |
| 34832 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 34833 | }, |
| 34834 | .call_frame = .{ .alignment = .@"16" }, |
| 34835 | .extra_temps = .{ |
| 34836 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 34837 | .unused, |
| 34838 | .unused, |
| 34839 | .unused, |
| 34840 | .unused, |
| 34841 | .unused, |
| 34842 | .unused, |
| 34843 | .unused, |
| 34844 | .unused, |
| 34845 | }, |
| 34846 | .dst_temps = .{.{ .ref = .src0 }}, |
| 34847 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34848 | .each = .{ .once = &.{ |
| 34849 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 34850 | } }, |
| 21979 | 34851 | }, .{ |
| 21980 | 34852 | .required_features = .{ .avx, null, null, null }, |
| 21981 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 34853 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 21982 | 34854 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 21983 | 34855 | .patterns = &.{ |
| 21984 | | .{ .src = .{ .to_mem, .none } }, |
| 34856 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21985 | 34857 | }, |
| 21986 | 34858 | .call_frame = .{ .alignment = .@"16" }, |
| 21987 | 34859 | .extra_temps = .{ |
| 21988 | 34860 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 21989 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 21990 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34861 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 34862 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 21991 | 34863 | .unused, |
| 21992 | 34864 | .unused, |
| 21993 | 34865 | .unused, |
| ... | ... | @@ -21999,7 +34871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21999 | 34871 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22000 | 34872 | .each = .{ .once = &.{ |
| 22001 | 34873 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22002 | | .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34874 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22003 | 34875 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22004 | 34876 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22005 | 34877 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| ... | ... | @@ -22007,16 +34879,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22007 | 34879 | } }, |
| 22008 | 34880 | }, .{ |
| 22009 | 34881 | .required_features = .{ .sse4_1, null, null, null }, |
| 22010 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 34882 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22011 | 34883 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 22012 | 34884 | .patterns = &.{ |
| 22013 | | .{ .src = .{ .to_mem, .none } }, |
| 34885 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22014 | 34886 | }, |
| 22015 | 34887 | .call_frame = .{ .alignment = .@"16" }, |
| 22016 | 34888 | .extra_temps = .{ |
| 22017 | 34889 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22018 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 22019 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34890 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 34891 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22020 | 34892 | .unused, |
| 22021 | 34893 | .unused, |
| 22022 | 34894 | .unused, |
| ... | ... | @@ -22028,7 +34900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22028 | 34900 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22029 | 34901 | .each = .{ .once = &.{ |
| 22030 | 34902 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22031 | | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34903 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22032 | 34904 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22033 | 34905 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22034 | 34906 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| ... | ... | @@ -22036,16 +34908,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22036 | 34908 | } }, |
| 22037 | 34909 | }, .{ |
| 22038 | 34910 | .required_features = .{ .sse2, null, null, null }, |
| 22039 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 34911 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22040 | 34912 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 22041 | 34913 | .patterns = &.{ |
| 22042 | | .{ .src = .{ .to_mem, .none } }, |
| 34914 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22043 | 34915 | }, |
| 22044 | 34916 | .call_frame = .{ .alignment = .@"16" }, |
| 22045 | 34917 | .extra_temps = .{ |
| 22046 | 34918 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22047 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 22048 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34919 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 34920 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22049 | 34921 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 22050 | 34922 | .unused, |
| 22051 | 34923 | .unused, |
| ... | ... | @@ -22057,7 +34929,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22057 | 34929 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22058 | 34930 | .each = .{ .once = &.{ |
| 22059 | 34931 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22060 | | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34932 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22061 | 34933 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22062 | 34934 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 22063 | 34935 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| ... | ... | @@ -22066,16 +34938,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22066 | 34938 | } }, |
| 22067 | 34939 | }, .{ |
| 22068 | 34940 | .required_features = .{ .sse, null, null, null }, |
| 22069 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 34941 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22070 | 34942 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 22071 | 34943 | .patterns = &.{ |
| 22072 | | .{ .src = .{ .to_mem, .none } }, |
| 34944 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22073 | 34945 | }, |
| 22074 | 34946 | .call_frame = .{ .alignment = .@"16" }, |
| 22075 | 34947 | .extra_temps = .{ |
| 22076 | 34948 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22077 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22078 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, |
| 34949 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 34950 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22079 | 34951 | .{ .type = .f32, .kind = .mem }, |
| 22080 | 34952 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 22081 | 34953 | .unused, |
| ... | ... | @@ -22087,7 +34959,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22087 | 34959 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22088 | 34960 | .each = .{ .once = &.{ |
| 22089 | 34961 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22090 | | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 34962 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22091 | 34963 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22092 | 34964 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, |
| 22093 | 34965 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, |
| ... | ... | @@ -22097,14 +34969,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22097 | 34969 | } }, |
| 22098 | 34970 | }, .{ |
| 22099 | 34971 | .required_features = .{ .sse, null, null, null }, |
| 22100 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22101 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 34972 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 34973 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22102 | 34974 | .patterns = &.{ |
| 22103 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 34975 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22104 | 34976 | }, |
| 22105 | 34977 | .call_frame = .{ .alignment = .@"16" }, |
| 22106 | 34978 | .extra_temps = .{ |
| 22107 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 34979 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 22108 | 34980 | .unused, |
| 22109 | 34981 | .unused, |
| 22110 | 34982 | .unused, |
| ... | ... | @@ -22121,16 +34993,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22121 | 34993 | } }, |
| 22122 | 34994 | }, .{ |
| 22123 | 34995 | .required_features = .{ .avx, null, null, null }, |
| 22124 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22125 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 34996 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 34997 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22126 | 34998 | .patterns = &.{ |
| 22127 | | .{ .src = .{ .to_mem, .none } }, |
| 34999 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22128 | 35000 | }, |
| 22129 | 35001 | .call_frame = .{ .alignment = .@"16" }, |
| 22130 | 35002 | .extra_temps = .{ |
| 22131 | 35003 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22132 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 22133 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 35004 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35005 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 22134 | 35006 | .unused, |
| 22135 | 35007 | .unused, |
| 22136 | 35008 | .unused, |
| ... | ... | @@ -22142,24 +35014,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22142 | 35014 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22143 | 35015 | .each = .{ .once = &.{ |
| 22144 | 35016 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22145 | | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 35017 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22146 | 35018 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22147 | | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22148 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35019 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35020 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22149 | 35021 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22150 | 35022 | } }, |
| 22151 | 35023 | }, .{ |
| 22152 | | .required_features = .{ .sse4_1, null, null, null }, |
| 22153 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22154 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35024 | .required_features = .{ .sse2, null, null, null }, |
| 35025 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35026 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22155 | 35027 | .patterns = &.{ |
| 22156 | | .{ .src = .{ .to_mem, .none } }, |
| 35028 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22157 | 35029 | }, |
| 22158 | 35030 | .call_frame = .{ .alignment = .@"16" }, |
| 22159 | 35031 | .extra_temps = .{ |
| 22160 | 35032 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22161 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 22162 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 35033 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35034 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 22163 | 35035 | .unused, |
| 22164 | 35036 | .unused, |
| 22165 | 35037 | .unused, |
| ... | ... | @@ -22171,25 +35043,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22171 | 35043 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22172 | 35044 | .each = .{ .once = &.{ |
| 22173 | 35045 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22174 | | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 35046 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22175 | 35047 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22176 | | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22177 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35048 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35049 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 35050 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35051 | } }, |
| 35052 | }, .{ |
| 35053 | .required_features = .{ .sse, null, null, null }, |
| 35054 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35055 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35056 | .patterns = &.{ |
| 35057 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35058 | }, |
| 35059 | .call_frame = .{ .alignment = .@"16" }, |
| 35060 | .extra_temps = .{ |
| 35061 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35062 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35063 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 35064 | .unused, |
| 35065 | .unused, |
| 35066 | .unused, |
| 35067 | .unused, |
| 35068 | .unused, |
| 35069 | .unused, |
| 35070 | }, |
| 35071 | .dst_temps = .{.mem}, |
| 35072 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35073 | .each = .{ .once = &.{ |
| 35074 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 35075 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 35076 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35077 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35078 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 35079 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35080 | } }, |
| 35081 | }, .{ |
| 35082 | .required_features = .{ .sse, null, null, null }, |
| 35083 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35084 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 35085 | .patterns = &.{ |
| 35086 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 35087 | }, |
| 35088 | .call_frame = .{ .alignment = .@"16" }, |
| 35089 | .extra_temps = .{ |
| 35090 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 35091 | .unused, |
| 35092 | .unused, |
| 35093 | .unused, |
| 35094 | .unused, |
| 35095 | .unused, |
| 35096 | .unused, |
| 35097 | .unused, |
| 35098 | .unused, |
| 35099 | }, |
| 35100 | .dst_temps = .{.{ .ref = .src0 }}, |
| 35101 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35102 | .each = .{ .once = &.{ |
| 35103 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 35104 | } }, |
| 35105 | }, .{ |
| 35106 | .required_features = .{ .avx, null, null, null }, |
| 35107 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35108 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 35109 | .patterns = &.{ |
| 35110 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35111 | }, |
| 35112 | .call_frame = .{ .alignment = .@"16" }, |
| 35113 | .extra_temps = .{ |
| 35114 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35115 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35116 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 35117 | .unused, |
| 35118 | .unused, |
| 35119 | .unused, |
| 35120 | .unused, |
| 35121 | .unused, |
| 35122 | .unused, |
| 35123 | }, |
| 35124 | .dst_temps = .{.mem}, |
| 35125 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35126 | .each = .{ .once = &.{ |
| 35127 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 35128 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 35129 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35130 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35131 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22178 | 35132 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22179 | 35133 | } }, |
| 22180 | 35134 | }, .{ |
| 22181 | 35135 | .required_features = .{ .sse2, null, null, null }, |
| 22182 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22183 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35136 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35137 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22184 | 35138 | .patterns = &.{ |
| 22185 | | .{ .src = .{ .to_mem, .none } }, |
| 35139 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22186 | 35140 | }, |
| 22187 | 35141 | .call_frame = .{ .alignment = .@"16" }, |
| 22188 | 35142 | .extra_temps = .{ |
| 22189 | 35143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22190 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 22191 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 22192 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35144 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35145 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 35146 | .unused, |
| 22193 | 35147 | .unused, |
| 22194 | 35148 | .unused, |
| 22195 | 35149 | .unused, |
| ... | ... | @@ -22200,27 +35154,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22200 | 35154 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22201 | 35155 | .each = .{ .once = &.{ |
| 22202 | 35156 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22203 | | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 35157 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22204 | 35158 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22205 | | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 22206 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 22207 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35159 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35160 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22208 | 35161 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22209 | 35162 | } }, |
| 22210 | 35163 | }, .{ |
| 22211 | 35164 | .required_features = .{ .sse, null, null, null }, |
| 22212 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22213 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35165 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35166 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22214 | 35167 | .patterns = &.{ |
| 22215 | | .{ .src = .{ .to_mem, .none } }, |
| 35168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22216 | 35169 | }, |
| 22217 | 35170 | .call_frame = .{ .alignment = .@"16" }, |
| 22218 | 35171 | .extra_temps = .{ |
| 22219 | 35172 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22220 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 22221 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, |
| 22222 | | .{ .type = .f32, .kind = .mem }, |
| 22223 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35173 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35174 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 35175 | .unused, |
| 35176 | .unused, |
| 22224 | 35177 | .unused, |
| 22225 | 35178 | .unused, |
| 22226 | 35179 | .unused, |
| ... | ... | @@ -22230,60 +35183,186 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22230 | 35183 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22231 | 35184 | .each = .{ .once = &.{ |
| 22232 | 35185 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22233 | | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 22234 | | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 35186 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22235 | 35187 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22236 | | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, |
| 22237 | | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, |
| 22238 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 22239 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35188 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35189 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22240 | 35190 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22241 | 35191 | } }, |
| 22242 | 35192 | }, .{ |
| 22243 | | .required_features = .{ .avx, null, null, null }, |
| 22244 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22245 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35193 | .required_features = .{ .sse, .x87, null, null }, |
| 35194 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35195 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22246 | 35196 | .patterns = &.{ |
| 22247 | | .{ .src = .{ .mem, .none } }, |
| 35197 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22248 | 35198 | }, |
| 22249 | | .dst_temps = .{.{ .rc = .sse }}, |
| 35199 | .call_frame = .{ .alignment = .@"16" }, |
| 35200 | .extra_temps = .{ |
| 35201 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 35202 | .unused, |
| 35203 | .unused, |
| 35204 | .unused, |
| 35205 | .unused, |
| 35206 | .unused, |
| 35207 | .unused, |
| 35208 | .unused, |
| 35209 | .unused, |
| 35210 | }, |
| 35211 | .dst_temps = .{.{ .reg = .st0 }}, |
| 35212 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22250 | 35213 | .each = .{ .once = &.{ |
| 22251 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 22252 | | .{ ._, .v_ss, .cvtsd2, .dst0x, .dst0x, .src0q, ._ }, |
| 35214 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 22253 | 35215 | } }, |
| 22254 | 35216 | }, .{ |
| 22255 | 35217 | .required_features = .{ .avx, null, null, null }, |
| 22256 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22257 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35218 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35219 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22258 | 35220 | .patterns = &.{ |
| 22259 | | .{ .src = .{ .to_sse, .none } }, |
| 35221 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22260 | 35222 | }, |
| 22261 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 35223 | .call_frame = .{ .alignment = .@"16" }, |
| 35224 | .extra_temps = .{ |
| 35225 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35226 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35227 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 35228 | .unused, |
| 35229 | .unused, |
| 35230 | .unused, |
| 35231 | .unused, |
| 35232 | .unused, |
| 35233 | .unused, |
| 35234 | }, |
| 35235 | .dst_temps = .{.mem}, |
| 35236 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22262 | 35237 | .each = .{ .once = &.{ |
| 22263 | | .{ ._, .v_ss, .cvtsd2, .dst0x, .src0x, .src0q, ._ }, |
| 35238 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 35239 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35240 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35241 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 35242 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 35243 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 35244 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22264 | 35245 | } }, |
| 22265 | 35246 | }, .{ |
| 22266 | 35247 | .required_features = .{ .sse2, null, null, null }, |
| 22267 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 35248 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35249 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 35250 | .patterns = &.{ |
| 35251 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35252 | }, |
| 35253 | .call_frame = .{ .alignment = .@"16" }, |
| 35254 | .extra_temps = .{ |
| 35255 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35256 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35257 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 35258 | .unused, |
| 35259 | .unused, |
| 35260 | .unused, |
| 35261 | .unused, |
| 35262 | .unused, |
| 35263 | .unused, |
| 35264 | }, |
| 35265 | .dst_temps = .{.mem}, |
| 35266 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35267 | .each = .{ .once = &.{ |
| 35268 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 35269 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35270 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35271 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 35272 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 35273 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 35274 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35275 | } }, |
| 35276 | }, .{ |
| 35277 | .required_features = .{ .sse, null, null, null }, |
| 35278 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 35279 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 35280 | .patterns = &.{ |
| 35281 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35282 | }, |
| 35283 | .call_frame = .{ .alignment = .@"16" }, |
| 35284 | .extra_temps = .{ |
| 35285 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35286 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 35287 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 35288 | .unused, |
| 35289 | .unused, |
| 35290 | .unused, |
| 35291 | .unused, |
| 35292 | .unused, |
| 35293 | .unused, |
| 35294 | }, |
| 35295 | .dst_temps = .{.mem}, |
| 35296 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35297 | .each = .{ .once = &.{ |
| 35298 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 35299 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35300 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35301 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 35302 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 35303 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 35304 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35305 | } }, |
| 35306 | } }) catch |err| switch (err) { |
| 35307 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 35308 | @tagName(air_tag), |
| 35309 | ty_op.ty.toType().fmt(pt), |
| 35310 | cg.typeOf(ty_op.operand).fmt(pt), |
| 35311 | ops[0].tracking(cg), |
| 35312 | }), |
| 35313 | else => |e| return e, |
| 35314 | }; |
| 35315 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 35316 | }, |
| 35317 | .fpext => |air_tag| if (use_old) try cg.airFpext(inst) else { |
| 35318 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 35319 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 35320 | var res: [1]Temp = undefined; |
| 35321 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 35322 | .required_features = .{ .f16c, null, null, null }, |
| 35323 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22268 | 35324 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22269 | 35325 | .patterns = &.{ |
| 22270 | | .{ .src = .{ .mem, .none } }, |
| 22271 | | .{ .src = .{ .to_sse, .none } }, |
| 35326 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22272 | 35327 | }, |
| 22273 | | .dst_temps = .{.{ .rc = .sse }}, |
| 35328 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22274 | 35329 | .each = .{ .once = &.{ |
| 22275 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 22276 | | .{ ._, ._ss, .cvtsd2, .dst0x, .src0q, ._, ._ }, |
| 35330 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 22277 | 35331 | } }, |
| 22278 | 35332 | }, .{ |
| 22279 | | .required_features = .{ .x87, null, null, null }, |
| 22280 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 35333 | .required_features = .{ .f16c, null, null, null }, |
| 35334 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 35335 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 35336 | .patterns = &.{ |
| 35337 | .{ .src = .{ .mem, .none, .none } }, |
| 35338 | .{ .src = .{ .to_sse, .none, .none } }, |
| 35339 | }, |
| 35340 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 35341 | .each = .{ .once = &.{ |
| 35342 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 35343 | } }, |
| 35344 | }, .{ |
| 35345 | .required_features = .{ .f16c, null, null, null }, |
| 35346 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 35347 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 35348 | .patterns = &.{ |
| 35349 | .{ .src = .{ .mem, .none, .none } }, |
| 35350 | .{ .src = .{ .to_sse, .none, .none } }, |
| 35351 | }, |
| 35352 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 35353 | .each = .{ .once = &.{ |
| 35354 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 35355 | } }, |
| 35356 | }, .{ |
| 35357 | .required_features = .{ .sse, null, null, null }, |
| 35358 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22281 | 35359 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22282 | 35360 | .patterns = &.{ |
| 22283 | | .{ .src = .{ .to_mem, .none } }, |
| 35361 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22284 | 35362 | }, |
| 35363 | .call_frame = .{ .alignment = .@"16" }, |
| 22285 | 35364 | .extra_temps = .{ |
| 22286 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 35365 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 22287 | 35366 | .unused, |
| 22288 | 35367 | .unused, |
| 22289 | 35368 | .unused, |
| ... | ... | @@ -22293,57 +35372,178 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22293 | 35372 | .unused, |
| 22294 | 35373 | .unused, |
| 22295 | 35374 | }, |
| 35375 | .dst_temps = .{.{ .ref = .src0 }}, |
| 35376 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35377 | .each = .{ .once = &.{ |
| 35378 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 35379 | } }, |
| 35380 | }, .{ |
| 35381 | .required_features = .{ .f16c, null, null, null }, |
| 35382 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 35383 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 35384 | .patterns = &.{ |
| 35385 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35386 | }, |
| 35387 | .extra_temps = .{ |
| 35388 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35389 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 35390 | .unused, |
| 35391 | .unused, |
| 35392 | .unused, |
| 35393 | .unused, |
| 35394 | .unused, |
| 35395 | .unused, |
| 35396 | .unused, |
| 35397 | }, |
| 22296 | 35398 | .dst_temps = .{.mem}, |
| 35399 | .clobbers = .{ .eflags = true }, |
| 22297 | 35400 | .each = .{ .once = &.{ |
| 22298 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 22299 | | .{ ._, .f_p, .st, .dst0d, ._, ._, ._ }, |
| 35401 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35402 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35403 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 35404 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 35405 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35406 | } }, |
| 35407 | }, .{ |
| 35408 | .required_features = .{ .avx, null, null, null }, |
| 35409 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35410 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35411 | .patterns = &.{ |
| 35412 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35413 | }, |
| 35414 | .call_frame = .{ .alignment = .@"16" }, |
| 35415 | .extra_temps = .{ |
| 35416 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35417 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35418 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 35419 | .unused, |
| 35420 | .unused, |
| 35421 | .unused, |
| 35422 | .unused, |
| 35423 | .unused, |
| 35424 | .unused, |
| 35425 | }, |
| 35426 | .dst_temps = .{.mem}, |
| 35427 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35428 | .each = .{ .once = &.{ |
| 35429 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35430 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 35431 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 35432 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35433 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35434 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35435 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35436 | } }, |
| 35437 | }, .{ |
| 35438 | .required_features = .{ .sse2, null, null, null }, |
| 35439 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35440 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35441 | .patterns = &.{ |
| 35442 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35443 | }, |
| 35444 | .call_frame = .{ .alignment = .@"16" }, |
| 35445 | .extra_temps = .{ |
| 35446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35447 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35448 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 35449 | .unused, |
| 35450 | .unused, |
| 35451 | .unused, |
| 35452 | .unused, |
| 35453 | .unused, |
| 35454 | .unused, |
| 35455 | }, |
| 35456 | .dst_temps = .{.mem}, |
| 35457 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35458 | .each = .{ .once = &.{ |
| 35459 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35460 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 35461 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 35462 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35463 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35464 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35465 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35466 | } }, |
| 35467 | }, .{ |
| 35468 | .required_features = .{ .sse, null, null, null }, |
| 35469 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35470 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35471 | .patterns = &.{ |
| 35472 | .{ .src = .{ .to_mem, .none, .none } }, |
| 35473 | }, |
| 35474 | .call_frame = .{ .alignment = .@"16" }, |
| 35475 | .extra_temps = .{ |
| 35476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35477 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35478 | .{ .type = .f32, .kind = .mem }, |
| 35479 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35480 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 35481 | .unused, |
| 35482 | .unused, |
| 35483 | .unused, |
| 35484 | .unused, |
| 35485 | }, |
| 35486 | .dst_temps = .{.mem}, |
| 35487 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35488 | .each = .{ .once = &.{ |
| 35489 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35490 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35491 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 35492 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 35493 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 35494 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 35495 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35496 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22300 | 35497 | } }, |
| 22301 | 35498 | }, .{ |
| 22302 | | .required_features = .{ .avx, null, null, null }, |
| 22303 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| 22304 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, |
| 35499 | .required_features = .{ .f16c, null, null, null }, |
| 35500 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35501 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22305 | 35502 | .patterns = &.{ |
| 22306 | | .{ .src = .{ .mem, .none } }, |
| 22307 | | .{ .src = .{ .to_sse, .none } }, |
| 35503 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22308 | 35504 | }, |
| 22309 | 35505 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22310 | 35506 | .each = .{ .once = &.{ |
| 22311 | | .{ ._, .v_ps, .cvtpd2, .dst0x, .src0x, ._, ._ }, |
| 35507 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 35508 | .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .dst0d, ._ }, |
| 22312 | 35509 | } }, |
| 22313 | 35510 | }, .{ |
| 22314 | | .required_features = .{ .sse2, null, null, null }, |
| 22315 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| 22316 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, |
| 35511 | .required_features = .{ .f16c, null, null, null }, |
| 35512 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 35513 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 22317 | 35514 | .patterns = &.{ |
| 22318 | | .{ .src = .{ .mem, .none } }, |
| 22319 | | .{ .src = .{ .to_sse, .none } }, |
| 35515 | .{ .src = .{ .mem, .none, .none } }, |
| 35516 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22320 | 35517 | }, |
| 22321 | 35518 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22322 | 35519 | .each = .{ .once = &.{ |
| 22323 | | .{ ._, ._ps, .cvtpd2, .dst0x, .src0x, ._, ._ }, |
| 35520 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 35521 | .{ ._, .v_pd, .cvtps2, .dst0x, .dst0q, ._, ._ }, |
| 22324 | 35522 | } }, |
| 22325 | 35523 | }, .{ |
| 22326 | | .required_features = .{ .avx, null, null, null }, |
| 22327 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any }, |
| 22328 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 35524 | .required_features = .{ .f16c, null, null, null }, |
| 35525 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 35526 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 22329 | 35527 | .patterns = &.{ |
| 22330 | | .{ .src = .{ .mem, .none } }, |
| 22331 | | .{ .src = .{ .to_sse, .none } }, |
| 35528 | .{ .src = .{ .mem, .none, .none } }, |
| 35529 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22332 | 35530 | }, |
| 22333 | 35531 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22334 | 35532 | .each = .{ .once = &.{ |
| 22335 | | .{ ._, .v_ps, .cvtpd2, .dst0x, .src0y, ._, ._ }, |
| 35533 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 35534 | .{ ._, .v_pd, .cvtps2, .dst0y, .dst0x, ._, ._ }, |
| 22336 | 35535 | } }, |
| 22337 | 35536 | }, .{ |
| 22338 | | .required_features = .{ .avx, null, null, null }, |
| 22339 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any }, |
| 22340 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 35537 | .required_features = .{ .f16c, null, null, null }, |
| 35538 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 35539 | .dst_constraints = .{.{ .scalar_float = .{ .of = .zword, .is = .qword } }}, |
| 22341 | 35540 | .patterns = &.{ |
| 22342 | | .{ .src = .{ .to_mem, .none } }, |
| 35541 | .{ .src = .{ .mem, .none, .none } }, |
| 35542 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22343 | 35543 | }, |
| 22344 | 35544 | .extra_temps = .{ |
| 22345 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22346 | | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 35545 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 35546 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 22347 | 35547 | .unused, |
| 22348 | 35548 | .unused, |
| 22349 | 35549 | .unused, |
| ... | ... | @@ -22353,24 +35553,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22353 | 35553 | .unused, |
| 22354 | 35554 | }, |
| 22355 | 35555 | .dst_temps = .{.mem}, |
| 22356 | | .clobbers = .{ .eflags = true }, |
| 22357 | 35556 | .each = .{ .once = &.{ |
| 22358 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22359 | | .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22360 | | .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22361 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 22362 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35557 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src0x, ._, ._ }, |
| 35558 | .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ }, |
| 35559 | .{ ._, .v_f128, .extract, .tmp0x, .tmp0y, .ui(1), ._ }, |
| 35560 | .{ ._, .v_pd, .mova, .mem(.dst0y), .tmp1y, ._, ._ }, |
| 35561 | .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ }, |
| 35562 | .{ ._, .v_pd, .mova, .memd(.dst0y, 32), .tmp1y, ._, ._ }, |
| 22363 | 35563 | } }, |
| 22364 | 35564 | }, .{ |
| 22365 | | .required_features = .{ .sse2, null, null, null }, |
| 22366 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any }, |
| 22367 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 35565 | .required_features = .{ .sse, null, null, null }, |
| 35566 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35567 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22368 | 35568 | .patterns = &.{ |
| 22369 | | .{ .src = .{ .to_mem, .none } }, |
| 35569 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22370 | 35570 | }, |
| 35571 | .call_frame = .{ .alignment = .@"16" }, |
| 22371 | 35572 | .extra_temps = .{ |
| 22372 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22373 | | .{ .type = .vector_2_f32, .kind = .{ .rc = .sse } }, |
| 35573 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 35574 | .unused, |
| 22374 | 35575 | .unused, |
| 22375 | 35576 | .unused, |
| 22376 | 35577 | .unused, |
| ... | ... | @@ -22379,26 +35580,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22379 | 35580 | .unused, |
| 22380 | 35581 | .unused, |
| 22381 | 35582 | }, |
| 22382 | | .dst_temps = .{.mem}, |
| 22383 | | .clobbers = .{ .eflags = true }, |
| 35583 | .dst_temps = .{.{ .ref = .src0 }}, |
| 35584 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22384 | 35585 | .each = .{ .once = &.{ |
| 22385 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22386 | | .{ .@"0:", ._ps, .cvtpd2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22387 | | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22388 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22389 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35586 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 22390 | 35587 | } }, |
| 22391 | 35588 | }, .{ |
| 22392 | | .required_features = .{ .x87, null, null, null }, |
| 22393 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 22394 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35589 | .required_features = .{ .f16c, null, null, null }, |
| 35590 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 35591 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }}, |
| 22395 | 35592 | .patterns = &.{ |
| 22396 | | .{ .src = .{ .to_mem, .none } }, |
| 35593 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22397 | 35594 | }, |
| 22398 | 35595 | .extra_temps = .{ |
| 22399 | 35596 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22400 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 22401 | | .unused, |
| 35597 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 35598 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 22402 | 35599 | .unused, |
| 22403 | 35600 | .unused, |
| 22404 | 35601 | .unused, |
| ... | ... | @@ -22409,24 +35606,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22409 | 35606 | .dst_temps = .{.mem}, |
| 22410 | 35607 | .clobbers = .{ .eflags = true }, |
| 22411 | 35608 | .each = .{ .once = &.{ |
| 22412 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22413 | | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22414 | | .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22415 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 35609 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35610 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35611 | .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, |
| 35612 | .{ ._, .v_f128, .extract, .tmp1x, .tmp1y, .ui(1), ._ }, |
| 35613 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 35614 | .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, |
| 35615 | .{ ._, .v_pd, .mova, .memsiad(.dst0y, .@"4", .tmp0, .add_unaligned_size, 32), .tmp2y, ._, ._ }, |
| 35616 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 22416 | 35617 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22417 | 35618 | } }, |
| 22418 | 35619 | }, .{ |
| 22419 | 35620 | .required_features = .{ .avx, null, null, null }, |
| 22420 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22421 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 35621 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35622 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22422 | 35623 | .patterns = &.{ |
| 22423 | | .{ .src = .{ .to_mem, .none } }, |
| 35624 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22424 | 35625 | }, |
| 22425 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35626 | .call_frame = .{ .alignment = .@"16" }, |
| 22426 | 35627 | .extra_temps = .{ |
| 22427 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22428 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 22429 | | .unused, |
| 35628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35629 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35630 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 22430 | 35631 | .unused, |
| 22431 | 35632 | .unused, |
| 22432 | 35633 | .unused, |
| ... | ... | @@ -22434,25 +35635,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22434 | 35635 | .unused, |
| 22435 | 35636 | .unused, |
| 22436 | 35637 | }, |
| 22437 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 35638 | .dst_temps = .{.mem}, |
| 22438 | 35639 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22439 | 35640 | .each = .{ .once = &.{ |
| 22440 | | .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 22441 | | .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 22442 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 35641 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35642 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 35643 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 35644 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35645 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35646 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35647 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22443 | 35648 | } }, |
| 22444 | 35649 | }, .{ |
| 22445 | 35650 | .required_features = .{ .sse2, null, null, null }, |
| 22446 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22447 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 35651 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35652 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22448 | 35653 | .patterns = &.{ |
| 22449 | | .{ .src = .{ .to_mem, .none } }, |
| 35654 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22450 | 35655 | }, |
| 22451 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35656 | .call_frame = .{ .alignment = .@"16" }, |
| 22452 | 35657 | .extra_temps = .{ |
| 22453 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22454 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 22455 | | .unused, |
| 35658 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35659 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35660 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 22456 | 35661 | .unused, |
| 22457 | 35662 | .unused, |
| 22458 | 35663 | .unused, |
| ... | ... | @@ -22460,25 +35665,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22460 | 35665 | .unused, |
| 22461 | 35666 | .unused, |
| 22462 | 35667 | }, |
| 22463 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 35668 | .dst_temps = .{.mem}, |
| 22464 | 35669 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22465 | 35670 | .each = .{ .once = &.{ |
| 22466 | | .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 22467 | | .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 22468 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 35671 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35672 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 35673 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 35674 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35675 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35676 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22469 | 35678 | } }, |
| 22470 | 35679 | }, .{ |
| 22471 | 35680 | .required_features = .{ .sse, null, null, null }, |
| 22472 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22473 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 35681 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35682 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22474 | 35683 | .patterns = &.{ |
| 22475 | | .{ .src = .{ .to_mem, .none } }, |
| 35684 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22476 | 35685 | }, |
| 22477 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35686 | .call_frame = .{ .alignment = .@"16" }, |
| 22478 | 35687 | .extra_temps = .{ |
| 22479 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22480 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 35688 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35689 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35690 | .{ .type = .f32, .kind = .mem }, |
| 35691 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35692 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 35693 | .unused, |
| 35694 | .unused, |
| 35695 | .unused, |
| 22481 | 35696 | .unused, |
| 35697 | }, |
| 35698 | .dst_temps = .{.mem}, |
| 35699 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35700 | .each = .{ .once = &.{ |
| 35701 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35702 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35703 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 35704 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 35705 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 35706 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 35707 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35709 | } }, |
| 35710 | }, .{ |
| 35711 | .required_features = .{ .f16c, .x87, null, null }, |
| 35712 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35713 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 35714 | .patterns = &.{ |
| 35715 | .{ .src = .{ .to_sse, .none, .none } }, |
| 35716 | }, |
| 35717 | .extra_temps = .{ |
| 35718 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 35719 | .{ .type = .f32, .kind = .mem }, |
| 35720 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 22482 | 35721 | .unused, |
| 22483 | 35722 | .unused, |
| 22484 | 35723 | .unused, |
| ... | ... | @@ -22486,56 +35725,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22486 | 35725 | .unused, |
| 22487 | 35726 | .unused, |
| 22488 | 35727 | }, |
| 22489 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 22490 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 35728 | .dst_temps = .{.{ .rc = .x87 }}, |
| 22491 | 35729 | .each = .{ .once = &.{ |
| 22492 | | .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, |
| 22493 | | .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 22494 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 35730 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 35731 | .{ ._, .v_ss, .mov, .mem(.tmp1d), .tmp0x, ._, ._ }, |
| 35732 | .{ ._, .f_, .ld, .mem(.tmp1d), ._, ._, ._ }, |
| 35733 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 22495 | 35734 | } }, |
| 22496 | 35735 | }, .{ |
| 22497 | | .required_features = .{ .avx, null, null, null }, |
| 22498 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22499 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35736 | .required_features = .{ .sse, .x87, null, null }, |
| 35737 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35738 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22500 | 35739 | .patterns = &.{ |
| 22501 | | .{ .src = .{ .to_mem, .none } }, |
| 35740 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22502 | 35741 | }, |
| 22503 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35742 | .call_frame = .{ .alignment = .@"16" }, |
| 22504 | 35743 | .extra_temps = .{ |
| 22505 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22506 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 22507 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22508 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 35744 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 35745 | .unused, |
| 35746 | .unused, |
| 35747 | .unused, |
| 22509 | 35748 | .unused, |
| 22510 | 35749 | .unused, |
| 22511 | 35750 | .unused, |
| 22512 | 35751 | .unused, |
| 22513 | 35752 | .unused, |
| 22514 | 35753 | }, |
| 22515 | | .dst_temps = .{.mem}, |
| 35754 | .dst_temps = .{.{ .reg = .st0 }}, |
| 22516 | 35755 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22517 | 35756 | .each = .{ .once = &.{ |
| 22518 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22519 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22520 | | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 22521 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22522 | | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22523 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22524 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 35757 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 22525 | 35758 | } }, |
| 22526 | 35759 | }, .{ |
| 22527 | | .required_features = .{ .sse4_1, null, null, null }, |
| 22528 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22529 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35760 | .required_features = .{ .avx, null, null, null }, |
| 35761 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35762 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22530 | 35763 | .patterns = &.{ |
| 22531 | | .{ .src = .{ .to_mem, .none } }, |
| 35764 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22532 | 35765 | }, |
| 22533 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35766 | .call_frame = .{ .alignment = .@"16" }, |
| 22534 | 35767 | .extra_temps = .{ |
| 22535 | 35768 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22536 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 22537 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22538 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 35769 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35770 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 35771 | .unused, |
| 22539 | 35772 | .unused, |
| 22540 | 35773 | .unused, |
| 22541 | 35774 | .unused, |
| ... | ... | @@ -22545,28 +35778,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22545 | 35778 | .dst_temps = .{.mem}, |
| 22546 | 35779 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22547 | 35780 | .each = .{ .once = &.{ |
| 22548 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22549 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22550 | | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 22551 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22552 | | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 35781 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35782 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 35783 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 35784 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35785 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 35786 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22553 | 35787 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22554 | 35788 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22555 | 35789 | } }, |
| 22556 | 35790 | }, .{ |
| 22557 | 35791 | .required_features = .{ .sse2, null, null, null }, |
| 22558 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22559 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35792 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35793 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22560 | 35794 | .patterns = &.{ |
| 22561 | | .{ .src = .{ .to_mem, .none } }, |
| 35795 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22562 | 35796 | }, |
| 22563 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35797 | .call_frame = .{ .alignment = .@"16" }, |
| 22564 | 35798 | .extra_temps = .{ |
| 22565 | 35799 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22566 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 22567 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22568 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 22569 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35800 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35801 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 35802 | .unused, |
| 35803 | .unused, |
| 22570 | 35804 | .unused, |
| 22571 | 35805 | .unused, |
| 22572 | 35806 | .unused, |
| ... | ... | @@ -22575,29 +35809,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22575 | 35809 | .dst_temps = .{.mem}, |
| 22576 | 35810 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22577 | 35811 | .each = .{ .once = &.{ |
| 22578 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22579 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22580 | | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 22581 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22582 | | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 22583 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 35812 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35813 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 35814 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 35815 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35816 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 35817 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22584 | 35818 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22585 | 35819 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22586 | 35820 | } }, |
| 22587 | 35821 | }, .{ |
| 22588 | 35822 | .required_features = .{ .sse, null, null, null }, |
| 22589 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22590 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 35823 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35824 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22591 | 35825 | .patterns = &.{ |
| 22592 | | .{ .src = .{ .to_mem, .none } }, |
| 35826 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22593 | 35827 | }, |
| 22594 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 35828 | .call_frame = .{ .alignment = .@"16" }, |
| 22595 | 35829 | .extra_temps = .{ |
| 22596 | 35830 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22597 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 22598 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 22599 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, |
| 22600 | 35831 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35832 | .{ .type = .f32, .kind = .mem }, |
| 35833 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35834 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 22601 | 35835 | .unused, |
| 22602 | 35836 | .unused, |
| 22603 | 35837 | .unused, |
| ... | ... | @@ -22606,26 +35840,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22606 | 35840 | .dst_temps = .{.mem}, |
| 22607 | 35841 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22608 | 35842 | .each = .{ .once = &.{ |
| 22609 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22610 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22611 | | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 22612 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 22613 | | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp1x, ._, ._ }, |
| 22614 | | .{ ._, ._, .mov, .tmp4d, .mem(.tmp2d), ._, ._ }, |
| 22615 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 35843 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35844 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35845 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 35846 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 35847 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 35848 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 35849 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22616 | 35850 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22617 | 35851 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22618 | 35852 | } }, |
| 22619 | 35853 | }, .{ |
| 22620 | | .required_features = .{ .x87, null, null, null }, |
| 22621 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22622 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35854 | .required_features = .{ .sse, null, null, null }, |
| 35855 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35856 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22623 | 35857 | .patterns = &.{ |
| 22624 | | .{ .src = .{ .mem, .none } }, |
| 22625 | | .{ .src = .{ .to_x87, .none } }, |
| 35858 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22626 | 35859 | }, |
| 35860 | .call_frame = .{ .alignment = .@"16" }, |
| 22627 | 35861 | .extra_temps = .{ |
| 22628 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 35862 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22629 | 35863 | .unused, |
| 22630 | 35864 | .unused, |
| 22631 | 35865 | .unused, |
| ... | ... | @@ -22635,22 +35869,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22635 | 35869 | .unused, |
| 22636 | 35870 | .unused, |
| 22637 | 35871 | }, |
| 22638 | | .dst_temps = .{.mem}, |
| 35872 | .dst_temps = .{.{ .ref = .src0 }}, |
| 35873 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22639 | 35874 | .each = .{ .once = &.{ |
| 22640 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 22641 | | .{ ._, .f_p, .st, .dst0d, ._, ._, ._ }, |
| 35875 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 22642 | 35876 | } }, |
| 22643 | 35877 | }, .{ |
| 22644 | | .required_features = .{ .x87, null, null, null }, |
| 22645 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22646 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 35878 | .required_features = .{ .avx, null, null, null }, |
| 35879 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35880 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22647 | 35881 | .patterns = &.{ |
| 22648 | | .{ .src = .{ .to_mem, .none } }, |
| 35882 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22649 | 35883 | }, |
| 35884 | .call_frame = .{ .alignment = .@"16" }, |
| 22650 | 35885 | .extra_temps = .{ |
| 22651 | 35886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22652 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 22653 | | .unused, |
| 35887 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35888 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22654 | 35889 | .unused, |
| 22655 | 35890 | .unused, |
| 22656 | 35891 | .unused, |
| ... | ... | @@ -22659,26 +35894,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22659 | 35894 | .unused, |
| 22660 | 35895 | }, |
| 22661 | 35896 | .dst_temps = .{.mem}, |
| 22662 | | .clobbers = .{ .eflags = true }, |
| 35897 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22663 | 35898 | .each = .{ .once = &.{ |
| 22664 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22665 | | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22666 | | .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22667 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 35899 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35900 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 35901 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 35902 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35903 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35904 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22668 | 35905 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22669 | 35906 | } }, |
| 22670 | 35907 | }, .{ |
| 22671 | | .required_features = .{ .x87, null, null, null }, |
| 22672 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22673 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 35908 | .required_features = .{ .sse2, null, null, null }, |
| 35909 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35910 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22674 | 35911 | .patterns = &.{ |
| 22675 | | .{ .src = .{ .mem, .none } }, |
| 22676 | | .{ .src = .{ .to_x87, .none } }, |
| 35912 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22677 | 35913 | }, |
| 35914 | .call_frame = .{ .alignment = .@"16" }, |
| 22678 | 35915 | .extra_temps = .{ |
| 22679 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 22680 | | .unused, |
| 22681 | | .unused, |
| 35916 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 35917 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35918 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22682 | 35919 | .unused, |
| 22683 | 35920 | .unused, |
| 22684 | 35921 | .unused, |
| ... | ... | @@ -22687,47 +35924,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22687 | 35924 | .unused, |
| 22688 | 35925 | }, |
| 22689 | 35926 | .dst_temps = .{.mem}, |
| 35927 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22690 | 35928 | .each = .{ .once = &.{ |
| 22691 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 22692 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 35929 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35930 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 35931 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 35932 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 35933 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 35934 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 35935 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22693 | 35936 | } }, |
| 22694 | 35937 | }, .{ |
| 22695 | | .required_features = .{ .x87, null, null, null }, |
| 22696 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 22697 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 35938 | .required_features = .{ .sse, null, null, null }, |
| 35939 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 35940 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22698 | 35941 | .patterns = &.{ |
| 22699 | | .{ .src = .{ .to_mem, .none } }, |
| 35942 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22700 | 35943 | }, |
| 35944 | .call_frame = .{ .alignment = .@"16" }, |
| 22701 | 35945 | .extra_temps = .{ |
| 22702 | 35946 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22703 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 22704 | | .unused, |
| 22705 | | .unused, |
| 22706 | | .unused, |
| 35947 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 35948 | .{ .type = .f32, .kind = .mem }, |
| 35949 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 35950 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22707 | 35951 | .unused, |
| 22708 | 35952 | .unused, |
| 22709 | 35953 | .unused, |
| 22710 | 35954 | .unused, |
| 22711 | 35955 | }, |
| 22712 | 35956 | .dst_temps = .{.mem}, |
| 22713 | | .clobbers = .{ .eflags = true }, |
| 35957 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22714 | 35958 | .each = .{ .once = &.{ |
| 22715 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22716 | | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22717 | | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22718 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 35959 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 35960 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 35961 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 35962 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 35963 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 35964 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 35965 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22719 | 35966 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22720 | 35967 | } }, |
| 22721 | 35968 | }, .{ |
| 22722 | | .required_features = .{ .sse, null, null, null }, |
| 22723 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22724 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 35969 | .required_features = .{ .avx, null, null, null }, |
| 35970 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 35971 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22725 | 35972 | .patterns = &.{ |
| 22726 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 35973 | .{ .src = .{ .mem, .none, .none } }, |
| 35974 | }, |
| 35975 | .dst_temps = .{.{ .rc = .sse }}, |
| 35976 | .each = .{ .once = &.{ |
| 35977 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 35978 | .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .src0d, ._ }, |
| 35979 | } }, |
| 35980 | }, .{ |
| 35981 | .required_features = .{ .avx, null, null, null }, |
| 35982 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 35983 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 35984 | .patterns = &.{ |
| 35985 | .{ .src = .{ .to_sse, .none, .none } }, |
| 35986 | }, |
| 35987 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 35988 | .each = .{ .once = &.{ |
| 35989 | .{ ._, .v_sd, .cvtss2, .dst0x, .src0x, .src0d, ._ }, |
| 35990 | } }, |
| 35991 | }, .{ |
| 35992 | .required_features = .{ .sse2, null, null, null }, |
| 35993 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 35994 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 35995 | .patterns = &.{ |
| 35996 | .{ .src = .{ .mem, .none, .none } }, |
| 35997 | .{ .src = .{ .to_sse, .none, .none } }, |
| 35998 | }, |
| 35999 | .dst_temps = .{.{ .rc = .sse }}, |
| 36000 | .each = .{ .once = &.{ |
| 36001 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 36002 | .{ ._, ._sd, .cvtss2, .dst0x, .src0d, ._, ._ }, |
| 36003 | } }, |
| 36004 | }, .{ |
| 36005 | .required_features = .{ .x87, null, null, null }, |
| 36006 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36007 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36008 | .patterns = &.{ |
| 36009 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22727 | 36010 | }, |
| 22728 | | .call_frame = .{ .alignment = .@"16" }, |
| 22729 | 36011 | .extra_temps = .{ |
| 22730 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 36012 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 22731 | 36013 | .unused, |
| 22732 | 36014 | .unused, |
| 22733 | 36015 | .unused, |
| ... | ... | @@ -22737,23 +36019,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22737 | 36019 | .unused, |
| 22738 | 36020 | .unused, |
| 22739 | 36021 | }, |
| 22740 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 22741 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36022 | .dst_temps = .{.mem}, |
| 22742 | 36023 | .each = .{ .once = &.{ |
| 22743 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 36024 | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, |
| 36025 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 22744 | 36026 | } }, |
| 22745 | 36027 | }, .{ |
| 22746 | 36028 | .required_features = .{ .avx, null, null, null }, |
| 22747 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22748 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 36029 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 36030 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 22749 | 36031 | .patterns = &.{ |
| 22750 | | .{ .src = .{ .to_mem, .none } }, |
| 36032 | .{ .src = .{ .mem, .none, .none } }, |
| 36033 | .{ .src = .{ .to_sse, .none, .none } }, |
| 36034 | }, |
| 36035 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36036 | .each = .{ .once = &.{ |
| 36037 | .{ ._, .v_pd, .cvtps2, .dst0x, .src0q, ._, ._ }, |
| 36038 | } }, |
| 36039 | }, .{ |
| 36040 | .required_features = .{ .sse2, null, null, null }, |
| 36041 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 36042 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 36043 | .patterns = &.{ |
| 36044 | .{ .src = .{ .mem, .none, .none } }, |
| 36045 | .{ .src = .{ .to_sse, .none, .none } }, |
| 36046 | }, |
| 36047 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36048 | .each = .{ .once = &.{ |
| 36049 | .{ ._, ._pd, .cvtps2, .dst0x, .src0q, ._, ._ }, |
| 36050 | } }, |
| 36051 | }, .{ |
| 36052 | .required_features = .{ .avx, null, null, null }, |
| 36053 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 36054 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 36055 | .patterns = &.{ |
| 36056 | .{ .src = .{ .mem, .none, .none } }, |
| 36057 | .{ .src = .{ .to_sse, .none, .none } }, |
| 36058 | }, |
| 36059 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36060 | .each = .{ .once = &.{ |
| 36061 | .{ ._, .v_pd, .cvtps2, .dst0y, .src0x, ._, ._ }, |
| 36062 | } }, |
| 36063 | }, .{ |
| 36064 | .required_features = .{ .avx, null, null, null }, |
| 36065 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 36066 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 36067 | .patterns = &.{ |
| 36068 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22751 | 36069 | }, |
| 22752 | | .call_frame = .{ .alignment = .@"16" }, |
| 22753 | 36070 | .extra_temps = .{ |
| 22754 | 36071 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22755 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22756 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 36072 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 36073 | .unused, |
| 22757 | 36074 | .unused, |
| 22758 | 36075 | .unused, |
| 22759 | 36076 | .unused, |
| ... | ... | @@ -22762,27 +36079,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22762 | 36079 | .unused, |
| 22763 | 36080 | }, |
| 22764 | 36081 | .dst_temps = .{.mem}, |
| 22765 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36082 | .clobbers = .{ .eflags = true }, |
| 22766 | 36083 | .each = .{ .once = &.{ |
| 22767 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22768 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22769 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22770 | | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22771 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 36084 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36085 | .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 36086 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 36087 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 22772 | 36088 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22773 | 36089 | } }, |
| 22774 | 36090 | }, .{ |
| 22775 | | .required_features = .{ .sse4_1, null, null, null }, |
| 22776 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22777 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 36091 | .required_features = .{ .sse2, null, null, null }, |
| 36092 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 36093 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 22778 | 36094 | .patterns = &.{ |
| 22779 | | .{ .src = .{ .to_mem, .none } }, |
| 36095 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22780 | 36096 | }, |
| 22781 | | .call_frame = .{ .alignment = .@"16" }, |
| 22782 | 36097 | .extra_temps = .{ |
| 22783 | 36098 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22784 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22785 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 36099 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 36100 | .unused, |
| 22786 | 36101 | .unused, |
| 22787 | 36102 | .unused, |
| 22788 | 36103 | .unused, |
| ... | ... | @@ -22791,28 +36106,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22791 | 36106 | .unused, |
| 22792 | 36107 | }, |
| 22793 | 36108 | .dst_temps = .{.mem}, |
| 22794 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36109 | .clobbers = .{ .eflags = true }, |
| 22795 | 36110 | .each = .{ .once = &.{ |
| 22796 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22797 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22798 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22799 | | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22800 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 36111 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36112 | .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 36113 | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36114 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22801 | 36115 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22802 | 36116 | } }, |
| 22803 | 36117 | }, .{ |
| 22804 | | .required_features = .{ .sse2, null, null, null }, |
| 22805 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22806 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 36118 | .required_features = .{ .x87, null, null, null }, |
| 36119 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36120 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22807 | 36121 | .patterns = &.{ |
| 22808 | | .{ .src = .{ .to_mem, .none } }, |
| 36122 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22809 | 36123 | }, |
| 22810 | | .call_frame = .{ .alignment = .@"16" }, |
| 22811 | 36124 | .extra_temps = .{ |
| 22812 | 36125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22813 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22814 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22815 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 36126 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 36127 | .unused, |
| 36128 | .unused, |
| 22816 | 36129 | .unused, |
| 22817 | 36130 | .unused, |
| 22818 | 36131 | .unused, |
| ... | ... | @@ -22820,57 +36133,74 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22820 | 36133 | .unused, |
| 22821 | 36134 | }, |
| 22822 | 36135 | .dst_temps = .{.mem}, |
| 22823 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36136 | .clobbers = .{ .eflags = true }, |
| 22824 | 36137 | .each = .{ .once = &.{ |
| 22825 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22826 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22827 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22828 | | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 22829 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 22830 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 36138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36139 | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36140 | .{ ._, .f_p, .st, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36141 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22831 | 36142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22832 | 36143 | } }, |
| 22833 | 36144 | }, .{ |
| 22834 | | .required_features = .{ .sse, null, null, null }, |
| 22835 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22836 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 36145 | .required_features = .{ .x87, null, null, null }, |
| 36146 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36147 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22837 | 36148 | .patterns = &.{ |
| 22838 | | .{ .src = .{ .to_mem, .none } }, |
| 36149 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22839 | 36150 | }, |
| 22840 | | .call_frame = .{ .alignment = .@"16" }, |
| 22841 | 36151 | .extra_temps = .{ |
| 22842 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22843 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 22844 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22845 | | .{ .type = .f32, .kind = .mem }, |
| 22846 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 36152 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 36153 | .unused, |
| 36154 | .unused, |
| 36155 | .unused, |
| 36156 | .unused, |
| 22847 | 36157 | .unused, |
| 22848 | 36158 | .unused, |
| 22849 | 36159 | .unused, |
| 22850 | 36160 | .unused, |
| 22851 | 36161 | }, |
| 22852 | 36162 | .dst_temps = .{.mem}, |
| 22853 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22854 | 36163 | .each = .{ .once = &.{ |
| 22855 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22856 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22857 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22858 | | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, |
| 22859 | | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, |
| 22860 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| 22861 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 36164 | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, |
| 36165 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 36166 | } }, |
| 36167 | }, .{ |
| 36168 | .required_features = .{ .x87, null, null, null }, |
| 36169 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36170 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36171 | .patterns = &.{ |
| 36172 | .{ .src = .{ .to_mem, .none, .none } }, |
| 36173 | }, |
| 36174 | .extra_temps = .{ |
| 36175 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 36176 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 36177 | .unused, |
| 36178 | .unused, |
| 36179 | .unused, |
| 36180 | .unused, |
| 36181 | .unused, |
| 36182 | .unused, |
| 36183 | .unused, |
| 36184 | }, |
| 36185 | .dst_temps = .{.mem}, |
| 36186 | .clobbers = .{ .eflags = true }, |
| 36187 | .each = .{ .once = &.{ |
| 36188 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36189 | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36190 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36191 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22862 | 36192 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22863 | 36193 | } }, |
| 22864 | 36194 | }, .{ |
| 22865 | 36195 | .required_features = .{ .sse, null, null, null }, |
| 22866 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22867 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36196 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36197 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22868 | 36198 | .patterns = &.{ |
| 22869 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 36199 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22870 | 36200 | }, |
| 22871 | 36201 | .call_frame = .{ .alignment = .@"16" }, |
| 22872 | 36202 | .extra_temps = .{ |
| 22873 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 36203 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22874 | 36204 | .unused, |
| 22875 | 36205 | .unused, |
| 22876 | 36206 | .unused, |
| ... | ... | @@ -22887,16 +36217,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22887 | 36217 | } }, |
| 22888 | 36218 | }, .{ |
| 22889 | 36219 | .required_features = .{ .avx, null, null, null }, |
| 22890 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22891 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36220 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36221 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22892 | 36222 | .patterns = &.{ |
| 22893 | | .{ .src = .{ .to_mem, .none } }, |
| 36223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22894 | 36224 | }, |
| 22895 | 36225 | .call_frame = .{ .alignment = .@"16" }, |
| 22896 | 36226 | .extra_temps = .{ |
| 22897 | 36227 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22898 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22899 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 36228 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 36229 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22900 | 36230 | .unused, |
| 22901 | 36231 | .unused, |
| 22902 | 36232 | .unused, |
| ... | ... | @@ -22907,25 +36237,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22907 | 36237 | .dst_temps = .{.mem}, |
| 22908 | 36238 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22909 | 36239 | .each = .{ .once = &.{ |
| 22910 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22911 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36240 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36241 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22912 | 36242 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22913 | | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36243 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22914 | 36244 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22915 | 36245 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22916 | 36246 | } }, |
| 22917 | 36247 | }, .{ |
| 22918 | 36248 | .required_features = .{ .sse2, null, null, null }, |
| 22919 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22920 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36249 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36250 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22921 | 36251 | .patterns = &.{ |
| 22922 | | .{ .src = .{ .to_mem, .none } }, |
| 36252 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22923 | 36253 | }, |
| 22924 | 36254 | .call_frame = .{ .alignment = .@"16" }, |
| 22925 | 36255 | .extra_temps = .{ |
| 22926 | 36256 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22927 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22928 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 36257 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 36258 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22929 | 36259 | .unused, |
| 22930 | 36260 | .unused, |
| 22931 | 36261 | .unused, |
| ... | ... | @@ -22936,25 +36266,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22936 | 36266 | .dst_temps = .{.mem}, |
| 22937 | 36267 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22938 | 36268 | .each = .{ .once = &.{ |
| 22939 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22940 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36269 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36270 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22941 | 36271 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22942 | | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36272 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22943 | 36273 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22944 | 36274 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22945 | 36275 | } }, |
| 22946 | 36276 | }, .{ |
| 22947 | 36277 | .required_features = .{ .sse, null, null, null }, |
| 22948 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22949 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36278 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36279 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22950 | 36280 | .patterns = &.{ |
| 22951 | | .{ .src = .{ .to_mem, .none } }, |
| 36281 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22952 | 36282 | }, |
| 22953 | 36283 | .call_frame = .{ .alignment = .@"16" }, |
| 22954 | 36284 | .extra_temps = .{ |
| 22955 | 36285 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22956 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22957 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 36286 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 36287 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22958 | 36288 | .unused, |
| 22959 | 36289 | .unused, |
| 22960 | 36290 | .unused, |
| ... | ... | @@ -22965,23 +36295,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22965 | 36295 | .dst_temps = .{.mem}, |
| 22966 | 36296 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22967 | 36297 | .each = .{ .once = &.{ |
| 22968 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22969 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36298 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36299 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22970 | 36300 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22971 | | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36301 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22972 | 36302 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22973 | 36303 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22974 | 36304 | } }, |
| 36305 | }, .{ |
| 36306 | .required_features = .{ .x87, null, null, null }, |
| 36307 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36308 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36309 | .patterns = &.{ |
| 36310 | .{ .src = .{ .to_mem, .none, .none } }, |
| 36311 | }, |
| 36312 | .extra_temps = .{ |
| 36313 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 36314 | .unused, |
| 36315 | .unused, |
| 36316 | .unused, |
| 36317 | .unused, |
| 36318 | .unused, |
| 36319 | .unused, |
| 36320 | .unused, |
| 36321 | .unused, |
| 36322 | }, |
| 36323 | .dst_temps = .{.mem}, |
| 36324 | .each = .{ .once = &.{ |
| 36325 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 36326 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 36327 | } }, |
| 36328 | }, .{ |
| 36329 | .required_features = .{ .x87, null, null, null }, |
| 36330 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36331 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36332 | .patterns = &.{ |
| 36333 | .{ .src = .{ .to_mem, .none, .none } }, |
| 36334 | }, |
| 36335 | .extra_temps = .{ |
| 36336 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 36337 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 36338 | .unused, |
| 36339 | .unused, |
| 36340 | .unused, |
| 36341 | .unused, |
| 36342 | .unused, |
| 36343 | .unused, |
| 36344 | .unused, |
| 36345 | }, |
| 36346 | .dst_temps = .{.mem}, |
| 36347 | .clobbers = .{ .eflags = true }, |
| 36348 | .each = .{ .once = &.{ |
| 36349 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36350 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36351 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36352 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 36353 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36354 | } }, |
| 22975 | 36355 | }, .{ |
| 22976 | 36356 | .required_features = .{ .sse, null, null, null }, |
| 22977 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 22978 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36357 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36358 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22979 | 36359 | .patterns = &.{ |
| 22980 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 36360 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22981 | 36361 | }, |
| 22982 | 36362 | .call_frame = .{ .alignment = .@"16" }, |
| 22983 | 36363 | .extra_temps = .{ |
| 22984 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 36364 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 22985 | 36365 | .unused, |
| 22986 | 36366 | .unused, |
| 22987 | 36367 | .unused, |
| ... | ... | @@ -22998,16 +36378,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22998 | 36378 | } }, |
| 22999 | 36379 | }, .{ |
| 23000 | 36380 | .required_features = .{ .avx, null, null, null }, |
| 23001 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23002 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36381 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36382 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23003 | 36383 | .patterns = &.{ |
| 23004 | | .{ .src = .{ .to_mem, .none } }, |
| 36384 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23005 | 36385 | }, |
| 23006 | 36386 | .call_frame = .{ .alignment = .@"16" }, |
| 23007 | 36387 | .extra_temps = .{ |
| 23008 | 36388 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23009 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23010 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 36389 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 36390 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 23011 | 36391 | .unused, |
| 23012 | 36392 | .unused, |
| 23013 | 36393 | .unused, |
| ... | ... | @@ -23018,25 +36398,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23018 | 36398 | .dst_temps = .{.mem}, |
| 23019 | 36399 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23020 | 36400 | .each = .{ .once = &.{ |
| 23021 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23022 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36401 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36402 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23023 | 36403 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23024 | | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36404 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23025 | 36405 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23026 | 36406 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23027 | 36407 | } }, |
| 23028 | 36408 | }, .{ |
| 23029 | 36409 | .required_features = .{ .sse2, null, null, null }, |
| 23030 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23031 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36410 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36411 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23032 | 36412 | .patterns = &.{ |
| 23033 | | .{ .src = .{ .to_mem, .none } }, |
| 36413 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23034 | 36414 | }, |
| 23035 | 36415 | .call_frame = .{ .alignment = .@"16" }, |
| 23036 | 36416 | .extra_temps = .{ |
| 23037 | 36417 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23038 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23039 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 36418 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 36419 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 23040 | 36420 | .unused, |
| 23041 | 36421 | .unused, |
| 23042 | 36422 | .unused, |
| ... | ... | @@ -23047,25 +36427,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23047 | 36427 | .dst_temps = .{.mem}, |
| 23048 | 36428 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23049 | 36429 | .each = .{ .once = &.{ |
| 23050 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23051 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36430 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36431 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23052 | 36432 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23053 | | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36433 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23054 | 36434 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23055 | 36435 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23056 | 36436 | } }, |
| 23057 | 36437 | }, .{ |
| 23058 | 36438 | .required_features = .{ .sse, null, null, null }, |
| 23059 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23060 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36439 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36440 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23061 | 36441 | .patterns = &.{ |
| 23062 | | .{ .src = .{ .to_mem, .none } }, |
| 36442 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23063 | 36443 | }, |
| 23064 | 36444 | .call_frame = .{ .alignment = .@"16" }, |
| 23065 | 36445 | .extra_temps = .{ |
| 23066 | 36446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23067 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23068 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 36447 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 36448 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 23069 | 36449 | .unused, |
| 23070 | 36450 | .unused, |
| 23071 | 36451 | .unused, |
| ... | ... | @@ -23076,50 +36456,105 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23076 | 36456 | .dst_temps = .{.mem}, |
| 23077 | 36457 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23078 | 36458 | .each = .{ .once = &.{ |
| 23079 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23080 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36459 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 36460 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 36461 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23081 | 36462 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23082 | | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 36463 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23083 | 36464 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23084 | 36465 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23085 | 36466 | } }, |
| 23086 | 36467 | }, .{ |
| 23087 | | .required_features = .{ .sse, null, null, null }, |
| 23088 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23089 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36468 | .required_features = .{ .avx, null, null, null }, |
| 36469 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 36470 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23090 | 36471 | .patterns = &.{ |
| 23091 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 36472 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23092 | 36473 | }, |
| 23093 | | .call_frame = .{ .alignment = .@"16" }, |
| 36474 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 23094 | 36475 | .extra_temps = .{ |
| 23095 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 36476 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 36477 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 36478 | .unused, |
| 23096 | 36479 | .unused, |
| 23097 | 36480 | .unused, |
| 23098 | 36481 | .unused, |
| 23099 | 36482 | .unused, |
| 23100 | 36483 | .unused, |
| 23101 | 36484 | .unused, |
| 36485 | }, |
| 36486 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 36487 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36488 | .each = .{ .once = &.{ |
| 36489 | .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 36490 | .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 36491 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 36492 | } }, |
| 36493 | }, .{ |
| 36494 | .required_features = .{ .sse2, null, null, null }, |
| 36495 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 36496 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 36497 | .patterns = &.{ |
| 36498 | .{ .src = .{ .to_mem, .none, .none } }, |
| 36499 | }, |
| 36500 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 36501 | .extra_temps = .{ |
| 36502 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 36503 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 36504 | .unused, |
| 36505 | .unused, |
| 36506 | .unused, |
| 36507 | .unused, |
| 36508 | .unused, |
| 23102 | 36509 | .unused, |
| 23103 | 36510 | .unused, |
| 23104 | 36511 | }, |
| 23105 | | .dst_temps = .{.{ .reg = .st0 }}, |
| 36512 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 23106 | 36513 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23107 | 36514 | .each = .{ .once = &.{ |
| 23108 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 36515 | .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 36516 | .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 36517 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 36518 | } }, |
| 36519 | }, .{ |
| 36520 | .required_features = .{ .sse, null, null, null }, |
| 36521 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 36522 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 36523 | .patterns = &.{ |
| 36524 | .{ .src = .{ .to_mem, .none, .none } }, |
| 36525 | }, |
| 36526 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 36527 | .extra_temps = .{ |
| 36528 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 36529 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 36530 | .unused, |
| 36531 | .unused, |
| 36532 | .unused, |
| 36533 | .unused, |
| 36534 | .unused, |
| 36535 | .unused, |
| 36536 | .unused, |
| 36537 | }, |
| 36538 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 36539 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36540 | .each = .{ .once = &.{ |
| 36541 | .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, |
| 36542 | .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 36543 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 23109 | 36544 | } }, |
| 23110 | 36545 | }, .{ |
| 23111 | 36546 | .required_features = .{ .avx, null, null, null }, |
| 23112 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23113 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36547 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 36548 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23114 | 36549 | .patterns = &.{ |
| 23115 | | .{ .src = .{ .to_mem, .none } }, |
| 36550 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23116 | 36551 | }, |
| 23117 | | .call_frame = .{ .alignment = .@"16" }, |
| 36552 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 23118 | 36553 | .extra_temps = .{ |
| 23119 | 36554 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23120 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23121 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 23122 | | .unused, |
| 36555 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 36556 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 36557 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 23123 | 36558 | .unused, |
| 23124 | 36559 | .unused, |
| 23125 | 36560 | .unused, |
| ... | ... | @@ -23129,27 +36564,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23129 | 36564 | .dst_temps = .{.mem}, |
| 23130 | 36565 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23131 | 36566 | .each = .{ .once = &.{ |
| 23132 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36567 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23133 | 36568 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23134 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23135 | | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 23136 | | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36569 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 36570 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 36571 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23137 | 36572 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23138 | 36573 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23139 | 36574 | } }, |
| 23140 | 36575 | }, .{ |
| 23141 | 36576 | .required_features = .{ .sse2, null, null, null }, |
| 23142 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23143 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36577 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 36578 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23144 | 36579 | .patterns = &.{ |
| 23145 | | .{ .src = .{ .to_mem, .none } }, |
| 36580 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23146 | 36581 | }, |
| 23147 | | .call_frame = .{ .alignment = .@"16" }, |
| 36582 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 23148 | 36583 | .extra_temps = .{ |
| 23149 | 36584 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23150 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23151 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 23152 | | .unused, |
| 36585 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 36586 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 36587 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 23153 | 36588 | .unused, |
| 23154 | 36589 | .unused, |
| 23155 | 36590 | .unused, |
| ... | ... | @@ -23159,27 +36594,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23159 | 36594 | .dst_temps = .{.mem}, |
| 23160 | 36595 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23161 | 36596 | .each = .{ .once = &.{ |
| 23162 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36597 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23163 | 36598 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23164 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23165 | | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 23166 | | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36599 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 36600 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 36601 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23167 | 36602 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23168 | 36603 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23169 | 36604 | } }, |
| 23170 | 36605 | }, .{ |
| 23171 | 36606 | .required_features = .{ .sse, null, null, null }, |
| 23172 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, |
| 23173 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36607 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 36608 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23174 | 36609 | .patterns = &.{ |
| 23175 | | .{ .src = .{ .to_mem, .none } }, |
| 36610 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23176 | 36611 | }, |
| 23177 | | .call_frame = .{ .alignment = .@"16" }, |
| 36612 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 23178 | 36613 | .extra_temps = .{ |
| 23179 | 36614 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23180 | | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 23181 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, |
| 23182 | | .unused, |
| 36615 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 36616 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 36617 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 23183 | 36618 | .unused, |
| 23184 | 36619 | .unused, |
| 23185 | 36620 | .unused, |
| ... | ... | @@ -23189,11 +36624,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23189 | 36624 | .dst_temps = .{.mem}, |
| 23190 | 36625 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23191 | 36626 | .each = .{ .once = &.{ |
| 23192 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36627 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23193 | 36628 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23194 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23195 | | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 23196 | | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 36629 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 36630 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 36631 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23197 | 36632 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23198 | 36633 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23199 | 36634 | } }, |
| ... | ... | @@ -23208,138 +36643,76 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23208 | 36643 | }; |
| 23209 | 36644 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 23210 | 36645 | }, |
| 23211 | | .fpext => |air_tag| if (use_old) try cg.airFpext(inst) else { |
| 36646 | .intcast => |air_tag| if (use_old) try cg.airIntCast(inst) else { |
| 23212 | 36647 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 36648 | const dst_ty = ty_op.ty.toType(); |
| 36649 | const src_ty = cg.typeOf(ty_op.operand); |
| 23213 | 36650 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 23214 | 36651 | var res: [1]Temp = undefined; |
| 23215 | | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 23216 | | .required_features = .{ .f16c, null, null, null }, |
| 23217 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23218 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36652 | cg.select(&res, &.{dst_ty}, &ops, if (dst_ty.scalarType(zcu).abiSize(zcu) <= src_ty.scalarType(zcu).abiSize(zcu)) comptime &.{ .{ |
| 36653 | .dst_constraints = .{.{ .int = .dword }}, |
| 23219 | 36654 | .patterns = &.{ |
| 23220 | | .{ .src = .{ .to_sse, .none } }, |
| 36655 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 36656 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 23221 | 36657 | }, |
| 23222 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23223 | | .each = .{ .once = &.{ |
| 23224 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 23225 | | } }, |
| 36658 | .dst_temps = .{.{ .ref = .src0 }}, |
| 36659 | .each = .{ .once = &.{} }, |
| 23226 | 36660 | }, .{ |
| 23227 | | .required_features = .{ .f16c, null, null, null }, |
| 23228 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any }, |
| 23229 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 36661 | .required_features = .{ .@"64bit", null, null, null }, |
| 36662 | .dst_constraints = .{.{ .int = .qword }}, |
| 23230 | 36663 | .patterns = &.{ |
| 23231 | | .{ .src = .{ .mem, .none } }, |
| 23232 | | .{ .src = .{ .to_sse, .none } }, |
| 36664 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 36665 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 23233 | 36666 | }, |
| 23234 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23235 | | .each = .{ .once = &.{ |
| 23236 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 23237 | | } }, |
| 36667 | .dst_temps = .{.{ .ref = .src0 }}, |
| 36668 | .each = .{ .once = &.{} }, |
| 23238 | 36669 | }, .{ |
| 23239 | | .required_features = .{ .f16c, null, null, null }, |
| 23240 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any }, |
| 23241 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 36670 | .dst_constraints = .{.{ .int = .byte }}, |
| 23242 | 36671 | .patterns = &.{ |
| 23243 | | .{ .src = .{ .mem, .none } }, |
| 23244 | | .{ .src = .{ .to_sse, .none } }, |
| 36672 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23245 | 36673 | }, |
| 23246 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36674 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23247 | 36675 | .each = .{ .once = &.{ |
| 23248 | | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 36676 | .{ ._, ._, .mov, .dst0b, .mem(.src0b), ._, ._ }, |
| 23249 | 36677 | } }, |
| 23250 | 36678 | }, .{ |
| 23251 | | .required_features = .{ .sse, null, null, null }, |
| 23252 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23253 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36679 | .dst_constraints = .{.{ .int = .word }}, |
| 23254 | 36680 | .patterns = &.{ |
| 23255 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 23256 | | }, |
| 23257 | | .call_frame = .{ .alignment = .@"16" }, |
| 23258 | | .extra_temps = .{ |
| 23259 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 23260 | | .unused, |
| 23261 | | .unused, |
| 23262 | | .unused, |
| 23263 | | .unused, |
| 23264 | | .unused, |
| 23265 | | .unused, |
| 23266 | | .unused, |
| 23267 | | .unused, |
| 36681 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23268 | 36682 | }, |
| 23269 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 23270 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36683 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23271 | 36684 | .each = .{ .once = &.{ |
| 23272 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 36685 | .{ ._, ._, .mov, .dst0w, .mem(.src0w), ._, ._ }, |
| 23273 | 36686 | } }, |
| 23274 | 36687 | }, .{ |
| 23275 | | .required_features = .{ .f16c, null, null, null }, |
| 23276 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any }, |
| 23277 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 36688 | .dst_constraints = .{.{ .int = .dword }}, |
| 23278 | 36689 | .patterns = &.{ |
| 23279 | | .{ .src = .{ .to_mem, .none } }, |
| 23280 | | }, |
| 23281 | | .extra_temps = .{ |
| 23282 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23283 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 23284 | | .unused, |
| 23285 | | .unused, |
| 23286 | | .unused, |
| 23287 | | .unused, |
| 23288 | | .unused, |
| 23289 | | .unused, |
| 23290 | | .unused, |
| 36690 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23291 | 36691 | }, |
| 23292 | | .dst_temps = .{.mem}, |
| 23293 | | .clobbers = .{ .eflags = true }, |
| 36692 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23294 | 36693 | .each = .{ .once = &.{ |
| 23295 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23296 | | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23297 | | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 23298 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23299 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36694 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 23300 | 36695 | } }, |
| 23301 | 36696 | }, .{ |
| 23302 | | .required_features = .{ .avx, null, null, null }, |
| 23303 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23304 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36697 | .required_features = .{ .@"64bit", null, null, null }, |
| 36698 | .dst_constraints = .{.{ .int = .qword }}, |
| 23305 | 36699 | .patterns = &.{ |
| 23306 | | .{ .src = .{ .to_mem, .none } }, |
| 23307 | | }, |
| 23308 | | .call_frame = .{ .alignment = .@"16" }, |
| 23309 | | .extra_temps = .{ |
| 23310 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23311 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23312 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 23313 | | .unused, |
| 23314 | | .unused, |
| 23315 | | .unused, |
| 23316 | | .unused, |
| 23317 | | .unused, |
| 23318 | | .unused, |
| 36700 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23319 | 36701 | }, |
| 23320 | | .dst_temps = .{.mem}, |
| 23321 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36702 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23322 | 36703 | .each = .{ .once = &.{ |
| 23323 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23324 | | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 23325 | | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 23326 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23327 | | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23328 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23329 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36704 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 23330 | 36705 | } }, |
| 23331 | 36706 | }, .{ |
| 23332 | | .required_features = .{ .sse2, null, null, null }, |
| 23333 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23334 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36707 | .required_features = .{ .@"64bit", null, null, null }, |
| 36708 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 23335 | 36709 | .patterns = &.{ |
| 23336 | | .{ .src = .{ .to_mem, .none } }, |
| 36710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23337 | 36711 | }, |
| 23338 | | .call_frame = .{ .alignment = .@"16" }, |
| 23339 | 36712 | .extra_temps = .{ |
| 23340 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23341 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23342 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 36713 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 36714 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 36715 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 23343 | 36716 | .unused, |
| 23344 | 36717 | .unused, |
| 23345 | 36718 | .unused, |
| ... | ... | @@ -23348,180 +36721,109 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23348 | 36721 | .unused, |
| 23349 | 36722 | }, |
| 23350 | 36723 | .dst_temps = .{.mem}, |
| 23351 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23352 | 36724 | .each = .{ .once = &.{ |
| 23353 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23354 | | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 23355 | | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 23356 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23357 | | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23358 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23359 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36725 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 36726 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 36727 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| 36728 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 23360 | 36729 | } }, |
| 23361 | 36730 | }, .{ |
| 23362 | 36731 | .required_features = .{ .sse, null, null, null }, |
| 23363 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23364 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 36732 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 36733 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, |
| 23365 | 36734 | .patterns = &.{ |
| 23366 | | .{ .src = .{ .to_mem, .none } }, |
| 36735 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 36736 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23367 | 36737 | }, |
| 23368 | | .call_frame = .{ .alignment = .@"16" }, |
| 23369 | | .extra_temps = .{ |
| 23370 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23371 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 23372 | | .{ .type = .f32, .kind = .mem }, |
| 23373 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23374 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 23375 | | .unused, |
| 23376 | | .unused, |
| 23377 | | .unused, |
| 23378 | | .unused, |
| 36738 | .dst_temps = .{.{ .ref = .src0 }}, |
| 36739 | .each = .{ .once = &.{} }, |
| 36740 | }, .{ |
| 36741 | .required_features = .{ .avx, null, null, null }, |
| 36742 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 36743 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .byte } }}, |
| 36744 | .patterns = &.{ |
| 36745 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 36746 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23379 | 36747 | }, |
| 23380 | | .dst_temps = .{.mem}, |
| 23381 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23382 | | .each = .{ .once = &.{ |
| 23383 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23384 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23385 | | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 23386 | | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 23387 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23388 | | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 23389 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23390 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23391 | | } }, |
| 36748 | .dst_temps = .{.{ .ref = .src0 }}, |
| 36749 | .each = .{ .once = &.{} }, |
| 23392 | 36750 | }, .{ |
| 23393 | | .required_features = .{ .f16c, null, null, null }, |
| 23394 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23395 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36751 | .required_features = .{ .avx, null, null, null }, |
| 36752 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 36753 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 23396 | 36754 | .patterns = &.{ |
| 23397 | | .{ .src = .{ .to_sse, .none } }, |
| 36755 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23398 | 36756 | }, |
| 23399 | 36757 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23400 | 36758 | .each = .{ .once = &.{ |
| 23401 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 23402 | | .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .dst0d, ._ }, |
| 36759 | .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ }, |
| 23403 | 36760 | } }, |
| 23404 | 36761 | }, .{ |
| 23405 | | .required_features = .{ .f16c, null, null, null }, |
| 23406 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .word } }, .any }, |
| 23407 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 36762 | .required_features = .{ .avx, null, null, null }, |
| 36763 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 36764 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 23408 | 36765 | .patterns = &.{ |
| 23409 | | .{ .src = .{ .mem, .none } }, |
| 23410 | | .{ .src = .{ .to_sse, .none } }, |
| 36766 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23411 | 36767 | }, |
| 23412 | 36768 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23413 | 36769 | .each = .{ .once = &.{ |
| 23414 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 23415 | | .{ ._, .v_pd, .cvtps2, .dst0x, .dst0q, ._, ._ }, |
| 36770 | .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ }, |
| 23416 | 36771 | } }, |
| 23417 | 36772 | }, .{ |
| 23418 | | .required_features = .{ .f16c, null, null, null }, |
| 23419 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any }, |
| 23420 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 36773 | .required_features = .{ .sse2, null, null, null }, |
| 36774 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 36775 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 23421 | 36776 | .patterns = &.{ |
| 23422 | | .{ .src = .{ .mem, .none } }, |
| 23423 | | .{ .src = .{ .to_sse, .none } }, |
| 36777 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23424 | 36778 | }, |
| 23425 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36779 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23426 | 36780 | .each = .{ .once = &.{ |
| 23427 | | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 23428 | | .{ ._, .v_pd, .cvtps2, .dst0y, .dst0x, ._, ._ }, |
| 36781 | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, |
| 23429 | 36782 | } }, |
| 23430 | 36783 | }, .{ |
| 23431 | | .required_features = .{ .f16c, null, null, null }, |
| 23432 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any }, |
| 23433 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .zword, .is = .qword } }}, |
| 36784 | .required_features = .{ .sse2, null, null, null }, |
| 36785 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 36786 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 23434 | 36787 | .patterns = &.{ |
| 23435 | | .{ .src = .{ .mem, .none } }, |
| 23436 | | .{ .src = .{ .to_sse, .none } }, |
| 23437 | | }, |
| 23438 | | .extra_temps = .{ |
| 23439 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 23440 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23441 | | .unused, |
| 23442 | | .unused, |
| 23443 | | .unused, |
| 23444 | | .unused, |
| 23445 | | .unused, |
| 23446 | | .unused, |
| 23447 | | .unused, |
| 36788 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23448 | 36789 | }, |
| 23449 | | .dst_temps = .{.mem}, |
| 36790 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23450 | 36791 | .each = .{ .once = &.{ |
| 23451 | | .{ ._, .v_ps, .cvtph2, .tmp0y, .src0x, ._, ._ }, |
| 23452 | | .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ }, |
| 23453 | | .{ ._, .v_f128, .extract, .tmp0x, .tmp0y, .ui(1), ._ }, |
| 23454 | | .{ ._, .v_pd, .mova, .mem(.dst0y), .tmp1y, ._, ._ }, |
| 23455 | | .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ }, |
| 23456 | | .{ ._, .v_pd, .mova, .memd(.dst0y, 32), .tmp1y, ._, ._ }, |
| 36792 | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, |
| 23457 | 36793 | } }, |
| 23458 | 36794 | }, .{ |
| 23459 | | .required_features = .{ .sse, null, null, null }, |
| 23460 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23461 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36795 | .required_features = .{ .avx2, null, null, null }, |
| 36796 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 36797 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 23462 | 36798 | .patterns = &.{ |
| 23463 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 23464 | | }, |
| 23465 | | .call_frame = .{ .alignment = .@"16" }, |
| 23466 | | .extra_temps = .{ |
| 23467 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 23468 | | .unused, |
| 23469 | | .unused, |
| 23470 | | .unused, |
| 23471 | | .unused, |
| 23472 | | .unused, |
| 23473 | | .unused, |
| 23474 | | .unused, |
| 23475 | | .unused, |
| 36799 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23476 | 36800 | }, |
| 23477 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 23478 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36801 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23479 | 36802 | .each = .{ .once = &.{ |
| 23480 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 36803 | .{ ._, .vp_b, .ackssw, .dst0y, .src0y, .dst0y, ._ }, |
| 23481 | 36804 | } }, |
| 23482 | 36805 | }, .{ |
| 23483 | | .required_features = .{ .f16c, null, null, null }, |
| 23484 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any }, |
| 23485 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }}, |
| 36806 | .required_features = .{ .avx2, null, null, null }, |
| 36807 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 36808 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, |
| 23486 | 36809 | .patterns = &.{ |
| 23487 | | .{ .src = .{ .to_mem, .none } }, |
| 36810 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23488 | 36811 | }, |
| 23489 | | .extra_temps = .{ |
| 23490 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23491 | | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 23492 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 23493 | | .unused, |
| 23494 | | .unused, |
| 23495 | | .unused, |
| 23496 | | .unused, |
| 23497 | | .unused, |
| 23498 | | .unused, |
| 23499 | | }, |
| 23500 | | .dst_temps = .{.mem}, |
| 23501 | | .clobbers = .{ .eflags = true }, |
| 36812 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23502 | 36813 | .each = .{ .once = &.{ |
| 23503 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23504 | | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23505 | | .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, |
| 23506 | | .{ ._, .v_f128, .extract, .tmp1x, .tmp1y, .ui(1), ._ }, |
| 23507 | | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 23508 | | .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, |
| 23509 | | .{ ._, .v_pd, .mova, .memsiad(.dst0y, .@"4", .tmp0, .add_unaligned_size, 32), .tmp2y, ._, ._ }, |
| 23510 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23511 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36814 | .{ ._, .vp_b, .ackusw, .dst0y, .src0y, .dst0y, ._ }, |
| 23512 | 36815 | } }, |
| 23513 | 36816 | }, .{ |
| 23514 | | .required_features = .{ .avx, null, null, null }, |
| 23515 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23516 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36817 | .required_features = .{ .slow_incdec, null, null, null }, |
| 36818 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 36819 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23517 | 36820 | .patterns = &.{ |
| 23518 | | .{ .src = .{ .to_mem, .none } }, |
| 36821 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23519 | 36822 | }, |
| 23520 | | .call_frame = .{ .alignment = .@"16" }, |
| 23521 | 36823 | .extra_temps = .{ |
| 23522 | 36824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23523 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23524 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 36825 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 36826 | .unused, |
| 23525 | 36827 | .unused, |
| 23526 | 36828 | .unused, |
| 23527 | 36829 | .unused, |
| ... | ... | @@ -23530,28 +36832,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23530 | 36832 | .unused, |
| 23531 | 36833 | }, |
| 23532 | 36834 | .dst_temps = .{.mem}, |
| 23533 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36835 | .clobbers = .{ .eflags = true }, |
| 23534 | 36836 | .each = .{ .once = &.{ |
| 23535 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23536 | | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 23537 | | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 23538 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23539 | | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23540 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 36837 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36838 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36839 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 36840 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23541 | 36841 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23542 | 36842 | } }, |
| 23543 | 36843 | }, .{ |
| 23544 | | .required_features = .{ .sse2, null, null, null }, |
| 23545 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23546 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36844 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 36845 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23547 | 36846 | .patterns = &.{ |
| 23548 | | .{ .src = .{ .to_mem, .none } }, |
| 36847 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23549 | 36848 | }, |
| 23550 | | .call_frame = .{ .alignment = .@"16" }, |
| 23551 | 36849 | .extra_temps = .{ |
| 23552 | 36850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23553 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23554 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 36851 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 36852 | .unused, |
| 23555 | 36853 | .unused, |
| 23556 | 36854 | .unused, |
| 23557 | 36855 | .unused, |
| ... | ... | @@ -23560,108 +36858,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23560 | 36858 | .unused, |
| 23561 | 36859 | }, |
| 23562 | 36860 | .dst_temps = .{.mem}, |
| 23563 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36861 | .clobbers = .{ .eflags = true }, |
| 23564 | 36862 | .each = .{ .once = &.{ |
| 23565 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23566 | | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 23567 | | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 23568 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23569 | | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23570 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23571 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36863 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36864 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36865 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 36866 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 36867 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23572 | 36868 | } }, |
| 23573 | 36869 | }, .{ |
| 23574 | | .required_features = .{ .sse, null, null, null }, |
| 23575 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23576 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 36870 | .required_features = .{ .avx, null, null, null }, |
| 36871 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 36872 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, |
| 23577 | 36873 | .patterns = &.{ |
| 23578 | | .{ .src = .{ .to_mem, .none } }, |
| 36874 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23579 | 36875 | }, |
| 23580 | | .call_frame = .{ .alignment = .@"16" }, |
| 23581 | | .extra_temps = .{ |
| 23582 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23583 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 23584 | | .{ .type = .f32, .kind = .mem }, |
| 23585 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23586 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 23587 | | .unused, |
| 23588 | | .unused, |
| 23589 | | .unused, |
| 23590 | | .unused, |
| 36876 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36877 | .each = .{ .once = &.{ |
| 36878 | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, |
| 36879 | .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ }, |
| 36880 | } }, |
| 36881 | }, .{ |
| 36882 | .required_features = .{ .avx, null, null, null }, |
| 36883 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 36884 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 36885 | .patterns = &.{ |
| 36886 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23591 | 36887 | }, |
| 23592 | | .dst_temps = .{.mem}, |
| 23593 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36888 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23594 | 36889 | .each = .{ .once = &.{ |
| 23595 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23596 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23597 | | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 23598 | | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 23599 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23600 | | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 23601 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23602 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36890 | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, |
| 36891 | .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ }, |
| 23603 | 36892 | } }, |
| 23604 | 36893 | }, .{ |
| 23605 | | .required_features = .{ .f16c, .x87, null, null }, |
| 23606 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23607 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36894 | .required_features = .{ .sse2, null, null, null }, |
| 36895 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 36896 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, |
| 23608 | 36897 | .patterns = &.{ |
| 23609 | | .{ .src = .{ .to_sse, .none } }, |
| 36898 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23610 | 36899 | }, |
| 23611 | | .extra_temps = .{ |
| 23612 | | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 23613 | | .{ .type = .f32, .kind = .mem }, |
| 23614 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 23615 | | .unused, |
| 23616 | | .unused, |
| 23617 | | .unused, |
| 23618 | | .unused, |
| 23619 | | .unused, |
| 23620 | | .unused, |
| 36900 | .dst_temps = .{.{ .ref = .src0 }}, |
| 36901 | .each = .{ .once = &.{ |
| 36902 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 36903 | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, |
| 36904 | } }, |
| 36905 | }, .{ |
| 36906 | .required_features = .{ .sse4_1, null, null, null }, |
| 36907 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 36908 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 36909 | .patterns = &.{ |
| 36910 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23621 | 36911 | }, |
| 23622 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 36912 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23623 | 36913 | .each = .{ .once = &.{ |
| 23624 | | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 23625 | | .{ ._, .v_ss, .mov, .mem(.tmp1d), .tmp0x, ._, ._ }, |
| 23626 | | .{ ._, .f_, .ld, .mem(.tmp1d), ._, ._, ._ }, |
| 23627 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 36914 | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 36915 | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, |
| 23628 | 36916 | } }, |
| 23629 | 36917 | }, .{ |
| 23630 | | .required_features = .{ .sse, null, null, null }, |
| 23631 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23632 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36918 | .required_features = .{ .avx2, null, null, null }, |
| 36919 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 36920 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 23633 | 36921 | .patterns = &.{ |
| 23634 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 36922 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23635 | 36923 | }, |
| 23636 | | .call_frame = .{ .alignment = .@"16" }, |
| 23637 | | .extra_temps = .{ |
| 23638 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 23639 | | .unused, |
| 23640 | | .unused, |
| 23641 | | .unused, |
| 23642 | | .unused, |
| 23643 | | .unused, |
| 23644 | | .unused, |
| 23645 | | .unused, |
| 23646 | | .unused, |
| 36924 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 36925 | .each = .{ .once = &.{ |
| 36926 | .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, |
| 36927 | .{ ._, .vp_b, .ackssw, .dst0y, .dst0y, .dst0y, ._ }, |
| 36928 | } }, |
| 36929 | }, .{ |
| 36930 | .required_features = .{ .avx2, null, null, null }, |
| 36931 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 36932 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 36933 | .patterns = &.{ |
| 36934 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23647 | 36935 | }, |
| 23648 | | .dst_temps = .{.{ .reg = .st0 }}, |
| 23649 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36936 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23650 | 36937 | .each = .{ .once = &.{ |
| 23651 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 36938 | .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, |
| 36939 | .{ ._, .vp_b, .ackusw, .dst0y, .dst0y, .dst0y, ._ }, |
| 23652 | 36940 | } }, |
| 23653 | 36941 | }, .{ |
| 23654 | | .required_features = .{ .avx, null, null, null }, |
| 23655 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23656 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36942 | .required_features = .{ .slow_incdec, null, null, null }, |
| 36943 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36944 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23657 | 36945 | .patterns = &.{ |
| 23658 | | .{ .src = .{ .to_mem, .none } }, |
| 36946 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23659 | 36947 | }, |
| 23660 | | .call_frame = .{ .alignment = .@"16" }, |
| 23661 | 36948 | .extra_temps = .{ |
| 23662 | 36949 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23663 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23664 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 36950 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 36951 | .unused, |
| 23665 | 36952 | .unused, |
| 23666 | 36953 | .unused, |
| 23667 | 36954 | .unused, |
| ... | ... | @@ -23670,29 +36957,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23670 | 36957 | .unused, |
| 23671 | 36958 | }, |
| 23672 | 36959 | .dst_temps = .{.mem}, |
| 23673 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36960 | .clobbers = .{ .eflags = true }, |
| 23674 | 36961 | .each = .{ .once = &.{ |
| 23675 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23676 | | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 23677 | | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 23678 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23679 | | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 23680 | | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 23681 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 36962 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36963 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36964 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 36965 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23682 | 36966 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23683 | 36967 | } }, |
| 23684 | 36968 | }, .{ |
| 23685 | | .required_features = .{ .sse2, null, null, null }, |
| 23686 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23687 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36969 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 36970 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23688 | 36971 | .patterns = &.{ |
| 23689 | | .{ .src = .{ .to_mem, .none } }, |
| 36972 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23690 | 36973 | }, |
| 23691 | | .call_frame = .{ .alignment = .@"16" }, |
| 23692 | 36974 | .extra_temps = .{ |
| 23693 | 36975 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23694 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23695 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 36976 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 36977 | .unused, |
| 23696 | 36978 | .unused, |
| 23697 | 36979 | .unused, |
| 23698 | 36980 | .unused, |
| ... | ... | @@ -23701,60 +36983,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23701 | 36983 | .unused, |
| 23702 | 36984 | }, |
| 23703 | 36985 | .dst_temps = .{.mem}, |
| 23704 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 36986 | .clobbers = .{ .eflags = true }, |
| 23705 | 36987 | .each = .{ .once = &.{ |
| 23706 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23707 | | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 23708 | | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 23709 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23710 | | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 23711 | | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 23712 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23713 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 36988 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 36989 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 36990 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 36991 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 36992 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23714 | 36993 | } }, |
| 23715 | 36994 | }, .{ |
| 23716 | | .required_features = .{ .sse, null, null, null }, |
| 23717 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23718 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 36995 | .required_features = .{ .slow_incdec, null, null, null }, |
| 36996 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 36997 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23719 | 36998 | .patterns = &.{ |
| 23720 | | .{ .src = .{ .to_mem, .none } }, |
| 36999 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23721 | 37000 | }, |
| 23722 | | .call_frame = .{ .alignment = .@"16" }, |
| 23723 | 37001 | .extra_temps = .{ |
| 23724 | 37002 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23725 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 23726 | | .{ .type = .f32, .kind = .mem }, |
| 23727 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23728 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 37003 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 37004 | .unused, |
| 37005 | .unused, |
| 37006 | .unused, |
| 23729 | 37007 | .unused, |
| 23730 | 37008 | .unused, |
| 23731 | 37009 | .unused, |
| 23732 | 37010 | .unused, |
| 23733 | 37011 | }, |
| 23734 | 37012 | .dst_temps = .{.mem}, |
| 23735 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37013 | .clobbers = .{ .eflags = true }, |
| 23736 | 37014 | .each = .{ .once = &.{ |
| 23737 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23738 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23739 | | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 23740 | | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 23741 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23742 | | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 23743 | | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 23744 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 37015 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37016 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37017 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 37018 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23745 | 37019 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23746 | 37020 | } }, |
| 23747 | 37021 | }, .{ |
| 23748 | | .required_features = .{ .sse, null, null, null }, |
| 23749 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23750 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37022 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 37023 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23751 | 37024 | .patterns = &.{ |
| 23752 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 37025 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23753 | 37026 | }, |
| 23754 | | .call_frame = .{ .alignment = .@"16" }, |
| 23755 | 37027 | .extra_temps = .{ |
| 23756 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 23757 | | .unused, |
| 37028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 37029 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23758 | 37030 | .unused, |
| 23759 | 37031 | .unused, |
| 23760 | 37032 | .unused, |
| ... | ... | @@ -23763,23 +37035,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23763 | 37035 | .unused, |
| 23764 | 37036 | .unused, |
| 23765 | 37037 | }, |
| 23766 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 23767 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37038 | .dst_temps = .{.mem}, |
| 37039 | .clobbers = .{ .eflags = true }, |
| 23768 | 37040 | .each = .{ .once = &.{ |
| 23769 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 37041 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37042 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37043 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 37044 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 37045 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23770 | 37046 | } }, |
| 23771 | 37047 | }, .{ |
| 23772 | | .required_features = .{ .avx, null, null, null }, |
| 23773 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23774 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37048 | .required_features = .{ .slow_incdec, null, null, null }, |
| 37049 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37050 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23775 | 37051 | .patterns = &.{ |
| 23776 | | .{ .src = .{ .to_mem, .none } }, |
| 37052 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23777 | 37053 | }, |
| 23778 | | .call_frame = .{ .alignment = .@"16" }, |
| 23779 | 37054 | .extra_temps = .{ |
| 23780 | 37055 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23781 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23782 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 37056 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37057 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23783 | 37058 | .unused, |
| 23784 | 37059 | .unused, |
| 23785 | 37060 | .unused, |
| ... | ... | @@ -23788,28 +37063,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23788 | 37063 | .unused, |
| 23789 | 37064 | }, |
| 23790 | 37065 | .dst_temps = .{.mem}, |
| 23791 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37066 | .clobbers = .{ .eflags = true }, |
| 23792 | 37067 | .each = .{ .once = &.{ |
| 23793 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23794 | | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 23795 | | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 23796 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23797 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23798 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 37068 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37069 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 37070 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 37071 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 37072 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 37073 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23799 | 37074 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23800 | 37075 | } }, |
| 23801 | 37076 | }, .{ |
| 23802 | | .required_features = .{ .sse2, null, null, null }, |
| 23803 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23804 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37077 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37078 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23805 | 37079 | .patterns = &.{ |
| 23806 | | .{ .src = .{ .to_mem, .none } }, |
| 37080 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23807 | 37081 | }, |
| 23808 | | .call_frame = .{ .alignment = .@"16" }, |
| 23809 | 37082 | .extra_temps = .{ |
| 23810 | 37083 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23811 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23812 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 37084 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37085 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23813 | 37086 | .unused, |
| 23814 | 37087 | .unused, |
| 23815 | 37088 | .unused, |
| ... | ... | @@ -23818,152 +37091,111 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23818 | 37091 | .unused, |
| 23819 | 37092 | }, |
| 23820 | 37093 | .dst_temps = .{.mem}, |
| 23821 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37094 | .clobbers = .{ .eflags = true }, |
| 23822 | 37095 | .each = .{ .once = &.{ |
| 23823 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23824 | | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 23825 | | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 23826 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 23827 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23828 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23829 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37096 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37097 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 37098 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 37099 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 37100 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 37101 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 37102 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23830 | 37103 | } }, |
| 23831 | 37104 | }, .{ |
| 23832 | 37105 | .required_features = .{ .sse, null, null, null }, |
| 23833 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, |
| 23834 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37106 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 37107 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 23835 | 37108 | .patterns = &.{ |
| 23836 | | .{ .src = .{ .to_mem, .none } }, |
| 37109 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37110 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23837 | 37111 | }, |
| 23838 | | .call_frame = .{ .alignment = .@"16" }, |
| 23839 | | .extra_temps = .{ |
| 23840 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23841 | | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 23842 | | .{ .type = .f32, .kind = .mem }, |
| 23843 | | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 23844 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 23845 | | .unused, |
| 23846 | | .unused, |
| 23847 | | .unused, |
| 23848 | | .unused, |
| 23849 | | }, |
| 23850 | | .dst_temps = .{.mem}, |
| 23851 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23852 | | .each = .{ .once = &.{ |
| 23853 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23854 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23855 | | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 23856 | | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 23857 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 23858 | | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 23859 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23860 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23861 | | } }, |
| 37112 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37113 | .each = .{ .once = &.{} }, |
| 23862 | 37114 | }, .{ |
| 23863 | 37115 | .required_features = .{ .avx, null, null, null }, |
| 23864 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 23865 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 37116 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 37117 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, |
| 23866 | 37118 | .patterns = &.{ |
| 23867 | | .{ .src = .{ .mem, .none } }, |
| 37119 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37120 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23868 | 37121 | }, |
| 23869 | | .dst_temps = .{.{ .rc = .sse }}, |
| 23870 | | .each = .{ .once = &.{ |
| 23871 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 23872 | | .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .src0d, ._ }, |
| 23873 | | } }, |
| 37122 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37123 | .each = .{ .once = &.{} }, |
| 23874 | 37124 | }, .{ |
| 23875 | 37125 | .required_features = .{ .avx, null, null, null }, |
| 23876 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 23877 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 37126 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 37127 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 23878 | 37128 | .patterns = &.{ |
| 23879 | | .{ .src = .{ .to_sse, .none } }, |
| 37129 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23880 | 37130 | }, |
| 23881 | 37131 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23882 | 37132 | .each = .{ .once = &.{ |
| 23883 | | .{ ._, .v_sd, .cvtss2, .dst0x, .src0x, .src0d, ._ }, |
| 37133 | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, |
| 23884 | 37134 | } }, |
| 23885 | 37135 | }, .{ |
| 23886 | | .required_features = .{ .sse2, null, null, null }, |
| 23887 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 23888 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 37136 | .required_features = .{ .avx, null, null, null }, |
| 37137 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 37138 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, |
| 23889 | 37139 | .patterns = &.{ |
| 23890 | | .{ .src = .{ .mem, .none } }, |
| 23891 | | .{ .src = .{ .to_sse, .none } }, |
| 37140 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23892 | 37141 | }, |
| 23893 | | .dst_temps = .{.{ .rc = .sse }}, |
| 37142 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23894 | 37143 | .each = .{ .once = &.{ |
| 23895 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 23896 | | .{ ._, ._sd, .cvtss2, .dst0x, .src0d, ._, ._ }, |
| 37144 | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, |
| 23897 | 37145 | } }, |
| 23898 | 37146 | }, .{ |
| 23899 | | .required_features = .{ .x87, null, null, null }, |
| 23900 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 23901 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 37147 | .required_features = .{ .sse2, null, null, null }, |
| 37148 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 37149 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 23902 | 37150 | .patterns = &.{ |
| 23903 | | .{ .src = .{ .to_mem, .none } }, |
| 23904 | | }, |
| 23905 | | .extra_temps = .{ |
| 23906 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 23907 | | .unused, |
| 23908 | | .unused, |
| 23909 | | .unused, |
| 23910 | | .unused, |
| 23911 | | .unused, |
| 23912 | | .unused, |
| 23913 | | .unused, |
| 23914 | | .unused, |
| 37151 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23915 | 37152 | }, |
| 23916 | | .dst_temps = .{.mem}, |
| 37153 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23917 | 37154 | .each = .{ .once = &.{ |
| 23918 | | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, |
| 23919 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 37155 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 23920 | 37156 | } }, |
| 23921 | 37157 | }, .{ |
| 23922 | | .required_features = .{ .avx, null, null, null }, |
| 23923 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any }, |
| 23924 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 37158 | .required_features = .{ .sse4_1, null, null, null }, |
| 37159 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 37160 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, |
| 23925 | 37161 | .patterns = &.{ |
| 23926 | | .{ .src = .{ .mem, .none } }, |
| 23927 | | .{ .src = .{ .to_sse, .none } }, |
| 37162 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23928 | 37163 | }, |
| 23929 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 37164 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23930 | 37165 | .each = .{ .once = &.{ |
| 23931 | | .{ ._, .v_pd, .cvtps2, .dst0x, .src0q, ._, ._ }, |
| 37166 | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 23932 | 37167 | } }, |
| 23933 | 37168 | }, .{ |
| 23934 | | .required_features = .{ .sse2, null, null, null }, |
| 23935 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any }, |
| 23936 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 37169 | .required_features = .{ .avx2, null, null, null }, |
| 37170 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 37171 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 23937 | 37172 | .patterns = &.{ |
| 23938 | | .{ .src = .{ .mem, .none } }, |
| 23939 | | .{ .src = .{ .to_sse, .none } }, |
| 37173 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23940 | 37174 | }, |
| 23941 | 37175 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23942 | 37176 | .each = .{ .once = &.{ |
| 23943 | | .{ ._, ._pd, .cvtps2, .dst0x, .src0q, ._, ._ }, |
| 37177 | .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, |
| 23944 | 37178 | } }, |
| 23945 | 37179 | }, .{ |
| 23946 | | .required_features = .{ .avx, null, null, null }, |
| 23947 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| 23948 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 37180 | .required_features = .{ .avx2, null, null, null }, |
| 37181 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 37182 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 23949 | 37183 | .patterns = &.{ |
| 23950 | | .{ .src = .{ .mem, .none } }, |
| 23951 | | .{ .src = .{ .to_sse, .none } }, |
| 37184 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23952 | 37185 | }, |
| 23953 | 37186 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23954 | 37187 | .each = .{ .once = &.{ |
| 23955 | | .{ ._, .v_pd, .cvtps2, .dst0y, .src0x, ._, ._ }, |
| 37188 | .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, |
| 23956 | 37189 | } }, |
| 23957 | 37190 | }, .{ |
| 23958 | | .required_features = .{ .avx, null, null, null }, |
| 23959 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| 23960 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 37191 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 37192 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 23961 | 37193 | .patterns = &.{ |
| 23962 | | .{ .src = .{ .to_mem, .none } }, |
| 37194 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23963 | 37195 | }, |
| 23964 | 37196 | .extra_temps = .{ |
| 23965 | 37197 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23966 | | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 37198 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 23967 | 37199 | .unused, |
| 23968 | 37200 | .unused, |
| 23969 | 37201 | .unused, |
| ... | ... | @@ -23975,22 +37207,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23975 | 37207 | .dst_temps = .{.mem}, |
| 23976 | 37208 | .clobbers = .{ .eflags = true }, |
| 23977 | 37209 | .each = .{ .once = &.{ |
| 23978 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23979 | | .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23980 | | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 23981 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 37210 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37211 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37212 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 37213 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23982 | 37214 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23983 | 37215 | } }, |
| 23984 | 37216 | }, .{ |
| 23985 | | .required_features = .{ .sse2, null, null, null }, |
| 23986 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .dword } }, .any }, |
| 23987 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 37217 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 37218 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 23988 | 37219 | .patterns = &.{ |
| 23989 | | .{ .src = .{ .to_mem, .none } }, |
| 37220 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23990 | 37221 | }, |
| 23991 | 37222 | .extra_temps = .{ |
| 23992 | 37223 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23993 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 37224 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 23994 | 37225 | .unused, |
| 23995 | 37226 | .unused, |
| 23996 | 37227 | .unused, |
| ... | ... | @@ -24002,22 +37233,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24002 | 37233 | .dst_temps = .{.mem}, |
| 24003 | 37234 | .clobbers = .{ .eflags = true }, |
| 24004 | 37235 | .each = .{ .once = &.{ |
| 24005 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24006 | | .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24007 | | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24008 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 37236 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37237 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37238 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 37239 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 24009 | 37240 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24010 | 37241 | } }, |
| 24011 | 37242 | }, .{ |
| 24012 | | .required_features = .{ .x87, null, null, null }, |
| 24013 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24014 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 37243 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 37244 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 24015 | 37245 | .patterns = &.{ |
| 24016 | | .{ .src = .{ .to_mem, .none } }, |
| 37246 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24017 | 37247 | }, |
| 24018 | 37248 | .extra_temps = .{ |
| 24019 | 37249 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24020 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 37250 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 24021 | 37251 | .unused, |
| 24022 | 37252 | .unused, |
| 24023 | 37253 | .unused, |
| ... | ... | @@ -24029,46 +37259,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24029 | 37259 | .dst_temps = .{.mem}, |
| 24030 | 37260 | .clobbers = .{ .eflags = true }, |
| 24031 | 37261 | .each = .{ .once = &.{ |
| 24032 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24033 | | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 24034 | | .{ ._, .f_p, .st, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 24035 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 37262 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37263 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37264 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 37265 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 24036 | 37266 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24037 | 37267 | } }, |
| 24038 | 37268 | }, .{ |
| 24039 | | .required_features = .{ .x87, null, null, null }, |
| 24040 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24041 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 24042 | | .patterns = &.{ |
| 24043 | | .{ .src = .{ .to_mem, .none } }, |
| 24044 | | }, |
| 24045 | | .extra_temps = .{ |
| 24046 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 24047 | | .unused, |
| 24048 | | .unused, |
| 24049 | | .unused, |
| 24050 | | .unused, |
| 24051 | | .unused, |
| 24052 | | .unused, |
| 24053 | | .unused, |
| 24054 | | .unused, |
| 24055 | | }, |
| 24056 | | .dst_temps = .{.mem}, |
| 24057 | | .each = .{ .once = &.{ |
| 24058 | | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, |
| 24059 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 24060 | | } }, |
| 24061 | | }, .{ |
| 24062 | | .required_features = .{ .x87, null, null, null }, |
| 24063 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24064 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 37269 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37270 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 24065 | 37271 | .patterns = &.{ |
| 24066 | | .{ .src = .{ .to_mem, .none } }, |
| 37272 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24067 | 37273 | }, |
| 24068 | 37274 | .extra_temps = .{ |
| 24069 | 37275 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24070 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 24071 | | .unused, |
| 37276 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37277 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 24072 | 37278 | .unused, |
| 24073 | 37279 | .unused, |
| 24074 | 37280 | .unused, |
| ... | ... | @@ -24079,106 +37285,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24079 | 37285 | .dst_temps = .{.mem}, |
| 24080 | 37286 | .clobbers = .{ .eflags = true }, |
| 24081 | 37287 | .each = .{ .once = &.{ |
| 24082 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24083 | | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 24084 | | .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 24085 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 37288 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37289 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 37290 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 37291 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 37292 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 37293 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 24086 | 37294 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24087 | 37295 | } }, |
| 24088 | 37296 | }, .{ |
| 24089 | 37297 | .required_features = .{ .sse, null, null, null }, |
| 24090 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24091 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37298 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 37299 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 24092 | 37300 | .patterns = &.{ |
| 24093 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 24094 | | }, |
| 24095 | | .call_frame = .{ .alignment = .@"16" }, |
| 24096 | | .extra_temps = .{ |
| 24097 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 24098 | | .unused, |
| 24099 | | .unused, |
| 24100 | | .unused, |
| 24101 | | .unused, |
| 24102 | | .unused, |
| 24103 | | .unused, |
| 24104 | | .unused, |
| 24105 | | .unused, |
| 37301 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37302 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 24106 | 37303 | }, |
| 24107 | 37304 | .dst_temps = .{.{ .ref = .src0 }}, |
| 24108 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 24109 | | .each = .{ .once = &.{ |
| 24110 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 24111 | | } }, |
| 37305 | .each = .{ .once = &.{} }, |
| 24112 | 37306 | }, .{ |
| 24113 | 37307 | .required_features = .{ .avx, null, null, null }, |
| 24114 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24115 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37308 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 37309 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 24116 | 37310 | .patterns = &.{ |
| 24117 | | .{ .src = .{ .to_mem, .none } }, |
| 37311 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37312 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 24118 | 37313 | }, |
| 24119 | | .call_frame = .{ .alignment = .@"16" }, |
| 24120 | | .extra_temps = .{ |
| 24121 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24122 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 24123 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 24124 | | .unused, |
| 24125 | | .unused, |
| 24126 | | .unused, |
| 24127 | | .unused, |
| 24128 | | .unused, |
| 24129 | | .unused, |
| 37314 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37315 | .each = .{ .once = &.{} }, |
| 37316 | }, .{ |
| 37317 | .required_features = .{ .avx, null, null, null }, |
| 37318 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 37319 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, |
| 37320 | .patterns = &.{ |
| 37321 | .{ .src = .{ .mem, .none, .none } }, |
| 37322 | .{ .src = .{ .to_sse, .none, .none } }, |
| 24130 | 37323 | }, |
| 24131 | | .dst_temps = .{.mem}, |
| 24132 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37324 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24133 | 37325 | .each = .{ .once = &.{ |
| 24134 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24135 | | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24136 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 24137 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24138 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 24139 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37326 | .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ }, |
| 24140 | 37327 | } }, |
| 24141 | 37328 | }, .{ |
| 24142 | 37329 | .required_features = .{ .sse2, null, null, null }, |
| 24143 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24144 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37330 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 37331 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, |
| 24145 | 37332 | .patterns = &.{ |
| 24146 | | .{ .src = .{ .to_mem, .none } }, |
| 24147 | | }, |
| 24148 | | .call_frame = .{ .alignment = .@"16" }, |
| 24149 | | .extra_temps = .{ |
| 24150 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24151 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 24152 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 24153 | | .unused, |
| 24154 | | .unused, |
| 24155 | | .unused, |
| 24156 | | .unused, |
| 24157 | | .unused, |
| 24158 | | .unused, |
| 37333 | .{ .src = .{ .mem, .none, .none } }, |
| 37334 | .{ .src = .{ .to_sse, .none, .none } }, |
| 24159 | 37335 | }, |
| 24160 | | .dst_temps = .{.mem}, |
| 24161 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37336 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24162 | 37337 | .each = .{ .once = &.{ |
| 24163 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24164 | | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24165 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 24166 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24167 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 24168 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37338 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ }, |
| 24169 | 37339 | } }, |
| 24170 | 37340 | }, .{ |
| 24171 | | .required_features = .{ .sse, null, null, null }, |
| 24172 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, |
| 24173 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37341 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 37342 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24174 | 37343 | .patterns = &.{ |
| 24175 | | .{ .src = .{ .to_mem, .none } }, |
| 37344 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24176 | 37345 | }, |
| 24177 | | .call_frame = .{ .alignment = .@"16" }, |
| 24178 | 37346 | .extra_temps = .{ |
| 24179 | 37347 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24180 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 24181 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 37348 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37349 | .unused, |
| 24182 | 37350 | .unused, |
| 24183 | 37351 | .unused, |
| 24184 | 37352 | .unused, |
| ... | ... | @@ -24187,25 +37355,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24187 | 37355 | .unused, |
| 24188 | 37356 | }, |
| 24189 | 37357 | .dst_temps = .{.mem}, |
| 24190 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37358 | .clobbers = .{ .eflags = true }, |
| 24191 | 37359 | .each = .{ .once = &.{ |
| 24192 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24193 | | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24194 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 24195 | | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 37360 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37361 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37362 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 24196 | 37363 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 24197 | 37364 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24198 | 37365 | } }, |
| 24199 | 37366 | }, .{ |
| 24200 | | .required_features = .{ .x87, null, null, null }, |
| 24201 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 24202 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 37367 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 37368 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24203 | 37369 | .patterns = &.{ |
| 24204 | | .{ .src = .{ .to_mem, .none } }, |
| 37370 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24205 | 37371 | }, |
| 24206 | 37372 | .extra_temps = .{ |
| 24207 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 24208 | | .unused, |
| 37373 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 37374 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24209 | 37375 | .unused, |
| 24210 | 37376 | .unused, |
| 24211 | 37377 | .unused, |
| ... | ... | @@ -24215,20 +37381,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24215 | 37381 | .unused, |
| 24216 | 37382 | }, |
| 24217 | 37383 | .dst_temps = .{.mem}, |
| 37384 | .clobbers = .{ .eflags = true }, |
| 24218 | 37385 | .each = .{ .once = &.{ |
| 24219 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 24220 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 37386 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37387 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37388 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 37389 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 37390 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24221 | 37391 | } }, |
| 24222 | 37392 | }, .{ |
| 24223 | | .required_features = .{ .x87, null, null, null }, |
| 24224 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 24225 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 37393 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 37394 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24226 | 37395 | .patterns = &.{ |
| 24227 | | .{ .src = .{ .to_mem, .none } }, |
| 37396 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24228 | 37397 | }, |
| 24229 | 37398 | .extra_temps = .{ |
| 24230 | 37399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24231 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 37400 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24232 | 37401 | .unused, |
| 24233 | 37402 | .unused, |
| 24234 | 37403 | .unused, |
| ... | ... | @@ -24240,24 +37409,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24240 | 37409 | .dst_temps = .{.mem}, |
| 24241 | 37410 | .clobbers = .{ .eflags = true }, |
| 24242 | 37411 | .each = .{ .once = &.{ |
| 24243 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24244 | | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 24245 | | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 24246 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 37412 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37413 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 37414 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 37415 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 24247 | 37416 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24248 | 37417 | } }, |
| 24249 | 37418 | }, .{ |
| 24250 | | .required_features = .{ .sse, null, null, null }, |
| 24251 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 24252 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37419 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37420 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24253 | 37421 | .patterns = &.{ |
| 24254 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, |
| 37422 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24255 | 37423 | }, |
| 24256 | | .call_frame = .{ .alignment = .@"16" }, |
| 24257 | 37424 | .extra_temps = .{ |
| 24258 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 24259 | | .unused, |
| 24260 | | .unused, |
| 37425 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 37426 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37427 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24261 | 37428 | .unused, |
| 24262 | 37429 | .unused, |
| 24263 | 37430 | .unused, |
| ... | ... | @@ -24265,23 +37432,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24265 | 37432 | .unused, |
| 24266 | 37433 | .unused, |
| 24267 | 37434 | }, |
| 24268 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24269 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37435 | .dst_temps = .{.mem}, |
| 37436 | .clobbers = .{ .eflags = true }, |
| 24270 | 37437 | .each = .{ .once = &.{ |
| 24271 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 37438 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37439 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 37440 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 37441 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 37442 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 37443 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 37444 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24272 | 37445 | } }, |
| 37446 | }, .{ |
| 37447 | .required_features = .{ .sse, null, null, null }, |
| 37448 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 37449 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 37450 | .patterns = &.{ |
| 37451 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37452 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 37453 | }, |
| 37454 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37455 | .each = .{ .once = &.{} }, |
| 24273 | 37456 | }, .{ |
| 24274 | 37457 | .required_features = .{ .avx, null, null, null }, |
| 24275 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 24276 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37458 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 37459 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 24277 | 37460 | .patterns = &.{ |
| 24278 | | .{ .src = .{ .to_mem, .none } }, |
| 37461 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37462 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 37463 | }, |
| 37464 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37465 | .each = .{ .once = &.{} }, |
| 37466 | }, .{ |
| 37467 | .required_features = .{ .@"64bit", null, null, null }, |
| 37468 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37469 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 37470 | .patterns = &.{ |
| 37471 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24279 | 37472 | }, |
| 24280 | | .call_frame = .{ .alignment = .@"16" }, |
| 24281 | 37473 | .extra_temps = .{ |
| 24282 | 37474 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24283 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 24284 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 37475 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37476 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 24285 | 37477 | .unused, |
| 24286 | 37478 | .unused, |
| 24287 | 37479 | .unused, |
| ... | ... | @@ -24290,28 +37482,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24290 | 37482 | .unused, |
| 24291 | 37483 | }, |
| 24292 | 37484 | .dst_temps = .{.mem}, |
| 24293 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37485 | .clobbers = .{ .eflags = true }, |
| 24294 | 37486 | .each = .{ .once = &.{ |
| 24295 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24296 | | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24297 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 24298 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 37487 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 37488 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 37489 | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 37490 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 37491 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 24299 | 37492 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 24300 | 37493 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24301 | 37494 | } }, |
| 24302 | 37495 | }, .{ |
| 24303 | | .required_features = .{ .sse2, null, null, null }, |
| 24304 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 24305 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37496 | .required_features = .{ .sse, null, null, null }, |
| 37497 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 37498 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 24306 | 37499 | .patterns = &.{ |
| 24307 | | .{ .src = .{ .to_mem, .none } }, |
| 37500 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37501 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 37502 | }, |
| 37503 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37504 | .each = .{ .once = &.{} }, |
| 37505 | }, .{ |
| 37506 | .required_features = .{ .avx, null, null, null }, |
| 37507 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| 37508 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .xword } }}, |
| 37509 | .patterns = &.{ |
| 37510 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37511 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 37512 | }, |
| 37513 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37514 | .each = .{ .once = &.{} }, |
| 37515 | }, .{ |
| 37516 | .required_features = .{ .avx, null, null, null }, |
| 37517 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 37518 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .yword } }}, |
| 37519 | .patterns = &.{ |
| 37520 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 37521 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 37522 | }, |
| 37523 | .dst_temps = .{.{ .ref = .src0 }}, |
| 37524 | .each = .{ .once = &.{} }, |
| 37525 | }, .{ |
| 37526 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 37527 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37528 | .dst_constraints = .{.any_scalar_int}, |
| 37529 | .patterns = &.{ |
| 37530 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24308 | 37531 | }, |
| 24309 | | .call_frame = .{ .alignment = .@"16" }, |
| 24310 | 37532 | .extra_temps = .{ |
| 24311 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24312 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 24313 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 24314 | | .unused, |
| 37533 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37534 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 37535 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37536 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24315 | 37537 | .unused, |
| 24316 | 37538 | .unused, |
| 24317 | 37539 | .unused, |
| ... | ... | @@ -24319,28 +37541,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24319 | 37541 | .unused, |
| 24320 | 37542 | }, |
| 24321 | 37543 | .dst_temps = .{.mem}, |
| 24322 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37544 | .clobbers = .{ .eflags = true }, |
| 24323 | 37545 | .each = .{ .once = &.{ |
| 24324 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24325 | | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24326 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 24327 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24328 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 24329 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37546 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 37547 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 37548 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 37549 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 37550 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 37551 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 37552 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 37553 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 24330 | 37554 | } }, |
| 24331 | 37555 | }, .{ |
| 24332 | | .required_features = .{ .sse, null, null, null }, |
| 24333 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, |
| 24334 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37556 | .required_features = .{ .@"64bit", null, null, null }, |
| 37557 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 37558 | .dst_constraints = .{.any_scalar_int}, |
| 24335 | 37559 | .patterns = &.{ |
| 24336 | | .{ .src = .{ .to_mem, .none } }, |
| 37560 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24337 | 37561 | }, |
| 24338 | | .call_frame = .{ .alignment = .@"16" }, |
| 24339 | 37562 | .extra_temps = .{ |
| 24340 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24341 | | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 24342 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 24343 | | .unused, |
| 37563 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 37564 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 37565 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37566 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24344 | 37567 | .unused, |
| 24345 | 37568 | .unused, |
| 24346 | 37569 | .unused, |
| ... | ... | @@ -24348,80 +37571,75 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24348 | 37571 | .unused, |
| 24349 | 37572 | }, |
| 24350 | 37573 | .dst_temps = .{.mem}, |
| 24351 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37574 | .clobbers = .{ .eflags = true }, |
| 24352 | 37575 | .each = .{ .once = &.{ |
| 24353 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24354 | | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 24355 | | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24356 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 24357 | | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24358 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 24359 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37576 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 37577 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 37578 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 37579 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 37580 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 37581 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 37582 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 37583 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 24360 | 37584 | } }, |
| 24361 | | }, .{ |
| 24362 | | .required_features = .{ .avx, null, null, null }, |
| 24363 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 24364 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37585 | } } else comptime &.{ .{ |
| 37586 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 37587 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 24365 | 37588 | .patterns = &.{ |
| 24366 | | .{ .src = .{ .to_mem, .none } }, |
| 37589 | .{ .src = .{ .mem, .none, .none } }, |
| 37590 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24367 | 37591 | }, |
| 24368 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 24369 | | .extra_temps = .{ |
| 24370 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 24371 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 24372 | | .unused, |
| 24373 | | .unused, |
| 24374 | | .unused, |
| 24375 | | .unused, |
| 24376 | | .unused, |
| 24377 | | .unused, |
| 24378 | | .unused, |
| 37592 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 37593 | .each = .{ .once = &.{ |
| 37594 | .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ }, |
| 37595 | } }, |
| 37596 | }, .{ |
| 37597 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 37598 | .dst_constraints = .{.{ .int = .dword }}, |
| 37599 | .patterns = &.{ |
| 37600 | .{ .src = .{ .mem, .none, .none } }, |
| 37601 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24379 | 37602 | }, |
| 24380 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 24381 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37603 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24382 | 37604 | .each = .{ .once = &.{ |
| 24383 | | .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 24384 | | .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 24385 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 37605 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 24386 | 37606 | } }, |
| 24387 | 37607 | }, .{ |
| 24388 | | .required_features = .{ .sse2, null, null, null }, |
| 24389 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 24390 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37608 | .required_features = .{ .@"64bit", null, null, null }, |
| 37609 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 37610 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 24391 | 37611 | .patterns = &.{ |
| 24392 | | .{ .src = .{ .to_mem, .none } }, |
| 37612 | .{ .src = .{ .mem, .none, .none } }, |
| 37613 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24393 | 37614 | }, |
| 24394 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 24395 | | .extra_temps = .{ |
| 24396 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 24397 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 24398 | | .unused, |
| 24399 | | .unused, |
| 24400 | | .unused, |
| 24401 | | .unused, |
| 24402 | | .unused, |
| 24403 | | .unused, |
| 24404 | | .unused, |
| 37615 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 37616 | .each = .{ .once = &.{ |
| 37617 | .{ ._, ._, .movsx, .dst0q, .src0b, ._, ._ }, |
| 37618 | } }, |
| 37619 | }, .{ |
| 37620 | .required_features = .{ .@"64bit", null, null, null }, |
| 37621 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 37622 | .dst_constraints = .{.{ .int = .qword }}, |
| 37623 | .patterns = &.{ |
| 37624 | .{ .src = .{ .mem, .none, .none } }, |
| 37625 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24405 | 37626 | }, |
| 24406 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 24407 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37627 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24408 | 37628 | .each = .{ .once = &.{ |
| 24409 | | .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, |
| 24410 | | .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 24411 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 37629 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 24412 | 37630 | } }, |
| 24413 | 37631 | }, .{ |
| 24414 | | .required_features = .{ .sse, null, null, null }, |
| 24415 | | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 24416 | | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37632 | .required_features = .{ .@"64bit", null, null, null }, |
| 37633 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 37634 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24417 | 37635 | .patterns = &.{ |
| 24418 | | .{ .src = .{ .to_mem, .none } }, |
| 37636 | .{ .src = .{ .mem, .none, .none } }, |
| 37637 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24419 | 37638 | }, |
| 24420 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 24421 | 37639 | .extra_temps = .{ |
| 24422 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 24423 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 24424 | | .unused, |
| 37640 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 37641 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37642 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24425 | 37643 | .unused, |
| 24426 | 37644 | .unused, |
| 24427 | 37645 | .unused, |
| ... | ... | @@ -24429,26 +37647,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24429 | 37647 | .unused, |
| 24430 | 37648 | .unused, |
| 24431 | 37649 | }, |
| 24432 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 24433 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37650 | .dst_temps = .{.mem}, |
| 37651 | .clobbers = .{ .eflags = true }, |
| 24434 | 37652 | .each = .{ .once = &.{ |
| 24435 | | .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, |
| 24436 | | .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ }, |
| 24437 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 37653 | .{ ._, ._, .movsx, .tmp0q, .src0b, ._, ._ }, |
| 37654 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37655 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 37656 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 37657 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 37658 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24438 | 37659 | } }, |
| 24439 | 37660 | }, .{ |
| 24440 | | .required_features = .{ .avx, null, null, null }, |
| 24441 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 24442 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37661 | .required_features = .{ .@"64bit", null, null, null }, |
| 37662 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 37663 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24443 | 37664 | .patterns = &.{ |
| 24444 | | .{ .src = .{ .to_mem, .none } }, |
| 37665 | .{ .src = .{ .mem, .none, .none } }, |
| 37666 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24445 | 37667 | }, |
| 24446 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 24447 | 37668 | .extra_temps = .{ |
| 24448 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24449 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 24450 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 24451 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 37669 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 37670 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37671 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 37672 | .unused, |
| 24452 | 37673 | .unused, |
| 24453 | 37674 | .unused, |
| 24454 | 37675 | .unused, |
| ... | ... | @@ -24456,29 +37677,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24456 | 37677 | .unused, |
| 24457 | 37678 | }, |
| 24458 | 37679 | .dst_temps = .{.mem}, |
| 24459 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37680 | .clobbers = .{ .eflags = true }, |
| 24460 | 37681 | .each = .{ .once = &.{ |
| 24461 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24462 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24463 | | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 24464 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 24465 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24466 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 24467 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37682 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 37683 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37684 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 37685 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 37686 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 37687 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24468 | 37688 | } }, |
| 24469 | 37689 | }, .{ |
| 24470 | | .required_features = .{ .sse2, null, null, null }, |
| 24471 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 24472 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37690 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 37691 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 24473 | 37692 | .patterns = &.{ |
| 24474 | | .{ .src = .{ .to_mem, .none } }, |
| 37693 | .{ .src = .{ .mem, .none, .none } }, |
| 37694 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24475 | 37695 | }, |
| 24476 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 24477 | 37696 | .extra_temps = .{ |
| 24478 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24479 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 24480 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 24481 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 37697 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 37698 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 37699 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 37700 | .unused, |
| 24482 | 37701 | .unused, |
| 24483 | 37702 | .unused, |
| 24484 | 37703 | .unused, |
| ... | ... | @@ -24486,29 +37705,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24486 | 37705 | .unused, |
| 24487 | 37706 | }, |
| 24488 | 37707 | .dst_temps = .{.mem}, |
| 24489 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37708 | .clobbers = .{ .eflags = true }, |
| 24490 | 37709 | .each = .{ .once = &.{ |
| 24491 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24492 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24493 | | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 24494 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 24495 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24496 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 24497 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37710 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 37711 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37712 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 37713 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 37714 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 37715 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24498 | 37716 | } }, |
| 24499 | 37717 | }, .{ |
| 24500 | | .required_features = .{ .sse, null, null, null }, |
| 24501 | | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, |
| 24502 | | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 37718 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 37719 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 24503 | 37720 | .patterns = &.{ |
| 24504 | | .{ .src = .{ .to_mem, .none } }, |
| 37721 | .{ .src = .{ .mem, .none, .none } }, |
| 37722 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24505 | 37723 | }, |
| 24506 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 24507 | 37724 | .extra_temps = .{ |
| 24508 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24509 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 24510 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 24511 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 37725 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 37726 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 37727 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 37728 | .unused, |
| 24512 | 37729 | .unused, |
| 24513 | 37730 | .unused, |
| 24514 | 37731 | .unused, |
| ... | ... | @@ -24516,95 +37733,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24516 | 37733 | .unused, |
| 24517 | 37734 | }, |
| 24518 | 37735 | .dst_temps = .{.mem}, |
| 24519 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 37736 | .clobbers = .{ .eflags = true }, |
| 24520 | 37737 | .each = .{ .once = &.{ |
| 24521 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 24522 | | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 24523 | | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 24524 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 24525 | | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 24526 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 24527 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37738 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 37739 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37740 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 37741 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 37742 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 37743 | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 24528 | 37744 | } }, |
| 24529 | | } }) catch |err| switch (err) { |
| 24530 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 24531 | | @tagName(air_tag), |
| 24532 | | ty_op.ty.toType().fmt(pt), |
| 24533 | | cg.typeOf(ty_op.operand).fmt(pt), |
| 24534 | | ops[0].tracking(cg), |
| 24535 | | }), |
| 24536 | | else => |e| return e, |
| 24537 | | }; |
| 24538 | | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 24539 | | }, |
| 24540 | | .intcast => |air_tag| if (use_old) try cg.airIntCast(inst) else { |
| 24541 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 24542 | | const dst_ty = ty_op.ty.toType(); |
| 24543 | | const src_ty = cg.typeOf(ty_op.operand); |
| 24544 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 24545 | | var res: [1]Temp = undefined; |
| 24546 | | cg.select(&res, &.{dst_ty}, &ops, if (dst_ty.scalarType(zcu).abiSize(zcu) <= src_ty.scalarType(zcu).abiSize(zcu)) comptime &.{ .{ |
| 24547 | | .dst_constraints = .{.{ .int = .dword }}, |
| 24548 | | .patterns = &.{ |
| 24549 | | .{ .src = .{ .mut_mem, .none } }, |
| 24550 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 24551 | | }, |
| 24552 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24553 | | .each = .{ .once = &.{} }, |
| 24554 | | }, .{ |
| 24555 | | .required_features = .{ .@"64bit", null, null, null }, |
| 24556 | | .dst_constraints = .{.{ .int = .qword }}, |
| 24557 | | .patterns = &.{ |
| 24558 | | .{ .src = .{ .mut_mem, .none } }, |
| 24559 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 24560 | | }, |
| 24561 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24562 | | .each = .{ .once = &.{} }, |
| 24563 | 37745 | }, .{ |
| 24564 | | .dst_constraints = .{.{ .int = .byte }}, |
| 37746 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 37747 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 24565 | 37748 | .patterns = &.{ |
| 24566 | | .{ .src = .{ .to_mem, .none } }, |
| 37749 | .{ .src = .{ .mem, .none, .none } }, |
| 37750 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24567 | 37751 | }, |
| 24568 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 37752 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24569 | 37753 | .each = .{ .once = &.{ |
| 24570 | | .{ ._, ._, .mov, .dst0b, .mem(.src0b), ._, ._ }, |
| 37754 | .{ ._, ._, .movsx, .dst0d, .src0w, ._, ._ }, |
| 24571 | 37755 | } }, |
| 24572 | 37756 | }, .{ |
| 24573 | | .dst_constraints = .{.{ .int = .word }}, |
| 37757 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 37758 | .dst_constraints = .{.{ .int = .dword }}, |
| 24574 | 37759 | .patterns = &.{ |
| 24575 | | .{ .src = .{ .to_mem, .none } }, |
| 37760 | .{ .src = .{ .mem, .none, .none } }, |
| 37761 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24576 | 37762 | }, |
| 24577 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 37763 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24578 | 37764 | .each = .{ .once = &.{ |
| 24579 | | .{ ._, ._, .mov, .dst0w, .mem(.src0w), ._, ._ }, |
| 37765 | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, |
| 24580 | 37766 | } }, |
| 24581 | 37767 | }, .{ |
| 24582 | | .dst_constraints = .{.{ .int = .dword }}, |
| 37768 | .required_features = .{ .@"64bit", null, null, null }, |
| 37769 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 37770 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 24583 | 37771 | .patterns = &.{ |
| 24584 | | .{ .src = .{ .to_mem, .none } }, |
| 37772 | .{ .src = .{ .mem, .none, .none } }, |
| 37773 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24585 | 37774 | }, |
| 24586 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 37775 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24587 | 37776 | .each = .{ .once = &.{ |
| 24588 | | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 37777 | .{ ._, ._, .movsx, .dst0q, .src0w, ._, ._ }, |
| 24589 | 37778 | } }, |
| 24590 | 37779 | }, .{ |
| 24591 | 37780 | .required_features = .{ .@"64bit", null, null, null }, |
| 37781 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 24592 | 37782 | .dst_constraints = .{.{ .int = .qword }}, |
| 24593 | 37783 | .patterns = &.{ |
| 24594 | | .{ .src = .{ .to_mem, .none } }, |
| 37784 | .{ .src = .{ .mem, .none, .none } }, |
| 37785 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24595 | 37786 | }, |
| 24596 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 37787 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24597 | 37788 | .each = .{ .once = &.{ |
| 24598 | | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 37789 | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, |
| 24599 | 37790 | } }, |
| 24600 | 37791 | }, .{ |
| 24601 | 37792 | .required_features = .{ .@"64bit", null, null, null }, |
| 24602 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 37793 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 37794 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24603 | 37795 | .patterns = &.{ |
| 24604 | | .{ .src = .{ .to_mem, .none } }, |
| 37796 | .{ .src = .{ .mem, .none, .none } }, |
| 37797 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24605 | 37798 | }, |
| 24606 | 37799 | .extra_temps = .{ |
| 24607 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 37800 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24608 | 37801 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24609 | 37802 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24610 | 37803 | .unused, |
| ... | ... | @@ -24615,109 +37808,55 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24615 | 37808 | .unused, |
| 24616 | 37809 | }, |
| 24617 | 37810 | .dst_temps = .{.mem}, |
| 37811 | .clobbers = .{ .eflags = true }, |
| 24618 | 37812 | .each = .{ .once = &.{ |
| 24619 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 37813 | .{ ._, ._, .movsx, .tmp0q, .src0w, ._, ._ }, |
| 24620 | 37814 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24621 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| 24622 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 24623 | | } }, |
| 24624 | | }, .{ |
| 24625 | | .required_features = .{ .sse, null, null, null }, |
| 24626 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 24627 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, |
| 24628 | | .patterns = &.{ |
| 24629 | | .{ .src = .{ .mut_mem, .none } }, |
| 24630 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 24631 | | }, |
| 24632 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24633 | | .each = .{ .once = &.{} }, |
| 24634 | | }, .{ |
| 24635 | | .required_features = .{ .avx, null, null, null }, |
| 24636 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 24637 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .byte } }}, |
| 24638 | | .patterns = &.{ |
| 24639 | | .{ .src = .{ .mut_mem, .none } }, |
| 24640 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 24641 | | }, |
| 24642 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24643 | | .each = .{ .once = &.{} }, |
| 24644 | | }, .{ |
| 24645 | | .required_features = .{ .avx, null, null, null }, |
| 24646 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 24647 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 24648 | | .patterns = &.{ |
| 24649 | | .{ .src = .{ .to_sse, .none } }, |
| 24650 | | }, |
| 24651 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24652 | | .each = .{ .once = &.{ |
| 24653 | | .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ }, |
| 24654 | | } }, |
| 24655 | | }, .{ |
| 24656 | | .required_features = .{ .avx, null, null, null }, |
| 24657 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 24658 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 24659 | | .patterns = &.{ |
| 24660 | | .{ .src = .{ .to_sse, .none } }, |
| 24661 | | }, |
| 24662 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24663 | | .each = .{ .once = &.{ |
| 24664 | | .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ }, |
| 24665 | | } }, |
| 24666 | | }, .{ |
| 24667 | | .required_features = .{ .sse2, null, null, null }, |
| 24668 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 24669 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 24670 | | .patterns = &.{ |
| 24671 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 24672 | | }, |
| 24673 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24674 | | .each = .{ .once = &.{ |
| 24675 | | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, |
| 24676 | | } }, |
| 24677 | | }, .{ |
| 24678 | | .required_features = .{ .sse2, null, null, null }, |
| 24679 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 24680 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 24681 | | .patterns = &.{ |
| 24682 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 24683 | | }, |
| 24684 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24685 | | .each = .{ .once = &.{ |
| 24686 | | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, |
| 37815 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 37816 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 37817 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 37818 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24687 | 37819 | } }, |
| 24688 | 37820 | }, .{ |
| 24689 | | .required_features = .{ .avx2, null, null, null }, |
| 24690 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any }, |
| 24691 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 37821 | .required_features = .{ .@"64bit", null, null, null }, |
| 37822 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 37823 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24692 | 37824 | .patterns = &.{ |
| 24693 | | .{ .src = .{ .to_sse, .none } }, |
| 37825 | .{ .src = .{ .mem, .none, .none } }, |
| 37826 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24694 | 37827 | }, |
| 24695 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24696 | | .each = .{ .once = &.{ |
| 24697 | | .{ ._, .vp_b, .ackssw, .dst0y, .src0y, .dst0y, ._ }, |
| 24698 | | } }, |
| 24699 | | }, .{ |
| 24700 | | .required_features = .{ .avx2, null, null, null }, |
| 24701 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any }, |
| 24702 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, |
| 24703 | | .patterns = &.{ |
| 24704 | | .{ .src = .{ .to_sse, .none } }, |
| 37828 | .extra_temps = .{ |
| 37829 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 37830 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37831 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 37832 | .unused, |
| 37833 | .unused, |
| 37834 | .unused, |
| 37835 | .unused, |
| 37836 | .unused, |
| 37837 | .unused, |
| 24705 | 37838 | }, |
| 24706 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 37839 | .dst_temps = .{.mem}, |
| 37840 | .clobbers = .{ .eflags = true }, |
| 24707 | 37841 | .each = .{ .once = &.{ |
| 24708 | | .{ ._, .vp_b, .ackusw, .dst0y, .src0y, .dst0y, ._ }, |
| 37842 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 37843 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37844 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 37845 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 37846 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 37847 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24709 | 37848 | } }, |
| 24710 | 37849 | }, .{ |
| 24711 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 24712 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 24713 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 37850 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 37851 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 24714 | 37852 | .patterns = &.{ |
| 24715 | | .{ .src = .{ .to_mem, .none } }, |
| 37853 | .{ .src = .{ .mem, .none, .none } }, |
| 37854 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24716 | 37855 | }, |
| 24717 | 37856 | .extra_temps = .{ |
| 24718 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24719 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24720 | | .unused, |
| 37857 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 37858 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 37859 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24721 | 37860 | .unused, |
| 24722 | 37861 | .unused, |
| 24723 | 37862 | .unused, |
| ... | ... | @@ -24728,22 +37867,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24728 | 37867 | .dst_temps = .{.mem}, |
| 24729 | 37868 | .clobbers = .{ .eflags = true }, |
| 24730 | 37869 | .each = .{ .once = &.{ |
| 24731 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24732 | | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24733 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 24734 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 24735 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 37870 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 37871 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37872 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 37873 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 37874 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 37875 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24736 | 37876 | } }, |
| 24737 | 37877 | }, .{ |
| 24738 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 24739 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 37878 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 37879 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 24740 | 37880 | .patterns = &.{ |
| 24741 | | .{ .src = .{ .to_mem, .none } }, |
| 37881 | .{ .src = .{ .mem, .none, .none } }, |
| 37882 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24742 | 37883 | }, |
| 24743 | 37884 | .extra_temps = .{ |
| 24744 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24745 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24746 | | .unused, |
| 37885 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 37886 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 37887 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24747 | 37888 | .unused, |
| 24748 | 37889 | .unused, |
| 24749 | 37890 | .unused, |
| ... | ... | @@ -24754,95 +37895,106 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24754 | 37895 | .dst_temps = .{.mem}, |
| 24755 | 37896 | .clobbers = .{ .eflags = true }, |
| 24756 | 37897 | .each = .{ .once = &.{ |
| 24757 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24758 | | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24759 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 24760 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 24761 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 37898 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 37899 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37900 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 37901 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 37902 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 37903 | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 24762 | 37904 | } }, |
| 24763 | 37905 | }, .{ |
| 24764 | | .required_features = .{ .avx, null, null, null }, |
| 24765 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 24766 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, |
| 37906 | .required_features = .{ .@"64bit", null, null, null }, |
| 37907 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 37908 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 24767 | 37909 | .patterns = &.{ |
| 24768 | | .{ .src = .{ .to_sse, .none } }, |
| 37910 | .{ .src = .{ .mem, .none, .none } }, |
| 37911 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24769 | 37912 | }, |
| 24770 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 37913 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24771 | 37914 | .each = .{ .once = &.{ |
| 24772 | | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, |
| 24773 | | .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ }, |
| 37915 | .{ ._, ._d, .movsx, .dst0q, .src0d, ._, ._ }, |
| 24774 | 37916 | } }, |
| 24775 | 37917 | }, .{ |
| 24776 | | .required_features = .{ .avx, null, null, null }, |
| 24777 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 24778 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 37918 | .required_features = .{ .@"64bit", null, null, null }, |
| 37919 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 37920 | .dst_constraints = .{.{ .int = .qword }}, |
| 24779 | 37921 | .patterns = &.{ |
| 24780 | | .{ .src = .{ .to_sse, .none } }, |
| 37922 | .{ .src = .{ .mem, .none, .none } }, |
| 37923 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24781 | 37924 | }, |
| 24782 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 37925 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24783 | 37926 | .each = .{ .once = &.{ |
| 24784 | | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, |
| 24785 | | .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ }, |
| 37927 | .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ }, |
| 24786 | 37928 | } }, |
| 24787 | 37929 | }, .{ |
| 24788 | | .required_features = .{ .sse2, null, null, null }, |
| 24789 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 24790 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, |
| 37930 | .required_features = .{ .@"64bit", null, null, null }, |
| 37931 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 37932 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24791 | 37933 | .patterns = &.{ |
| 24792 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 37934 | .{ .src = .{ .mem, .none, .none } }, |
| 37935 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24793 | 37936 | }, |
| 24794 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 24795 | | .each = .{ .once = &.{ |
| 24796 | | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 24797 | | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, |
| 24798 | | } }, |
| 24799 | | }, .{ |
| 24800 | | .required_features = .{ .sse4_1, null, null, null }, |
| 24801 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 24802 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 24803 | | .patterns = &.{ |
| 24804 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 37937 | .extra_temps = .{ |
| 37938 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 37939 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37940 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 37941 | .unused, |
| 37942 | .unused, |
| 37943 | .unused, |
| 37944 | .unused, |
| 37945 | .unused, |
| 37946 | .unused, |
| 24805 | 37947 | }, |
| 24806 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 37948 | .dst_temps = .{.mem}, |
| 37949 | .clobbers = .{ .eflags = true }, |
| 24807 | 37950 | .each = .{ .once = &.{ |
| 24808 | | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 24809 | | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, |
| 37951 | .{ ._, ._d, .movsx, .tmp0q, .src0d, ._, ._ }, |
| 37952 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37953 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 37954 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 37955 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 37956 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24810 | 37957 | } }, |
| 24811 | 37958 | }, .{ |
| 24812 | | .required_features = .{ .avx2, null, null, null }, |
| 24813 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 24814 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 37959 | .required_features = .{ .@"64bit", null, null, null }, |
| 37960 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 37961 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24815 | 37962 | .patterns = &.{ |
| 24816 | | .{ .src = .{ .to_sse, .none } }, |
| 37963 | .{ .src = .{ .mem, .none, .none } }, |
| 37964 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24817 | 37965 | }, |
| 24818 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24819 | | .each = .{ .once = &.{ |
| 24820 | | .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, |
| 24821 | | .{ ._, .vp_b, .ackssw, .dst0y, .dst0y, .dst0y, ._ }, |
| 24822 | | } }, |
| 24823 | | }, .{ |
| 24824 | | .required_features = .{ .avx2, null, null, null }, |
| 24825 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 24826 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 24827 | | .patterns = &.{ |
| 24828 | | .{ .src = .{ .to_sse, .none } }, |
| 37966 | .extra_temps = .{ |
| 37967 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 37968 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 37969 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 37970 | .unused, |
| 37971 | .unused, |
| 37972 | .unused, |
| 37973 | .unused, |
| 37974 | .unused, |
| 37975 | .unused, |
| 24829 | 37976 | }, |
| 24830 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 37977 | .dst_temps = .{.mem}, |
| 37978 | .clobbers = .{ .eflags = true }, |
| 24831 | 37979 | .each = .{ .once = &.{ |
| 24832 | | .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, |
| 24833 | | .{ ._, .vp_b, .ackusw, .dst0y, .dst0y, .dst0y, ._ }, |
| 37980 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 37981 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 37982 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 37983 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 37984 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 37985 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24834 | 37986 | } }, |
| 24835 | 37987 | }, .{ |
| 24836 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 24837 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 24838 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 37988 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 37989 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 24839 | 37990 | .patterns = &.{ |
| 24840 | | .{ .src = .{ .to_mem, .none } }, |
| 37991 | .{ .src = .{ .mem, .none, .none } }, |
| 37992 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24841 | 37993 | }, |
| 24842 | 37994 | .extra_temps = .{ |
| 24843 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24844 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24845 | | .unused, |
| 37995 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 37996 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 37997 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24846 | 37998 | .unused, |
| 24847 | 37999 | .unused, |
| 24848 | 38000 | .unused, |
| ... | ... | @@ -24853,22 +38005,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24853 | 38005 | .dst_temps = .{.mem}, |
| 24854 | 38006 | .clobbers = .{ .eflags = true }, |
| 24855 | 38007 | .each = .{ .once = &.{ |
| 24856 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24857 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24858 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 24859 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 24860 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 38008 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 38009 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 38010 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 38011 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 38012 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 38013 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24861 | 38014 | } }, |
| 24862 | 38015 | }, .{ |
| 24863 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 24864 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 38016 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 38017 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 24865 | 38018 | .patterns = &.{ |
| 24866 | | .{ .src = .{ .to_mem, .none } }, |
| 38019 | .{ .src = .{ .mem, .none, .none } }, |
| 38020 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24867 | 38021 | }, |
| 24868 | 38022 | .extra_temps = .{ |
| 24869 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24870 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24871 | | .unused, |
| 38023 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 38024 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 38025 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24872 | 38026 | .unused, |
| 24873 | 38027 | .unused, |
| 24874 | 38028 | .unused, |
| ... | ... | @@ -24879,23 +38033,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24879 | 38033 | .dst_temps = .{.mem}, |
| 24880 | 38034 | .clobbers = .{ .eflags = true }, |
| 24881 | 38035 | .each = .{ .once = &.{ |
| 24882 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24883 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24884 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 24885 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 24886 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 38036 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 38037 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 38038 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 38039 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 38040 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 38041 | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 24887 | 38042 | } }, |
| 24888 | 38043 | }, .{ |
| 24889 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 24890 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 24891 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 38044 | .required_features = .{ .@"64bit", null, null, null }, |
| 38045 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 38046 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24892 | 38047 | .patterns = &.{ |
| 24893 | | .{ .src = .{ .to_mem, .none } }, |
| 38048 | .{ .src = .{ .mem, .none, .none } }, |
| 38049 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24894 | 38050 | }, |
| 24895 | 38051 | .extra_temps = .{ |
| 24896 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24897 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24898 | | .unused, |
| 38052 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 38053 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 38054 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24899 | 38055 | .unused, |
| 24900 | 38056 | .unused, |
| 24901 | 38057 | .unused, |
| ... | ... | @@ -24906,22 +38062,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24906 | 38062 | .dst_temps = .{.mem}, |
| 24907 | 38063 | .clobbers = .{ .eflags = true }, |
| 24908 | 38064 | .each = .{ .once = &.{ |
| 24909 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24910 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24911 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 24912 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 24913 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 38065 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| 38066 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 38067 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 38068 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 38069 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 38070 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24914 | 38071 | } }, |
| 24915 | 38072 | }, .{ |
| 24916 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 24917 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 38073 | .required_features = .{ .@"64bit", null, null, null }, |
| 38074 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 38075 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24918 | 38076 | .patterns = &.{ |
| 24919 | | .{ .src = .{ .to_mem, .none } }, |
| 38077 | .{ .src = .{ .mem, .none, .none } }, |
| 38078 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24920 | 38079 | }, |
| 24921 | 38080 | .extra_temps = .{ |
| 24922 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24923 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24924 | | .unused, |
| 38081 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 38082 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 38083 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24925 | 38084 | .unused, |
| 24926 | 38085 | .unused, |
| 24927 | 38086 | .unused, |
| ... | ... | @@ -24932,24 +38091,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24932 | 38091 | .dst_temps = .{.mem}, |
| 24933 | 38092 | .clobbers = .{ .eflags = true }, |
| 24934 | 38093 | .each = .{ .once = &.{ |
| 24935 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24936 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24937 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 24938 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 24939 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 38094 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| 38095 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 38096 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 38097 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 38098 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 38099 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24940 | 38100 | } }, |
| 24941 | 38101 | }, .{ |
| 24942 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 24943 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 24944 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 38102 | .required_features = .{ .@"64bit", null, null, null }, |
| 38103 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 38104 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24945 | 38105 | .patterns = &.{ |
| 24946 | | .{ .src = .{ .to_mem, .none } }, |
| 38106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24947 | 38107 | }, |
| 24948 | 38108 | .extra_temps = .{ |
| 24949 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24950 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24951 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24952 | | .unused, |
| 38109 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 38110 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 38111 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38112 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24953 | 38113 | .unused, |
| 24954 | 38114 | .unused, |
| 24955 | 38115 | .unused, |
| ... | ... | @@ -24959,25 +38119,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24959 | 38119 | .dst_temps = .{.mem}, |
| 24960 | 38120 | .clobbers = .{ .eflags = true }, |
| 24961 | 38121 | .each = .{ .once = &.{ |
| 24962 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24963 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 24964 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 24965 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 24966 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 24967 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 24968 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 38122 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 38123 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 38124 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 38125 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 38126 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 38127 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 38128 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 38129 | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, |
| 38130 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24969 | 38131 | } }, |
| 24970 | 38132 | }, .{ |
| 24971 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 24972 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 38133 | .required_features = .{ .@"64bit", null, null, null }, |
| 38134 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 38135 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24973 | 38136 | .patterns = &.{ |
| 24974 | | .{ .src = .{ .to_mem, .none } }, |
| 38137 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24975 | 38138 | }, |
| 24976 | 38139 | .extra_temps = .{ |
| 24977 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24978 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24979 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 24980 | | .unused, |
| 38140 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 38141 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 38142 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38143 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 24981 | 38144 | .unused, |
| 24982 | 38145 | .unused, |
| 24983 | 38146 | .unused, |
| ... | ... | @@ -24987,135 +38150,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24987 | 38150 | .dst_temps = .{.mem}, |
| 24988 | 38151 | .clobbers = .{ .eflags = true }, |
| 24989 | 38152 | .each = .{ .once = &.{ |
| 24990 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24991 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 24992 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 24993 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 24994 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 24995 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 24996 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 38153 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 38154 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 38155 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 38156 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 38157 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 38158 | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, |
| 38159 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24997 | 38160 | } }, |
| 24998 | | }, .{ |
| 24999 | | .required_features = .{ .sse, null, null, null }, |
| 25000 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 25001 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25002 | | .patterns = &.{ |
| 25003 | | .{ .src = .{ .mut_mem, .none } }, |
| 25004 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25005 | | }, |
| 25006 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25007 | | .each = .{ .once = &.{} }, |
| 25008 | | }, .{ |
| 25009 | | .required_features = .{ .avx, null, null, null }, |
| 25010 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any }, |
| 25011 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, |
| 25012 | | .patterns = &.{ |
| 25013 | | .{ .src = .{ .mut_mem, .none } }, |
| 25014 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25015 | | }, |
| 25016 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25017 | | .each = .{ .once = &.{} }, |
| 25018 | 38161 | }, .{ |
| 25019 | 38162 | .required_features = .{ .avx, null, null, null }, |
| 25020 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 25021 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 38163 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38164 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25022 | 38165 | .patterns = &.{ |
| 25023 | | .{ .src = .{ .to_sse, .none } }, |
| 38166 | .{ .src = .{ .mem, .none, .none } }, |
| 38167 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25024 | 38168 | }, |
| 25025 | 38169 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25026 | 38170 | .each = .{ .once = &.{ |
| 25027 | | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, |
| 38171 | .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ }, |
| 25028 | 38172 | } }, |
| 25029 | 38173 | }, .{ |
| 25030 | 38174 | .required_features = .{ .avx, null, null, null }, |
| 25031 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 25032 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, |
| 38175 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38176 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25033 | 38177 | .patterns = &.{ |
| 25034 | | .{ .src = .{ .to_sse, .none } }, |
| 38178 | .{ .src = .{ .mem, .none, .none } }, |
| 38179 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25035 | 38180 | }, |
| 25036 | 38181 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25037 | 38182 | .each = .{ .once = &.{ |
| 25038 | | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, |
| 25039 | | } }, |
| 25040 | | }, .{ |
| 25041 | | .required_features = .{ .sse2, null, null, null }, |
| 25042 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 25043 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 25044 | | .patterns = &.{ |
| 25045 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25046 | | }, |
| 25047 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25048 | | .each = .{ .once = &.{ |
| 25049 | | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 38183 | .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ }, |
| 25050 | 38184 | } }, |
| 25051 | 38185 | }, .{ |
| 25052 | 38186 | .required_features = .{ .sse4_1, null, null, null }, |
| 25053 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 25054 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, |
| 25055 | | .patterns = &.{ |
| 25056 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25057 | | }, |
| 25058 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25059 | | .each = .{ .once = &.{ |
| 25060 | | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 25061 | | } }, |
| 25062 | | }, .{ |
| 25063 | | .required_features = .{ .avx2, null, null, null }, |
| 25064 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 38187 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25065 | 38188 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25066 | 38189 | .patterns = &.{ |
| 25067 | | .{ .src = .{ .to_sse, .none } }, |
| 38190 | .{ .src = .{ .mem, .none, .none } }, |
| 38191 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25068 | 38192 | }, |
| 25069 | 38193 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25070 | 38194 | .each = .{ .once = &.{ |
| 25071 | | .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, |
| 38195 | .{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ }, |
| 25072 | 38196 | } }, |
| 25073 | 38197 | }, .{ |
| 25074 | | .required_features = .{ .avx2, null, null, null }, |
| 25075 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 38198 | .required_features = .{ .sse4_1, null, null, null }, |
| 38199 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25076 | 38200 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25077 | 38201 | .patterns = &.{ |
| 25078 | | .{ .src = .{ .to_sse, .none } }, |
| 38202 | .{ .src = .{ .mem, .none, .none } }, |
| 38203 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25079 | 38204 | }, |
| 25080 | 38205 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25081 | 38206 | .each = .{ .once = &.{ |
| 25082 | | .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, |
| 38207 | .{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ }, |
| 25083 | 38208 | } }, |
| 25084 | 38209 | }, .{ |
| 25085 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 25086 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 38210 | .required_features = .{ .sse2, null, null, null }, |
| 38211 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38212 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25087 | 38213 | .patterns = &.{ |
| 25088 | | .{ .src = .{ .to_mem, .none } }, |
| 38214 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25089 | 38215 | }, |
| 25090 | 38216 | .extra_temps = .{ |
| 25091 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25092 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 25093 | | .unused, |
| 25094 | | .unused, |
| 25095 | | .unused, |
| 25096 | | .unused, |
| 25097 | | .unused, |
| 25098 | | .unused, |
| 38217 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 25099 | 38218 | .unused, |
| 25100 | | }, |
| 25101 | | .dst_temps = .{.mem}, |
| 25102 | | .clobbers = .{ .eflags = true }, |
| 25103 | | .each = .{ .once = &.{ |
| 25104 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25105 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 25106 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25107 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 25108 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25109 | | } }, |
| 25110 | | }, .{ |
| 25111 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 25112 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 25113 | | .patterns = &.{ |
| 25114 | | .{ .src = .{ .to_mem, .none } }, |
| 25115 | | }, |
| 25116 | | .extra_temps = .{ |
| 25117 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25118 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 25119 | 38219 | .unused, |
| 25120 | 38220 | .unused, |
| 25121 | 38221 | .unused, |
| ... | ... | @@ -25124,51 +38224,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25124 | 38224 | .unused, |
| 25125 | 38225 | .unused, |
| 25126 | 38226 | }, |
| 25127 | | .dst_temps = .{.mem}, |
| 25128 | | .clobbers = .{ .eflags = true }, |
| 38227 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25129 | 38228 | .each = .{ .once = &.{ |
| 25130 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25131 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 25132 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25133 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 25134 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 38229 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 38230 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 38231 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 25135 | 38232 | } }, |
| 25136 | 38233 | }, .{ |
| 25137 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 25138 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 38234 | .required_features = .{ .sse2, null, null, null }, |
| 38235 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38236 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25139 | 38237 | .patterns = &.{ |
| 25140 | | .{ .src = .{ .to_mem, .none } }, |
| 38238 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25141 | 38239 | }, |
| 25142 | 38240 | .extra_temps = .{ |
| 25143 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25144 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 25145 | | .unused, |
| 25146 | | .unused, |
| 25147 | | .unused, |
| 25148 | | .unused, |
| 25149 | | .unused, |
| 38241 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 25150 | 38242 | .unused, |
| 25151 | 38243 | .unused, |
| 25152 | | }, |
| 25153 | | .dst_temps = .{.mem}, |
| 25154 | | .clobbers = .{ .eflags = true }, |
| 25155 | | .each = .{ .once = &.{ |
| 25156 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25157 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 25158 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25159 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 25160 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25161 | | } }, |
| 25162 | | }, .{ |
| 25163 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 25164 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 25165 | | .patterns = &.{ |
| 25166 | | .{ .src = .{ .to_mem, .none } }, |
| 25167 | | }, |
| 25168 | | .extra_temps = .{ |
| 25169 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25170 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25171 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 25172 | 38244 | .unused, |
| 25173 | 38245 | .unused, |
| 25174 | 38246 | .unused, |
| ... | ... | @@ -25176,70 +38248,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25176 | 38248 | .unused, |
| 25177 | 38249 | .unused, |
| 25178 | 38250 | }, |
| 25179 | | .dst_temps = .{.mem}, |
| 25180 | | .clobbers = .{ .eflags = true }, |
| 38251 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25181 | 38252 | .each = .{ .once = &.{ |
| 25182 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25183 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 25184 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 25185 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 25186 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 25187 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 25188 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 38253 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 38254 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 25189 | 38255 | } }, |
| 25190 | 38256 | }, .{ |
| 25191 | | .required_features = .{ .sse, null, null, null }, |
| 25192 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 25193 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25194 | | .patterns = &.{ |
| 25195 | | .{ .src = .{ .mut_mem, .none } }, |
| 25196 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25197 | | }, |
| 25198 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25199 | | .each = .{ .once = &.{} }, |
| 25200 | | }, .{ |
| 25201 | | .required_features = .{ .avx, null, null, null }, |
| 25202 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 25203 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 25204 | | .patterns = &.{ |
| 25205 | | .{ .src = .{ .mut_mem, .none } }, |
| 25206 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25207 | | }, |
| 25208 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25209 | | .each = .{ .once = &.{} }, |
| 25210 | | }, .{ |
| 25211 | | .required_features = .{ .avx, null, null, null }, |
| 25212 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 25213 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, |
| 38257 | .required_features = .{ .avx2, null, null, null }, |
| 38258 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 38259 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 25214 | 38260 | .patterns = &.{ |
| 25215 | | .{ .src = .{ .mem, .none } }, |
| 25216 | | .{ .src = .{ .to_sse, .none } }, |
| 38261 | .{ .src = .{ .mem, .none, .none } }, |
| 38262 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25217 | 38263 | }, |
| 25218 | 38264 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25219 | 38265 | .each = .{ .once = &.{ |
| 25220 | | .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ }, |
| 38266 | .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ }, |
| 25221 | 38267 | } }, |
| 25222 | 38268 | }, .{ |
| 25223 | | .required_features = .{ .sse2, null, null, null }, |
| 25224 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 25225 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, |
| 38269 | .required_features = .{ .avx2, null, null, null }, |
| 38270 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 38271 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, |
| 25226 | 38272 | .patterns = &.{ |
| 25227 | | .{ .src = .{ .mem, .none } }, |
| 25228 | | .{ .src = .{ .to_sse, .none } }, |
| 38273 | .{ .src = .{ .mem, .none, .none } }, |
| 38274 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25229 | 38275 | }, |
| 25230 | 38276 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25231 | 38277 | .each = .{ .once = &.{ |
| 25232 | | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ }, |
| 38278 | .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ }, |
| 25233 | 38279 | } }, |
| 25234 | 38280 | }, .{ |
| 25235 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 25236 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 38281 | .required_features = .{ .avx2, null, null, null }, |
| 38282 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 38283 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 25237 | 38284 | .patterns = &.{ |
| 25238 | | .{ .src = .{ .to_mem, .none } }, |
| 38285 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25239 | 38286 | }, |
| 25240 | 38287 | .extra_temps = .{ |
| 25241 | 38288 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25242 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 38289 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 25243 | 38290 | .unused, |
| 25244 | 38291 | .unused, |
| 25245 | 38292 | .unused, |
| ... | ... | @@ -25251,21 +38298,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25251 | 38298 | .dst_temps = .{.mem}, |
| 25252 | 38299 | .clobbers = .{ .eflags = true }, |
| 25253 | 38300 | .each = .{ .once = &.{ |
| 25254 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25255 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 25256 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 25257 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38301 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38302 | .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38303 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 38304 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 25258 | 38305 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25259 | 38306 | } }, |
| 25260 | 38307 | }, .{ |
| 25261 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 25262 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 38308 | .required_features = .{ .avx2, null, null, null }, |
| 38309 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 38310 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }}, |
| 25263 | 38311 | .patterns = &.{ |
| 25264 | | .{ .src = .{ .to_mem, .none } }, |
| 38312 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25265 | 38313 | }, |
| 25266 | 38314 | .extra_temps = .{ |
| 25267 | 38315 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25268 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 38316 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 25269 | 38317 | .unused, |
| 25270 | 38318 | .unused, |
| 25271 | 38319 | .unused, |
| ... | ... | @@ -25277,48 +38325,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25277 | 38325 | .dst_temps = .{.mem}, |
| 25278 | 38326 | .clobbers = .{ .eflags = true }, |
| 25279 | 38327 | .each = .{ .once = &.{ |
| 25280 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25281 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 25282 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 25283 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38328 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38329 | .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38330 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 38331 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 25284 | 38332 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25285 | 38333 | } }, |
| 25286 | 38334 | }, .{ |
| 25287 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 25288 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 38335 | .required_features = .{ .avx, null, null, null }, |
| 38336 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38337 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25289 | 38338 | .patterns = &.{ |
| 25290 | | .{ .src = .{ .to_mem, .none } }, |
| 38339 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25291 | 38340 | }, |
| 25292 | 38341 | .extra_temps = .{ |
| 25293 | 38342 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25294 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25295 | | .unused, |
| 25296 | | .unused, |
| 25297 | | .unused, |
| 25298 | | .unused, |
| 25299 | | .unused, |
| 25300 | | .unused, |
| 38343 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 25301 | 38344 | .unused, |
| 25302 | | }, |
| 25303 | | .dst_temps = .{.mem}, |
| 25304 | | .clobbers = .{ .eflags = true }, |
| 25305 | | .each = .{ .once = &.{ |
| 25306 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25307 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 25308 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 25309 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 25310 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25311 | | } }, |
| 25312 | | }, .{ |
| 25313 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 25314 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 25315 | | .patterns = &.{ |
| 25316 | | .{ .src = .{ .to_mem, .none } }, |
| 25317 | | }, |
| 25318 | | .extra_temps = .{ |
| 25319 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25320 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25321 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25322 | 38345 | .unused, |
| 25323 | 38346 | .unused, |
| 25324 | 38347 | .unused, |
| ... | ... | @@ -25329,45 +38352,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25329 | 38352 | .dst_temps = .{.mem}, |
| 25330 | 38353 | .clobbers = .{ .eflags = true }, |
| 25331 | 38354 | .each = .{ .once = &.{ |
| 25332 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25333 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 25334 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 25335 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 25336 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 25337 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38355 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38356 | .{ .@"0:", .vp_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38357 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38358 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25338 | 38359 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25339 | 38360 | } }, |
| 25340 | | }, .{ |
| 25341 | | .required_features = .{ .sse, null, null, null }, |
| 25342 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 25343 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 25344 | | .patterns = &.{ |
| 25345 | | .{ .src = .{ .mut_mem, .none } }, |
| 25346 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25347 | | }, |
| 25348 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25349 | | .each = .{ .once = &.{} }, |
| 25350 | 38361 | }, .{ |
| 25351 | 38362 | .required_features = .{ .avx, null, null, null }, |
| 25352 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any }, |
| 25353 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 25354 | | .patterns = &.{ |
| 25355 | | .{ .src = .{ .mut_mem, .none } }, |
| 25356 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25357 | | }, |
| 25358 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25359 | | .each = .{ .once = &.{} }, |
| 25360 | | }, .{ |
| 25361 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25362 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 25363 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 38363 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38364 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25364 | 38365 | .patterns = &.{ |
| 25365 | | .{ .src = .{ .to_mem, .none } }, |
| 38366 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25366 | 38367 | }, |
| 25367 | 38368 | .extra_temps = .{ |
| 25368 | 38369 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25369 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25370 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 38370 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 38371 | .unused, |
| 25371 | 38372 | .unused, |
| 25372 | 38373 | .unused, |
| 25373 | 38374 | .unused, |
| ... | ... | @@ -25378,56 +38379,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25378 | 38379 | .dst_temps = .{.mem}, |
| 25379 | 38380 | .clobbers = .{ .eflags = true }, |
| 25380 | 38381 | .each = .{ .once = &.{ |
| 25381 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 25382 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 25383 | | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 25384 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 25385 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 38382 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38383 | .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38384 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25386 | 38385 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25387 | 38386 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25388 | 38387 | } }, |
| 25389 | 38388 | }, .{ |
| 25390 | | .required_features = .{ .sse, null, null, null }, |
| 25391 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 25392 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 25393 | | .patterns = &.{ |
| 25394 | | .{ .src = .{ .mut_mem, .none } }, |
| 25395 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25396 | | }, |
| 25397 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25398 | | .each = .{ .once = &.{} }, |
| 25399 | | }, .{ |
| 25400 | | .required_features = .{ .avx, null, null, null }, |
| 25401 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any }, |
| 25402 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .xword } }}, |
| 25403 | | .patterns = &.{ |
| 25404 | | .{ .src = .{ .mut_mem, .none } }, |
| 25405 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25406 | | }, |
| 25407 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25408 | | .each = .{ .once = &.{} }, |
| 25409 | | }, .{ |
| 25410 | | .required_features = .{ .avx, null, null, null }, |
| 25411 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 25412 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .yword } }}, |
| 25413 | | .patterns = &.{ |
| 25414 | | .{ .src = .{ .mut_mem, .none } }, |
| 25415 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 25416 | | }, |
| 25417 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 25418 | | .each = .{ .once = &.{} }, |
| 25419 | | }, .{ |
| 25420 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 25421 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 25422 | | .dst_constraints = .{.any_scalar_int}, |
| 38389 | .required_features = .{ .sse4_1, null, null, null }, |
| 38390 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38391 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25423 | 38392 | .patterns = &.{ |
| 25424 | | .{ .src = .{ .to_mem, .none } }, |
| 38393 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25425 | 38394 | }, |
| 25426 | | .extra_temps = .{ |
| 25427 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25428 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 25429 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25430 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38395 | .extra_temps = .{ |
| 38396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38397 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 38398 | .unused, |
| 38399 | .unused, |
| 25431 | 38400 | .unused, |
| 25432 | 38401 | .unused, |
| 25433 | 38402 | .unused, |
| ... | ... | @@ -25437,27 +38406,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25437 | 38406 | .dst_temps = .{.mem}, |
| 25438 | 38407 | .clobbers = .{ .eflags = true }, |
| 25439 | 38408 | .each = .{ .once = &.{ |
| 25440 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 25441 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 25442 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 25443 | | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 25444 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 25445 | | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 25446 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 25447 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 38409 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38410 | .{ .@"0:", .p_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38411 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38412 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 38413 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25448 | 38414 | } }, |
| 25449 | 38415 | }, .{ |
| 25450 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25451 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 25452 | | .dst_constraints = .{.any_scalar_int}, |
| 38416 | .required_features = .{ .sse4_1, null, null, null }, |
| 38417 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38418 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25453 | 38419 | .patterns = &.{ |
| 25454 | | .{ .src = .{ .to_mem, .none } }, |
| 38420 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25455 | 38421 | }, |
| 25456 | 38422 | .extra_temps = .{ |
| 25457 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 25458 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 25459 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25460 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38424 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 38425 | .unused, |
| 38426 | .unused, |
| 25461 | 38427 | .unused, |
| 25462 | 38428 | .unused, |
| 25463 | 38429 | .unused, |
| ... | ... | @@ -25467,73 +38433,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25467 | 38433 | .dst_temps = .{.mem}, |
| 25468 | 38434 | .clobbers = .{ .eflags = true }, |
| 25469 | 38435 | .each = .{ .once = &.{ |
| 25470 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 25471 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 25472 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 25473 | | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 25474 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 25475 | | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 25476 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 25477 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25478 | | } }, |
| 25479 | | } } else comptime &.{ .{ |
| 25480 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 25481 | | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 25482 | | .patterns = &.{ |
| 25483 | | .{ .src = .{ .mem, .none } }, |
| 25484 | | .{ .src = .{ .to_gpr, .none } }, |
| 25485 | | }, |
| 25486 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 25487 | | .each = .{ .once = &.{ |
| 25488 | | .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ }, |
| 25489 | | } }, |
| 25490 | | }, .{ |
| 25491 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 25492 | | .dst_constraints = .{.{ .int = .dword }}, |
| 25493 | | .patterns = &.{ |
| 25494 | | .{ .src = .{ .mem, .none } }, |
| 25495 | | .{ .src = .{ .to_gpr, .none } }, |
| 25496 | | }, |
| 25497 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 25498 | | .each = .{ .once = &.{ |
| 25499 | | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 25500 | | } }, |
| 25501 | | }, .{ |
| 25502 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25503 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 25504 | | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 25505 | | .patterns = &.{ |
| 25506 | | .{ .src = .{ .mem, .none } }, |
| 25507 | | .{ .src = .{ .to_gpr, .none } }, |
| 25508 | | }, |
| 25509 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 25510 | | .each = .{ .once = &.{ |
| 25511 | | .{ ._, ._, .movsx, .dst0q, .src0b, ._, ._ }, |
| 25512 | | } }, |
| 25513 | | }, .{ |
| 25514 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25515 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 25516 | | .dst_constraints = .{.{ .int = .qword }}, |
| 25517 | | .patterns = &.{ |
| 25518 | | .{ .src = .{ .mem, .none } }, |
| 25519 | | .{ .src = .{ .to_gpr, .none } }, |
| 25520 | | }, |
| 25521 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 25522 | | .each = .{ .once = &.{ |
| 25523 | | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 38436 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38437 | .{ .@"0:", .p_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38438 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38439 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 38440 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25524 | 38441 | } }, |
| 25525 | 38442 | }, .{ |
| 25526 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25527 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 25528 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 38443 | .required_features = .{ .slow_incdec, null, null, null }, |
| 38444 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38445 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 25529 | 38446 | .patterns = &.{ |
| 25530 | | .{ .src = .{ .mem, .none } }, |
| 25531 | | .{ .src = .{ .to_gpr, .none } }, |
| 38447 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25532 | 38448 | }, |
| 25533 | 38449 | .extra_temps = .{ |
| 25534 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 25535 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25536 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38450 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38451 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 38452 | .unused, |
| 25537 | 38453 | .unused, |
| 25538 | 38454 | .unused, |
| 25539 | 38455 | .unused, |
| ... | ... | @@ -25544,25 +38460,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25544 | 38460 | .dst_temps = .{.mem}, |
| 25545 | 38461 | .clobbers = .{ .eflags = true }, |
| 25546 | 38462 | .each = .{ .once = &.{ |
| 25547 | | .{ ._, ._, .movsx, .tmp0q, .src0b, ._, ._ }, |
| 25548 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25549 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25550 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 25551 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25552 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38463 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38464 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38465 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 38466 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 38467 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25553 | 38468 | } }, |
| 25554 | 38469 | }, .{ |
| 25555 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25556 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 25557 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 38470 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38471 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 25558 | 38472 | .patterns = &.{ |
| 25559 | | .{ .src = .{ .mem, .none } }, |
| 25560 | | .{ .src = .{ .to_gpr, .none } }, |
| 38473 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25561 | 38474 | }, |
| 25562 | 38475 | .extra_temps = .{ |
| 25563 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 25564 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25565 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38477 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 38478 | .unused, |
| 25566 | 38479 | .unused, |
| 25567 | 38480 | .unused, |
| 25568 | 38481 | .unused, |
| ... | ... | @@ -25573,24 +38486,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25573 | 38486 | .dst_temps = .{.mem}, |
| 25574 | 38487 | .clobbers = .{ .eflags = true }, |
| 25575 | 38488 | .each = .{ .once = &.{ |
| 25576 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 25577 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25578 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25579 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25580 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25581 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38489 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38490 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38491 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 38492 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 38493 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25582 | 38494 | } }, |
| 25583 | 38495 | }, .{ |
| 25584 | | .src_constraints = .{ .{ .signed_int = .byte }, .any }, |
| 25585 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 38496 | .required_features = .{ .slow_incdec, null, null, null }, |
| 38497 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38498 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 25586 | 38499 | .patterns = &.{ |
| 25587 | | .{ .src = .{ .mem, .none } }, |
| 25588 | | .{ .src = .{ .to_gpr, .none } }, |
| 38500 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25589 | 38501 | }, |
| 25590 | 38502 | .extra_temps = .{ |
| 25591 | | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 25592 | | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 25593 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38503 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38504 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 38505 | .unused, |
| 25594 | 38506 | .unused, |
| 25595 | 38507 | .unused, |
| 25596 | 38508 | .unused, |
| ... | ... | @@ -25601,24 +38513,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25601 | 38513 | .dst_temps = .{.mem}, |
| 25602 | 38514 | .clobbers = .{ .eflags = true }, |
| 25603 | 38515 | .each = .{ .once = &.{ |
| 25604 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 25605 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25606 | | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 25607 | | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 25608 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 25609 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38516 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38517 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38518 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 38519 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 38520 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25610 | 38521 | } }, |
| 25611 | 38522 | }, .{ |
| 25612 | | .src_constraints = .{ .{ .int = .byte }, .any }, |
| 25613 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 38523 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38524 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 25614 | 38525 | .patterns = &.{ |
| 25615 | | .{ .src = .{ .mem, .none } }, |
| 25616 | | .{ .src = .{ .to_gpr, .none } }, |
| 38526 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25617 | 38527 | }, |
| 25618 | 38528 | .extra_temps = .{ |
| 25619 | | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 25620 | | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 25621 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38530 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 38531 | .unused, |
| 25622 | 38532 | .unused, |
| 25623 | 38533 | .unused, |
| 25624 | 38534 | .unused, |
| ... | ... | @@ -25629,71 +38539,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25629 | 38539 | .dst_temps = .{.mem}, |
| 25630 | 38540 | .clobbers = .{ .eflags = true }, |
| 25631 | 38541 | .each = .{ .once = &.{ |
| 25632 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 25633 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25634 | | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 25635 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25636 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 25637 | | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 38542 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38543 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38544 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 38545 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 38546 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25638 | 38547 | } }, |
| 25639 | 38548 | }, .{ |
| 25640 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 25641 | | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 38549 | .required_features = .{ .avx, null, null, null }, |
| 38550 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38551 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25642 | 38552 | .patterns = &.{ |
| 25643 | | .{ .src = .{ .mem, .none } }, |
| 25644 | | .{ .src = .{ .to_gpr, .none } }, |
| 38553 | .{ .src = .{ .mem, .none, .none } }, |
| 38554 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25645 | 38555 | }, |
| 25646 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 38556 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25647 | 38557 | .each = .{ .once = &.{ |
| 25648 | | .{ ._, ._, .movsx, .dst0d, .src0w, ._, ._ }, |
| 38558 | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 25649 | 38559 | } }, |
| 25650 | 38560 | }, .{ |
| 25651 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 25652 | | .dst_constraints = .{.{ .int = .dword }}, |
| 38561 | .required_features = .{ .avx, null, null, null }, |
| 38562 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38563 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25653 | 38564 | .patterns = &.{ |
| 25654 | | .{ .src = .{ .mem, .none } }, |
| 25655 | | .{ .src = .{ .to_gpr, .none } }, |
| 38565 | .{ .src = .{ .mem, .none, .none } }, |
| 38566 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25656 | 38567 | }, |
| 25657 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 38568 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25658 | 38569 | .each = .{ .once = &.{ |
| 25659 | | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, |
| 38570 | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 25660 | 38571 | } }, |
| 25661 | 38572 | }, .{ |
| 25662 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25663 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 25664 | | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 38573 | .required_features = .{ .sse4_1, null, null, null }, |
| 38574 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38575 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25665 | 38576 | .patterns = &.{ |
| 25666 | | .{ .src = .{ .mem, .none } }, |
| 25667 | | .{ .src = .{ .to_gpr, .none } }, |
| 38577 | .{ .src = .{ .mem, .none, .none } }, |
| 38578 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25668 | 38579 | }, |
| 25669 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 38580 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25670 | 38581 | .each = .{ .once = &.{ |
| 25671 | | .{ ._, ._, .movsx, .dst0q, .src0w, ._, ._ }, |
| 38582 | .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 25672 | 38583 | } }, |
| 25673 | 38584 | }, .{ |
| 25674 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25675 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 25676 | | .dst_constraints = .{.{ .int = .qword }}, |
| 38585 | .required_features = .{ .sse4_1, null, null, null }, |
| 38586 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38587 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25677 | 38588 | .patterns = &.{ |
| 25678 | | .{ .src = .{ .mem, .none } }, |
| 25679 | | .{ .src = .{ .to_gpr, .none } }, |
| 38589 | .{ .src = .{ .mem, .none, .none } }, |
| 38590 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25680 | 38591 | }, |
| 25681 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 38592 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25682 | 38593 | .each = .{ .once = &.{ |
| 25683 | | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, |
| 38594 | .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 25684 | 38595 | } }, |
| 25685 | 38596 | }, .{ |
| 25686 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25687 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 25688 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 38597 | .required_features = .{ .sse2, null, null, null }, |
| 38598 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38599 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25689 | 38600 | .patterns = &.{ |
| 25690 | | .{ .src = .{ .mem, .none } }, |
| 25691 | | .{ .src = .{ .to_gpr, .none } }, |
| 38601 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25692 | 38602 | }, |
| 25693 | 38603 | .extra_temps = .{ |
| 25694 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 25695 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25696 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38604 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 38605 | .unused, |
| 38606 | .unused, |
| 25697 | 38607 | .unused, |
| 25698 | 38608 | .unused, |
| 25699 | 38609 | .unused, |
| ... | ... | @@ -25701,28 +38611,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25701 | 38611 | .unused, |
| 25702 | 38612 | .unused, |
| 25703 | 38613 | }, |
| 25704 | | .dst_temps = .{.mem}, |
| 25705 | | .clobbers = .{ .eflags = true }, |
| 38614 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25706 | 38615 | .each = .{ .once = &.{ |
| 25707 | | .{ ._, ._, .movsx, .tmp0q, .src0w, ._, ._ }, |
| 25708 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25709 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25710 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 25711 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25712 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38616 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 38617 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 38618 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 38619 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 38620 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 25713 | 38621 | } }, |
| 25714 | 38622 | }, .{ |
| 25715 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25716 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 25717 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 38623 | .required_features = .{ .sse2, null, null, null }, |
| 38624 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38625 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25718 | 38626 | .patterns = &.{ |
| 25719 | | .{ .src = .{ .mem, .none } }, |
| 25720 | | .{ .src = .{ .to_gpr, .none } }, |
| 38627 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25721 | 38628 | }, |
| 25722 | 38629 | .extra_temps = .{ |
| 25723 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 25724 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25725 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38630 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 38631 | .unused, |
| 38632 | .unused, |
| 25726 | 38633 | .unused, |
| 25727 | 38634 | .unused, |
| 25728 | 38635 | .unused, |
| ... | ... | @@ -25730,27 +38637,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25730 | 38637 | .unused, |
| 25731 | 38638 | .unused, |
| 25732 | 38639 | }, |
| 25733 | | .dst_temps = .{.mem}, |
| 25734 | | .clobbers = .{ .eflags = true }, |
| 38640 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25735 | 38641 | .each = .{ .once = &.{ |
| 25736 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 25737 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25738 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25739 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25740 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25741 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38642 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 38643 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 38644 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 25742 | 38645 | } }, |
| 25743 | 38646 | }, .{ |
| 25744 | | .src_constraints = .{ .{ .signed_int = .word }, .any }, |
| 25745 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 38647 | .required_features = .{ .avx2, null, null, null }, |
| 38648 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38649 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 38650 | .patterns = &.{ |
| 38651 | .{ .src = .{ .mem, .none, .none } }, |
| 38652 | .{ .src = .{ .to_sse, .none, .none } }, |
| 38653 | }, |
| 38654 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 38655 | .each = .{ .once = &.{ |
| 38656 | .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ }, |
| 38657 | } }, |
| 38658 | }, .{ |
| 38659 | .required_features = .{ .avx2, null, null, null }, |
| 38660 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38661 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 38662 | .patterns = &.{ |
| 38663 | .{ .src = .{ .mem, .none, .none } }, |
| 38664 | .{ .src = .{ .to_sse, .none, .none } }, |
| 38665 | }, |
| 38666 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 38667 | .each = .{ .once = &.{ |
| 38668 | .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ }, |
| 38669 | } }, |
| 38670 | }, .{ |
| 38671 | .required_features = .{ .avx2, null, null, null }, |
| 38672 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38673 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 25746 | 38674 | .patterns = &.{ |
| 25747 | | .{ .src = .{ .mem, .none } }, |
| 25748 | | .{ .src = .{ .to_gpr, .none } }, |
| 38675 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25749 | 38676 | }, |
| 25750 | 38677 | .extra_temps = .{ |
| 25751 | | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 25752 | | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 25753 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38678 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38679 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 38680 | .unused, |
| 25754 | 38681 | .unused, |
| 25755 | 38682 | .unused, |
| 25756 | 38683 | .unused, |
| ... | ... | @@ -25761,24 +38688,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25761 | 38688 | .dst_temps = .{.mem}, |
| 25762 | 38689 | .clobbers = .{ .eflags = true }, |
| 25763 | 38690 | .each = .{ .once = &.{ |
| 25764 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 25765 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25766 | | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 25767 | | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 25768 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 25769 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38691 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38692 | .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38693 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 38694 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 38695 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25770 | 38696 | } }, |
| 25771 | 38697 | }, .{ |
| 25772 | | .src_constraints = .{ .{ .int = .word }, .any }, |
| 25773 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 38698 | .required_features = .{ .avx2, null, null, null }, |
| 38699 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 38700 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 25774 | 38701 | .patterns = &.{ |
| 25775 | | .{ .src = .{ .mem, .none } }, |
| 25776 | | .{ .src = .{ .to_gpr, .none } }, |
| 38702 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25777 | 38703 | }, |
| 25778 | 38704 | .extra_temps = .{ |
| 25779 | | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 25780 | | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 25781 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38706 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 38707 | .unused, |
| 25782 | 38708 | .unused, |
| 25783 | 38709 | .unused, |
| 25784 | 38710 | .unused, |
| ... | ... | @@ -25789,49 +38715,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25789 | 38715 | .dst_temps = .{.mem}, |
| 25790 | 38716 | .clobbers = .{ .eflags = true }, |
| 25791 | 38717 | .each = .{ .once = &.{ |
| 25792 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 25793 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25794 | | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 25795 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25796 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 25797 | | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 25798 | | } }, |
| 25799 | | }, .{ |
| 25800 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25801 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 25802 | | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 25803 | | .patterns = &.{ |
| 25804 | | .{ .src = .{ .mem, .none } }, |
| 25805 | | .{ .src = .{ .to_gpr, .none } }, |
| 25806 | | }, |
| 25807 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 25808 | | .each = .{ .once = &.{ |
| 25809 | | .{ ._, ._d, .movsx, .dst0q, .src0d, ._, ._ }, |
| 25810 | | } }, |
| 25811 | | }, .{ |
| 25812 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25813 | | .src_constraints = .{ .{ .int = .dword }, .any }, |
| 25814 | | .dst_constraints = .{.{ .int = .qword }}, |
| 25815 | | .patterns = &.{ |
| 25816 | | .{ .src = .{ .mem, .none } }, |
| 25817 | | .{ .src = .{ .to_gpr, .none } }, |
| 25818 | | }, |
| 25819 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 25820 | | .each = .{ .once = &.{ |
| 25821 | | .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ }, |
| 38718 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38719 | .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38720 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 38721 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 38722 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25822 | 38723 | } }, |
| 25823 | 38724 | }, .{ |
| 25824 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25825 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 25826 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 38725 | .required_features = .{ .avx, null, null, null }, |
| 38726 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38727 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25827 | 38728 | .patterns = &.{ |
| 25828 | | .{ .src = .{ .mem, .none } }, |
| 25829 | | .{ .src = .{ .to_gpr, .none } }, |
| 38729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25830 | 38730 | }, |
| 25831 | 38731 | .extra_temps = .{ |
| 25832 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 25833 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25834 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38732 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38733 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 38734 | .unused, |
| 25835 | 38735 | .unused, |
| 25836 | 38736 | .unused, |
| 25837 | 38737 | .unused, |
| ... | ... | @@ -25842,25 +38742,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25842 | 38742 | .dst_temps = .{.mem}, |
| 25843 | 38743 | .clobbers = .{ .eflags = true }, |
| 25844 | 38744 | .each = .{ .once = &.{ |
| 25845 | | .{ ._, ._d, .movsx, .tmp0q, .src0d, ._, ._ }, |
| 25846 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25847 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25848 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 25849 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25850 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38745 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38746 | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38747 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38748 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25851 | 38750 | } }, |
| 25852 | 38751 | }, .{ |
| 25853 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25854 | | .src_constraints = .{ .{ .int = .dword }, .any }, |
| 25855 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 38752 | .required_features = .{ .avx, null, null, null }, |
| 38753 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38754 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25856 | 38755 | .patterns = &.{ |
| 25857 | | .{ .src = .{ .mem, .none } }, |
| 25858 | | .{ .src = .{ .to_gpr, .none } }, |
| 38756 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25859 | 38757 | }, |
| 25860 | 38758 | .extra_temps = .{ |
| 25861 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 25862 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25863 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38759 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38760 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 38761 | .unused, |
| 25864 | 38762 | .unused, |
| 25865 | 38763 | .unused, |
| 25866 | 38764 | .unused, |
| ... | ... | @@ -25871,24 +38769,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25871 | 38769 | .dst_temps = .{.mem}, |
| 25872 | 38770 | .clobbers = .{ .eflags = true }, |
| 25873 | 38771 | .each = .{ .once = &.{ |
| 25874 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 25875 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25876 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25877 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25878 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25879 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38772 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38773 | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38774 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38775 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38776 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25880 | 38777 | } }, |
| 25881 | 38778 | }, .{ |
| 25882 | | .src_constraints = .{ .{ .signed_int = .dword }, .any }, |
| 25883 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 38779 | .required_features = .{ .sse4_1, null, null, null }, |
| 38780 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38781 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25884 | 38782 | .patterns = &.{ |
| 25885 | | .{ .src = .{ .mem, .none } }, |
| 25886 | | .{ .src = .{ .to_gpr, .none } }, |
| 38783 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25887 | 38784 | }, |
| 25888 | 38785 | .extra_temps = .{ |
| 25889 | | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 25890 | | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 25891 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38786 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38787 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 38788 | .unused, |
| 25892 | 38789 | .unused, |
| 25893 | 38790 | .unused, |
| 25894 | 38791 | .unused, |
| ... | ... | @@ -25899,24 +38796,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25899 | 38796 | .dst_temps = .{.mem}, |
| 25900 | 38797 | .clobbers = .{ .eflags = true }, |
| 25901 | 38798 | .each = .{ .once = &.{ |
| 25902 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 25903 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25904 | | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 25905 | | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 25906 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 25907 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38799 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38800 | .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38801 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38802 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38803 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25908 | 38804 | } }, |
| 25909 | 38805 | }, .{ |
| 25910 | | .src_constraints = .{ .{ .int = .dword }, .any }, |
| 25911 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 38806 | .required_features = .{ .sse4_1, null, null, null }, |
| 38807 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 38808 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25912 | 38809 | .patterns = &.{ |
| 25913 | | .{ .src = .{ .mem, .none } }, |
| 25914 | | .{ .src = .{ .to_gpr, .none } }, |
| 38810 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25915 | 38811 | }, |
| 25916 | 38812 | .extra_temps = .{ |
| 25917 | | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 25918 | | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 25919 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38814 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 38815 | .unused, |
| 25920 | 38816 | .unused, |
| 25921 | 38817 | .unused, |
| 25922 | 38818 | .unused, |
| ... | ... | @@ -25927,25 +38823,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25927 | 38823 | .dst_temps = .{.mem}, |
| 25928 | 38824 | .clobbers = .{ .eflags = true }, |
| 25929 | 38825 | .each = .{ .once = &.{ |
| 25930 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 25931 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25932 | | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 25933 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25934 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 25935 | | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 38826 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38827 | .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38828 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 38829 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 38830 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25936 | 38831 | } }, |
| 25937 | 38832 | }, .{ |
| 25938 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25939 | | .src_constraints = .{ .{ .signed_int = .qword }, .any }, |
| 25940 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 38833 | .required_features = .{ .slow_incdec, null, null, null }, |
| 38834 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38835 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 25941 | 38836 | .patterns = &.{ |
| 25942 | | .{ .src = .{ .mem, .none } }, |
| 25943 | | .{ .src = .{ .to_gpr, .none } }, |
| 38837 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25944 | 38838 | }, |
| 25945 | 38839 | .extra_temps = .{ |
| 25946 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 25947 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25948 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38840 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38841 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 38842 | .unused, |
| 25949 | 38843 | .unused, |
| 25950 | 38844 | .unused, |
| 25951 | 38845 | .unused, |
| ... | ... | @@ -25956,25 +38850,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25956 | 38850 | .dst_temps = .{.mem}, |
| 25957 | 38851 | .clobbers = .{ .eflags = true }, |
| 25958 | 38852 | .each = .{ .once = &.{ |
| 25959 | | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| 25960 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25961 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25962 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 25963 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25964 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38853 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38854 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38855 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 38856 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 38857 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25965 | 38858 | } }, |
| 25966 | 38859 | }, .{ |
| 25967 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25968 | | .src_constraints = .{ .{ .int = .qword }, .any }, |
| 25969 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 38860 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38861 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 25970 | 38862 | .patterns = &.{ |
| 25971 | | .{ .src = .{ .mem, .none } }, |
| 25972 | | .{ .src = .{ .to_gpr, .none } }, |
| 38863 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25973 | 38864 | }, |
| 25974 | 38865 | .extra_temps = .{ |
| 25975 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 25976 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 25977 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 38866 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38867 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 38868 | .unused, |
| 25978 | 38869 | .unused, |
| 25979 | 38870 | .unused, |
| 25980 | 38871 | .unused, |
| ... | ... | @@ -25985,25 +38876,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25985 | 38876 | .dst_temps = .{.mem}, |
| 25986 | 38877 | .clobbers = .{ .eflags = true }, |
| 25987 | 38878 | .each = .{ .once = &.{ |
| 25988 | | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| 25989 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 25990 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 25991 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 25992 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 25993 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38879 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38880 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38881 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 38882 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 38883 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25994 | 38884 | } }, |
| 25995 | 38885 | }, .{ |
| 25996 | | .required_features = .{ .@"64bit", null, null, null }, |
| 25997 | | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 25998 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 38886 | .required_features = .{ .slow_incdec, null, null, null }, |
| 38887 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38888 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 25999 | 38889 | .patterns = &.{ |
| 26000 | | .{ .src = .{ .to_mem, .none } }, |
| 38890 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26001 | 38891 | }, |
| 26002 | 38892 | .extra_temps = .{ |
| 26003 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 26004 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 26005 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 26006 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 38893 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38894 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 38895 | .unused, |
| 38896 | .unused, |
| 26007 | 38897 | .unused, |
| 26008 | 38898 | .unused, |
| 26009 | 38899 | .unused, |
| ... | ... | @@ -26013,28 +38903,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26013 | 38903 | .dst_temps = .{.mem}, |
| 26014 | 38904 | .clobbers = .{ .eflags = true }, |
| 26015 | 38905 | .each = .{ .once = &.{ |
| 26016 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 26017 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 26018 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 26019 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 26020 | | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 26021 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 26022 | | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 26023 | | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, |
| 26024 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38906 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38907 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38908 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 38909 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 38910 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26025 | 38911 | } }, |
| 26026 | 38912 | }, .{ |
| 26027 | | .required_features = .{ .@"64bit", null, null, null }, |
| 26028 | | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 26029 | | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 38913 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 38914 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 26030 | 38915 | .patterns = &.{ |
| 26031 | | .{ .src = .{ .to_mem, .none } }, |
| 38916 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26032 | 38917 | }, |
| 26033 | 38918 | .extra_temps = .{ |
| 26034 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 26035 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 26036 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 26037 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 38919 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 38920 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 38921 | .unused, |
| 38922 | .unused, |
| 26038 | 38923 | .unused, |
| 26039 | 38924 | .unused, |
| 26040 | 38925 | .unused, |
| ... | ... | @@ -26044,68 +38929,66 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26044 | 38929 | .dst_temps = .{.mem}, |
| 26045 | 38930 | .clobbers = .{ .eflags = true }, |
| 26046 | 38931 | .each = .{ .once = &.{ |
| 26047 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 26048 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 26049 | | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 26050 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 26051 | | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 26052 | | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, |
| 26053 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 38932 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 38933 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 38934 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 38935 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 38936 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26054 | 38937 | } }, |
| 26055 | 38938 | }, .{ |
| 26056 | 38939 | .required_features = .{ .avx, null, null, null }, |
| 26057 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26058 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 38940 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 38941 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26059 | 38942 | .patterns = &.{ |
| 26060 | | .{ .src = .{ .mem, .none } }, |
| 26061 | | .{ .src = .{ .to_sse, .none } }, |
| 38943 | .{ .src = .{ .mem, .none, .none } }, |
| 38944 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26062 | 38945 | }, |
| 26063 | 38946 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26064 | 38947 | .each = .{ .once = &.{ |
| 26065 | | .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ }, |
| 38948 | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 26066 | 38949 | } }, |
| 26067 | 38950 | }, .{ |
| 26068 | 38951 | .required_features = .{ .avx, null, null, null }, |
| 26069 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26070 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 38952 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 38953 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26071 | 38954 | .patterns = &.{ |
| 26072 | | .{ .src = .{ .mem, .none } }, |
| 26073 | | .{ .src = .{ .to_sse, .none } }, |
| 38955 | .{ .src = .{ .mem, .none, .none } }, |
| 38956 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26074 | 38957 | }, |
| 26075 | 38958 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26076 | 38959 | .each = .{ .once = &.{ |
| 26077 | | .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ }, |
| 38960 | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 26078 | 38961 | } }, |
| 26079 | 38962 | }, .{ |
| 26080 | 38963 | .required_features = .{ .sse4_1, null, null, null }, |
| 26081 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26082 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 38964 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 38965 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26083 | 38966 | .patterns = &.{ |
| 26084 | | .{ .src = .{ .mem, .none } }, |
| 26085 | | .{ .src = .{ .to_sse, .none } }, |
| 38967 | .{ .src = .{ .mem, .none, .none } }, |
| 38968 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26086 | 38969 | }, |
| 26087 | 38970 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26088 | 38971 | .each = .{ .once = &.{ |
| 26089 | | .{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ }, |
| 38972 | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 26090 | 38973 | } }, |
| 26091 | 38974 | }, .{ |
| 26092 | 38975 | .required_features = .{ .sse4_1, null, null, null }, |
| 26093 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26094 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 38976 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 38977 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26095 | 38978 | .patterns = &.{ |
| 26096 | | .{ .src = .{ .mem, .none } }, |
| 26097 | | .{ .src = .{ .to_sse, .none } }, |
| 38979 | .{ .src = .{ .mem, .none, .none } }, |
| 38980 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26098 | 38981 | }, |
| 26099 | 38982 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26100 | 38983 | .each = .{ .once = &.{ |
| 26101 | | .{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ }, |
| 38984 | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 26102 | 38985 | } }, |
| 26103 | 38986 | }, .{ |
| 26104 | 38987 | .required_features = .{ .sse2, null, null, null }, |
| 26105 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26106 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 38988 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 38989 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26107 | 38990 | .patterns = &.{ |
| 26108 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 38991 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26109 | 38992 | }, |
| 26110 | 38993 | .extra_temps = .{ |
| 26111 | 38994 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -26123,13 +39006,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26123 | 39006 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26124 | 39007 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 26125 | 39008 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 39009 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 39010 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 39011 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 39012 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26126 | 39013 | } }, |
| 26127 | 39014 | }, .{ |
| 26128 | 39015 | .required_features = .{ .sse2, null, null, null }, |
| 26129 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26130 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 39016 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 39017 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26131 | 39018 | .patterns = &.{ |
| 26132 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 39019 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26133 | 39020 | }, |
| 26134 | 39021 | .extra_temps = .{ |
| 26135 | 39022 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -26146,41 +39033,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26146 | 39033 | .each = .{ .once = &.{ |
| 26147 | 39034 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26148 | 39035 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 39036 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 39037 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26149 | 39038 | } }, |
| 26150 | 39039 | }, .{ |
| 26151 | 39040 | .required_features = .{ .avx2, null, null, null }, |
| 26152 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 26153 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 39041 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 39042 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26154 | 39043 | .patterns = &.{ |
| 26155 | | .{ .src = .{ .mem, .none } }, |
| 26156 | | .{ .src = .{ .to_sse, .none } }, |
| 39044 | .{ .src = .{ .mem, .none, .none } }, |
| 39045 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26157 | 39046 | }, |
| 26158 | 39047 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26159 | 39048 | .each = .{ .once = &.{ |
| 26160 | | .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ }, |
| 39049 | .{ ._, .vp_q, .movsxb, .dst0y, .src0d, ._, ._ }, |
| 26161 | 39050 | } }, |
| 26162 | 39051 | }, .{ |
| 26163 | 39052 | .required_features = .{ .avx2, null, null, null }, |
| 26164 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 26165 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, |
| 39053 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 39054 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26166 | 39055 | .patterns = &.{ |
| 26167 | | .{ .src = .{ .mem, .none } }, |
| 26168 | | .{ .src = .{ .to_sse, .none } }, |
| 39056 | .{ .src = .{ .mem, .none, .none } }, |
| 39057 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26169 | 39058 | }, |
| 26170 | 39059 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26171 | 39060 | .each = .{ .once = &.{ |
| 26172 | | .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ }, |
| 39061 | .{ ._, .vp_q, .movzxb, .dst0y, .src0d, ._, ._ }, |
| 26173 | 39062 | } }, |
| 26174 | 39063 | }, .{ |
| 26175 | 39064 | .required_features = .{ .avx2, null, null, null }, |
| 26176 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 26177 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 39065 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 39066 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26178 | 39067 | .patterns = &.{ |
| 26179 | | .{ .src = .{ .to_mem, .none } }, |
| 39068 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26180 | 39069 | }, |
| 26181 | 39070 | .extra_temps = .{ |
| 26182 | 39071 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26183 | | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 39072 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 26184 | 39073 | .unused, |
| 26185 | 39074 | .unused, |
| 26186 | 39075 | .unused, |
| ... | ... | @@ -26193,21 +39082,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26193 | 39082 | .clobbers = .{ .eflags = true }, |
| 26194 | 39083 | .each = .{ .once = &.{ |
| 26195 | 39084 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26196 | | .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26197 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26198 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 39085 | .{ .@"0:", .vp_q, .movsxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39086 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 39087 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 26199 | 39088 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26200 | 39089 | } }, |
| 26201 | 39090 | }, .{ |
| 26202 | 39091 | .required_features = .{ .avx2, null, null, null }, |
| 26203 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 26204 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }}, |
| 39092 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 39093 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26205 | 39094 | .patterns = &.{ |
| 26206 | | .{ .src = .{ .to_mem, .none } }, |
| 39095 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26207 | 39096 | }, |
| 26208 | 39097 | .extra_temps = .{ |
| 26209 | 39098 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26210 | | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 39099 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 26211 | 39100 | .unused, |
| 26212 | 39101 | .unused, |
| 26213 | 39102 | .unused, |
| ... | ... | @@ -26220,21 +39109,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26220 | 39109 | .clobbers = .{ .eflags = true }, |
| 26221 | 39110 | .each = .{ .once = &.{ |
| 26222 | 39111 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26223 | | .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26224 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26225 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 39112 | .{ .@"0:", .vp_q, .movzxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39113 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 39114 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 26226 | 39115 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26227 | 39116 | } }, |
| 26228 | 39117 | }, .{ |
| 26229 | 39118 | .required_features = .{ .avx, null, null, null }, |
| 26230 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26231 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 39119 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 39120 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26232 | 39121 | .patterns = &.{ |
| 26233 | | .{ .src = .{ .to_mem, .none } }, |
| 39122 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26234 | 39123 | }, |
| 26235 | 39124 | .extra_temps = .{ |
| 26236 | 39125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26237 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 39126 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 26238 | 39127 | .unused, |
| 26239 | 39128 | .unused, |
| 26240 | 39129 | .unused, |
| ... | ... | @@ -26247,21 +39136,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26247 | 39136 | .clobbers = .{ .eflags = true }, |
| 26248 | 39137 | .each = .{ .once = &.{ |
| 26249 | 39138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26250 | | .{ .@"0:", .vp_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26251 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26252 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 39139 | .{ .@"0:", .vp_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39140 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39141 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26253 | 39142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26254 | 39143 | } }, |
| 26255 | 39144 | }, .{ |
| 26256 | 39145 | .required_features = .{ .avx, null, null, null }, |
| 26257 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26258 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, |
| 39146 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 39147 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26259 | 39148 | .patterns = &.{ |
| 26260 | | .{ .src = .{ .to_mem, .none } }, |
| 39149 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26261 | 39150 | }, |
| 26262 | 39151 | .extra_temps = .{ |
| 26263 | 39152 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26264 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 39153 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 26265 | 39154 | .unused, |
| 26266 | 39155 | .unused, |
| 26267 | 39156 | .unused, |
| ... | ... | @@ -26274,21 +39163,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26274 | 39163 | .clobbers = .{ .eflags = true }, |
| 26275 | 39164 | .each = .{ .once = &.{ |
| 26276 | 39165 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26277 | | .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26278 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26279 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 39166 | .{ .@"0:", .vp_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39167 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39168 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26280 | 39169 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26281 | 39170 | } }, |
| 26282 | 39171 | }, .{ |
| 26283 | 39172 | .required_features = .{ .sse4_1, null, null, null }, |
| 26284 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26285 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 39173 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 39174 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26286 | 39175 | .patterns = &.{ |
| 26287 | | .{ .src = .{ .to_mem, .none } }, |
| 39176 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26288 | 39177 | }, |
| 26289 | 39178 | .extra_temps = .{ |
| 26290 | 39179 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26291 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 39180 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 26292 | 39181 | .unused, |
| 26293 | 39182 | .unused, |
| 26294 | 39183 | .unused, |
| ... | ... | @@ -26301,21 +39190,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26301 | 39190 | .clobbers = .{ .eflags = true }, |
| 26302 | 39191 | .each = .{ .once = &.{ |
| 26303 | 39192 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26304 | | .{ .@"0:", .p_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26305 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26306 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 39193 | .{ .@"0:", .p_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39194 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39195 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26307 | 39196 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26308 | 39197 | } }, |
| 26309 | 39198 | }, .{ |
| 26310 | 39199 | .required_features = .{ .sse4_1, null, null, null }, |
| 26311 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26312 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, |
| 39200 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 39201 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26313 | 39202 | .patterns = &.{ |
| 26314 | | .{ .src = .{ .to_mem, .none } }, |
| 39203 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26315 | 39204 | }, |
| 26316 | 39205 | .extra_temps = .{ |
| 26317 | 39206 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26318 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 39207 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 26319 | 39208 | .unused, |
| 26320 | 39209 | .unused, |
| 26321 | 39210 | .unused, |
| ... | ... | @@ -26328,21 +39217,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26328 | 39217 | .clobbers = .{ .eflags = true }, |
| 26329 | 39218 | .each = .{ .once = &.{ |
| 26330 | 39219 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26331 | | .{ .@"0:", .p_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26332 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26333 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 39220 | .{ .@"0:", .p_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39221 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39222 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26334 | 39223 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26335 | 39224 | } }, |
| 26336 | 39225 | }, .{ |
| 26337 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 26338 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26339 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 39226 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 39227 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39228 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 26340 | 39229 | .patterns = &.{ |
| 26341 | | .{ .src = .{ .to_mem, .none } }, |
| 39230 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26342 | 39231 | }, |
| 26343 | 39232 | .extra_temps = .{ |
| 26344 | 39233 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26345 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 39234 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 26346 | 39235 | .unused, |
| 26347 | 39236 | .unused, |
| 26348 | 39237 | .unused, |
| ... | ... | @@ -26355,20 +39244,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26355 | 39244 | .clobbers = .{ .eflags = true }, |
| 26356 | 39245 | .each = .{ .once = &.{ |
| 26357 | 39246 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26358 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26359 | | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 39247 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39248 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 26360 | 39249 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 26361 | 39250 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26362 | 39251 | } }, |
| 26363 | 39252 | }, .{ |
| 26364 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26365 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 39253 | .required_features = .{ .@"64bit", null, null, null }, |
| 39254 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39255 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 26366 | 39256 | .patterns = &.{ |
| 26367 | | .{ .src = .{ .to_mem, .none } }, |
| 39257 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26368 | 39258 | }, |
| 26369 | 39259 | .extra_temps = .{ |
| 26370 | 39260 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26371 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 39261 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 26372 | 39262 | .unused, |
| 26373 | 39263 | .unused, |
| 26374 | 39264 | .unused, |
| ... | ... | @@ -26381,21 +39271,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26381 | 39271 | .clobbers = .{ .eflags = true }, |
| 26382 | 39272 | .each = .{ .once = &.{ |
| 26383 | 39273 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26384 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26385 | | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 39274 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39275 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 26386 | 39276 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26387 | 39277 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26388 | 39278 | } }, |
| 26389 | 39279 | }, .{ |
| 26390 | 39280 | .required_features = .{ .slow_incdec, null, null, null }, |
| 26391 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26392 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 39281 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39282 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 26393 | 39283 | .patterns = &.{ |
| 26394 | | .{ .src = .{ .to_mem, .none } }, |
| 39284 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26395 | 39285 | }, |
| 26396 | 39286 | .extra_temps = .{ |
| 26397 | 39287 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26398 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 39288 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 26399 | 39289 | .unused, |
| 26400 | 39290 | .unused, |
| 26401 | 39291 | .unused, |
| ... | ... | @@ -26409,19 +39299,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26409 | 39299 | .each = .{ .once = &.{ |
| 26410 | 39300 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26411 | 39301 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26412 | | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 39302 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 26413 | 39303 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 26414 | 39304 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26415 | 39305 | } }, |
| 26416 | 39306 | }, .{ |
| 26417 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26418 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 39307 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39308 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 26419 | 39309 | .patterns = &.{ |
| 26420 | | .{ .src = .{ .to_mem, .none } }, |
| 39310 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26421 | 39311 | }, |
| 26422 | 39312 | .extra_temps = .{ |
| 26423 | 39313 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26424 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 39314 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 26425 | 39315 | .unused, |
| 26426 | 39316 | .unused, |
| 26427 | 39317 | .unused, |
| ... | ... | @@ -26435,64 +39325,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26435 | 39325 | .each = .{ .once = &.{ |
| 26436 | 39326 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26437 | 39327 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26438 | | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 39328 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 26439 | 39329 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26440 | 39330 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26441 | 39331 | } }, |
| 26442 | 39332 | }, .{ |
| 26443 | 39333 | .required_features = .{ .avx, null, null, null }, |
| 26444 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26445 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39334 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39335 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 26446 | 39336 | .patterns = &.{ |
| 26447 | | .{ .src = .{ .mem, .none } }, |
| 26448 | | .{ .src = .{ .to_sse, .none } }, |
| 39337 | .{ .src = .{ .mem, .none, .none } }, |
| 39338 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26449 | 39339 | }, |
| 26450 | 39340 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26451 | 39341 | .each = .{ .once = &.{ |
| 26452 | | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 39342 | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 39343 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 26453 | 39344 | } }, |
| 26454 | 39345 | }, .{ |
| 26455 | 39346 | .required_features = .{ .avx, null, null, null }, |
| 26456 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26457 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39347 | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39348 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 26458 | 39349 | .patterns = &.{ |
| 26459 | | .{ .src = .{ .mem, .none } }, |
| 26460 | | .{ .src = .{ .to_sse, .none } }, |
| 39350 | .{ .src = .{ .mem, .none, .none } }, |
| 39351 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26461 | 39352 | }, |
| 26462 | 39353 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26463 | 39354 | .each = .{ .once = &.{ |
| 26464 | | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 39355 | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 39356 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 26465 | 39357 | } }, |
| 26466 | 39358 | }, .{ |
| 26467 | 39359 | .required_features = .{ .sse4_1, null, null, null }, |
| 26468 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26469 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39360 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39361 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 26470 | 39362 | .patterns = &.{ |
| 26471 | | .{ .src = .{ .mem, .none } }, |
| 26472 | | .{ .src = .{ .to_sse, .none } }, |
| 39363 | .{ .src = .{ .mem, .none, .none } }, |
| 39364 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26473 | 39365 | }, |
| 26474 | 39366 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26475 | 39367 | .each = .{ .once = &.{ |
| 26476 | | .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 39368 | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 39369 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 26477 | 39370 | } }, |
| 26478 | 39371 | }, .{ |
| 26479 | 39372 | .required_features = .{ .sse4_1, null, null, null }, |
| 26480 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26481 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39373 | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39374 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 26482 | 39375 | .patterns = &.{ |
| 26483 | | .{ .src = .{ .mem, .none } }, |
| 26484 | | .{ .src = .{ .to_sse, .none } }, |
| 39376 | .{ .src = .{ .mem, .none, .none } }, |
| 39377 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26485 | 39378 | }, |
| 26486 | 39379 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26487 | 39380 | .each = .{ .once = &.{ |
| 26488 | | .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 39381 | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 39382 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 26489 | 39383 | } }, |
| 26490 | 39384 | }, .{ |
| 26491 | 39385 | .required_features = .{ .sse2, null, null, null }, |
| 26492 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26493 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39386 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39387 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 26494 | 39388 | .patterns = &.{ |
| 26495 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 39389 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26496 | 39390 | }, |
| 26497 | 39391 | .extra_temps = .{ |
| 26498 | 39392 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -26512,13 +39406,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26512 | 39406 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 26513 | 39407 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 26514 | 39408 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 39409 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 39410 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 39411 | .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ }, |
| 39412 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 26515 | 39413 | } }, |
| 26516 | 39414 | }, .{ |
| 26517 | 39415 | .required_features = .{ .sse2, null, null, null }, |
| 26518 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26519 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39416 | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39417 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 26520 | 39418 | .patterns = &.{ |
| 26521 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 39419 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26522 | 39420 | }, |
| 26523 | 39421 | .extra_temps = .{ |
| 26524 | 39422 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -26536,43 +39434,83 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26536 | 39434 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26537 | 39435 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 26538 | 39436 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 39437 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 39438 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 26539 | 39439 | } }, |
| 26540 | 39440 | }, .{ |
| 26541 | | .required_features = .{ .avx2, null, null, null }, |
| 26542 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26543 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 39441 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 39442 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39443 | .dst_constraints = .{.any_scalar_signed_int}, |
| 26544 | 39444 | .patterns = &.{ |
| 26545 | | .{ .src = .{ .mem, .none } }, |
| 26546 | | .{ .src = .{ .to_sse, .none } }, |
| 39445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26547 | 39446 | }, |
| 26548 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39447 | .extra_temps = .{ |
| 39448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 39449 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 39450 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 39451 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 39452 | .unused, |
| 39453 | .unused, |
| 39454 | .unused, |
| 39455 | .unused, |
| 39456 | .unused, |
| 39457 | }, |
| 39458 | .dst_temps = .{.mem}, |
| 39459 | .clobbers = .{ .eflags = true }, |
| 26549 | 39460 | .each = .{ .once = &.{ |
| 26550 | | .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ }, |
| 39461 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 39462 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 39463 | .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39464 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 39465 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 39466 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 39467 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 39468 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 39469 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26551 | 39470 | } }, |
| 26552 | 39471 | }, .{ |
| 26553 | | .required_features = .{ .avx2, null, null, null }, |
| 26554 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26555 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 39472 | .required_features = .{ .@"64bit", null, null, null }, |
| 39473 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39474 | .dst_constraints = .{.any_scalar_signed_int}, |
| 26556 | 39475 | .patterns = &.{ |
| 26557 | | .{ .src = .{ .mem, .none } }, |
| 26558 | | .{ .src = .{ .to_sse, .none } }, |
| 39476 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26559 | 39477 | }, |
| 26560 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39478 | .extra_temps = .{ |
| 39479 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 39480 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 39481 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 39482 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 39483 | .unused, |
| 39484 | .unused, |
| 39485 | .unused, |
| 39486 | .unused, |
| 39487 | .unused, |
| 39488 | }, |
| 39489 | .dst_temps = .{.mem}, |
| 39490 | .clobbers = .{ .eflags = true }, |
| 26561 | 39491 | .each = .{ .once = &.{ |
| 26562 | | .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ }, |
| 39492 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 39493 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 39494 | .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39495 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 39496 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 39497 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 39498 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 39499 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 39500 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26563 | 39501 | } }, |
| 26564 | 39502 | }, .{ |
| 26565 | | .required_features = .{ .avx2, null, null, null }, |
| 26566 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26567 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 39503 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 39504 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39505 | .dst_constraints = .{.any_scalar_int}, |
| 26568 | 39506 | .patterns = &.{ |
| 26569 | | .{ .src = .{ .to_mem, .none } }, |
| 39507 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26570 | 39508 | }, |
| 26571 | 39509 | .extra_temps = .{ |
| 26572 | 39510 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26573 | | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 26574 | | .unused, |
| 26575 | | .unused, |
| 39511 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 39512 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 39513 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 26576 | 39514 | .unused, |
| 26577 | 39515 | .unused, |
| 26578 | 39516 | .unused, |
| ... | ... | @@ -26583,23 +39521,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26583 | 39521 | .clobbers = .{ .eflags = true }, |
| 26584 | 39522 | .each = .{ .once = &.{ |
| 26585 | 39523 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26586 | | .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26587 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26588 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 39524 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 39525 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39526 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 39527 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 39528 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 39529 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 39530 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 26589 | 39531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26590 | 39532 | } }, |
| 26591 | 39533 | }, .{ |
| 26592 | | .required_features = .{ .avx2, null, null, null }, |
| 26593 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, |
| 26594 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 39534 | .required_features = .{ .@"64bit", null, null, null }, |
| 39535 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 39536 | .dst_constraints = .{.any_scalar_int}, |
| 26595 | 39537 | .patterns = &.{ |
| 26596 | | .{ .src = .{ .to_mem, .none } }, |
| 39538 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26597 | 39539 | }, |
| 26598 | 39540 | .extra_temps = .{ |
| 26599 | 39541 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26600 | | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 26601 | | .unused, |
| 26602 | | .unused, |
| 39542 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 39543 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 39544 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 26603 | 39545 | .unused, |
| 26604 | 39546 | .unused, |
| 26605 | 39547 | .unused, |
| ... | ... | @@ -26610,21 +39552,144 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26610 | 39552 | .clobbers = .{ .eflags = true }, |
| 26611 | 39553 | .each = .{ .once = &.{ |
| 26612 | 39554 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26613 | | .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26614 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26615 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26616 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 39555 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 39556 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39557 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 39558 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 39559 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 39560 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 39561 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 39562 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26617 | 39563 | } }, |
| 26618 | 39564 | }, .{ |
| 26619 | 39565 | .required_features = .{ .avx, null, null, null }, |
| 26620 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26621 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39566 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39567 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39568 | .patterns = &.{ |
| 39569 | .{ .src = .{ .mem, .none, .none } }, |
| 39570 | .{ .src = .{ .to_sse, .none, .none } }, |
| 39571 | }, |
| 39572 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39573 | .each = .{ .once = &.{ |
| 39574 | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 39575 | } }, |
| 39576 | }, .{ |
| 39577 | .required_features = .{ .avx, null, null, null }, |
| 39578 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39579 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39580 | .patterns = &.{ |
| 39581 | .{ .src = .{ .mem, .none, .none } }, |
| 39582 | .{ .src = .{ .to_sse, .none, .none } }, |
| 39583 | }, |
| 39584 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39585 | .each = .{ .once = &.{ |
| 39586 | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 39587 | } }, |
| 39588 | }, .{ |
| 39589 | .required_features = .{ .sse4_1, null, null, null }, |
| 39590 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39591 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39592 | .patterns = &.{ |
| 39593 | .{ .src = .{ .mem, .none, .none } }, |
| 39594 | .{ .src = .{ .to_sse, .none, .none } }, |
| 39595 | }, |
| 39596 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39597 | .each = .{ .once = &.{ |
| 39598 | .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 39599 | } }, |
| 39600 | }, .{ |
| 39601 | .required_features = .{ .sse4_1, null, null, null }, |
| 39602 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39603 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39604 | .patterns = &.{ |
| 39605 | .{ .src = .{ .mem, .none, .none } }, |
| 39606 | .{ .src = .{ .to_sse, .none, .none } }, |
| 39607 | }, |
| 39608 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39609 | .each = .{ .once = &.{ |
| 39610 | .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 39611 | } }, |
| 39612 | }, .{ |
| 39613 | .required_features = .{ .sse2, null, null, null }, |
| 39614 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39615 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 39616 | .patterns = &.{ |
| 39617 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 39618 | }, |
| 39619 | .extra_temps = .{ |
| 39620 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 39621 | .unused, |
| 39622 | .unused, |
| 39623 | .unused, |
| 39624 | .unused, |
| 39625 | .unused, |
| 39626 | .unused, |
| 39627 | .unused, |
| 39628 | .unused, |
| 39629 | }, |
| 39630 | .dst_temps = .{.{ .ref = .src0 }}, |
| 39631 | .each = .{ .once = &.{ |
| 39632 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 39633 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 39634 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 39635 | } }, |
| 39636 | }, .{ |
| 39637 | .required_features = .{ .sse2, null, null, null }, |
| 39638 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39639 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39640 | .patterns = &.{ |
| 39641 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 39642 | }, |
| 39643 | .extra_temps = .{ |
| 39644 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 39645 | .unused, |
| 39646 | .unused, |
| 39647 | .unused, |
| 39648 | .unused, |
| 39649 | .unused, |
| 39650 | .unused, |
| 39651 | .unused, |
| 39652 | .unused, |
| 39653 | }, |
| 39654 | .dst_temps = .{.{ .ref = .src0 }}, |
| 39655 | .each = .{ .once = &.{ |
| 39656 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 39657 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 39658 | } }, |
| 39659 | }, .{ |
| 39660 | .required_features = .{ .avx2, null, null, null }, |
| 39661 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 39662 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 39663 | .patterns = &.{ |
| 39664 | .{ .src = .{ .mem, .none, .none } }, |
| 39665 | .{ .src = .{ .to_sse, .none, .none } }, |
| 39666 | }, |
| 39667 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39668 | .each = .{ .once = &.{ |
| 39669 | .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ }, |
| 39670 | } }, |
| 39671 | }, .{ |
| 39672 | .required_features = .{ .avx2, null, null, null }, |
| 39673 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 39674 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 39675 | .patterns = &.{ |
| 39676 | .{ .src = .{ .mem, .none, .none } }, |
| 39677 | .{ .src = .{ .to_sse, .none, .none } }, |
| 39678 | }, |
| 39679 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 39680 | .each = .{ .once = &.{ |
| 39681 | .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ }, |
| 39682 | } }, |
| 39683 | }, .{ |
| 39684 | .required_features = .{ .avx2, null, null, null }, |
| 39685 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 39686 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 26622 | 39687 | .patterns = &.{ |
| 26623 | | .{ .src = .{ .to_mem, .none } }, |
| 39688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26624 | 39689 | }, |
| 26625 | 39690 | .extra_temps = .{ |
| 26626 | 39691 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26627 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 39692 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 26628 | 39693 | .unused, |
| 26629 | 39694 | .unused, |
| 26630 | 39695 | .unused, |
| ... | ... | @@ -26637,21 +39702,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26637 | 39702 | .clobbers = .{ .eflags = true }, |
| 26638 | 39703 | .each = .{ .once = &.{ |
| 26639 | 39704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26640 | | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26641 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26642 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 39705 | .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39706 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 39707 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 26643 | 39708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26644 | 39709 | } }, |
| 26645 | 39710 | }, .{ |
| 26646 | | .required_features = .{ .avx, null, null, null }, |
| 26647 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 26648 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 39711 | .required_features = .{ .avx2, null, null, null }, |
| 39712 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 39713 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 26649 | 39714 | .patterns = &.{ |
| 26650 | | .{ .src = .{ .to_mem, .none } }, |
| 39715 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26651 | 39716 | }, |
| 26652 | 39717 | .extra_temps = .{ |
| 26653 | 39718 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26654 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 39719 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 26655 | 39720 | .unused, |
| 26656 | 39721 | .unused, |
| 26657 | 39722 | .unused, |
| ... | ... | @@ -26664,17 +39729,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26664 | 39729 | .clobbers = .{ .eflags = true }, |
| 26665 | 39730 | .each = .{ .once = &.{ |
| 26666 | 39731 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26667 | | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26668 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26669 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 39732 | .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39733 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 39734 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 26670 | 39735 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26671 | 39736 | } }, |
| 26672 | 39737 | }, .{ |
| 26673 | | .required_features = .{ .sse4_1, null, null, null }, |
| 26674 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 39738 | .required_features = .{ .avx, null, null, null }, |
| 39739 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26675 | 39740 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 26676 | 39741 | .patterns = &.{ |
| 26677 | | .{ .src = .{ .to_mem, .none } }, |
| 39742 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26678 | 39743 | }, |
| 26679 | 39744 | .extra_temps = .{ |
| 26680 | 39745 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -26691,17 +39756,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26691 | 39756 | .clobbers = .{ .eflags = true }, |
| 26692 | 39757 | .each = .{ .once = &.{ |
| 26693 | 39758 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26694 | | .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26695 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26696 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 39759 | .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39760 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39761 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26697 | 39762 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26698 | 39763 | } }, |
| 26699 | 39764 | }, .{ |
| 26700 | | .required_features = .{ .sse4_1, null, null, null }, |
| 26701 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 39765 | .required_features = .{ .avx, null, null, null }, |
| 39766 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26702 | 39767 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 26703 | 39768 | .patterns = &.{ |
| 26704 | | .{ .src = .{ .to_mem, .none } }, |
| 39769 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26705 | 39770 | }, |
| 26706 | 39771 | .extra_temps = .{ |
| 26707 | 39772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -26718,21 +39783,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26718 | 39783 | .clobbers = .{ .eflags = true }, |
| 26719 | 39784 | .each = .{ .once = &.{ |
| 26720 | 39785 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26721 | | .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26722 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26723 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 39786 | .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39787 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39788 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26724 | 39789 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26725 | 39790 | } }, |
| 26726 | 39791 | }, .{ |
| 26727 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 26728 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26729 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 39792 | .required_features = .{ .sse4_1, null, null, null }, |
| 39793 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39794 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 26730 | 39795 | .patterns = &.{ |
| 26731 | | .{ .src = .{ .to_mem, .none } }, |
| 39796 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26732 | 39797 | }, |
| 26733 | 39798 | .extra_temps = .{ |
| 26734 | 39799 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26735 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 39800 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 26736 | 39801 | .unused, |
| 26737 | 39802 | .unused, |
| 26738 | 39803 | .unused, |
| ... | ... | @@ -26745,20 +39810,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26745 | 39810 | .clobbers = .{ .eflags = true }, |
| 26746 | 39811 | .each = .{ .once = &.{ |
| 26747 | 39812 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26748 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26749 | | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26750 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 39813 | .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39814 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39815 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26751 | 39816 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26752 | 39817 | } }, |
| 26753 | 39818 | }, .{ |
| 26754 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26755 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 39819 | .required_features = .{ .sse4_1, null, null, null }, |
| 39820 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 39821 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 26756 | 39822 | .patterns = &.{ |
| 26757 | | .{ .src = .{ .to_mem, .none } }, |
| 39823 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26758 | 39824 | }, |
| 26759 | 39825 | .extra_temps = .{ |
| 26760 | 39826 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26761 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 39827 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 26762 | 39828 | .unused, |
| 26763 | 39829 | .unused, |
| 26764 | 39830 | .unused, |
| ... | ... | @@ -26771,21 +39837,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26771 | 39837 | .clobbers = .{ .eflags = true }, |
| 26772 | 39838 | .each = .{ .once = &.{ |
| 26773 | 39839 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26774 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26775 | | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26776 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26777 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 39840 | .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39841 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 39842 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 39843 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26778 | 39844 | } }, |
| 26779 | 39845 | }, .{ |
| 26780 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 26781 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 26782 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 39846 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 39847 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 26783 | 39848 | .patterns = &.{ |
| 26784 | | .{ .src = .{ .to_mem, .none } }, |
| 39849 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26785 | 39850 | }, |
| 26786 | 39851 | .extra_temps = .{ |
| 26787 | 39852 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26788 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 39853 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 26789 | 39854 | .unused, |
| 26790 | 39855 | .unused, |
| 26791 | 39856 | .unused, |
| ... | ... | @@ -26798,16 +39863,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26798 | 39863 | .clobbers = .{ .eflags = true }, |
| 26799 | 39864 | .each = .{ .once = &.{ |
| 26800 | 39865 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26801 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26802 | | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26803 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 39866 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39867 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 39868 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26804 | 39869 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26805 | 39870 | } }, |
| 26806 | 39871 | }, .{ |
| 26807 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 39872 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 26808 | 39873 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 26809 | 39874 | .patterns = &.{ |
| 26810 | | .{ .src = .{ .to_mem, .none } }, |
| 39875 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26811 | 39876 | }, |
| 26812 | 39877 | .extra_temps = .{ |
| 26813 | 39878 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -26824,68 +39889,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26824 | 39889 | .clobbers = .{ .eflags = true }, |
| 26825 | 39890 | .each = .{ .once = &.{ |
| 26826 | 39891 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26827 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26828 | | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26829 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26830 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 39892 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 39893 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 39894 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 39895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26831 | 39896 | } }, |
| 26832 | 39897 | }, .{ |
| 26833 | 39898 | .required_features = .{ .avx, null, null, null }, |
| 26834 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any }, |
| 39899 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 26835 | 39900 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26836 | 39901 | .patterns = &.{ |
| 26837 | | .{ .src = .{ .mem, .none } }, |
| 26838 | | .{ .src = .{ .to_sse, .none } }, |
| 39902 | .{ .src = .{ .mem, .none, .none } }, |
| 39903 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26839 | 39904 | }, |
| 26840 | 39905 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26841 | 39906 | .each = .{ .once = &.{ |
| 26842 | | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 39907 | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 26843 | 39908 | } }, |
| 26844 | 39909 | }, .{ |
| 26845 | 39910 | .required_features = .{ .avx, null, null, null }, |
| 26846 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any }, |
| 39911 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 26847 | 39912 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26848 | 39913 | .patterns = &.{ |
| 26849 | | .{ .src = .{ .mem, .none } }, |
| 26850 | | .{ .src = .{ .to_sse, .none } }, |
| 39914 | .{ .src = .{ .mem, .none, .none } }, |
| 39915 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26851 | 39916 | }, |
| 26852 | 39917 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26853 | 39918 | .each = .{ .once = &.{ |
| 26854 | | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 39919 | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 26855 | 39920 | } }, |
| 26856 | 39921 | }, .{ |
| 26857 | 39922 | .required_features = .{ .sse4_1, null, null, null }, |
| 26858 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any }, |
| 39923 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 26859 | 39924 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26860 | 39925 | .patterns = &.{ |
| 26861 | | .{ .src = .{ .mem, .none } }, |
| 26862 | | .{ .src = .{ .to_sse, .none } }, |
| 39926 | .{ .src = .{ .mem, .none, .none } }, |
| 39927 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26863 | 39928 | }, |
| 26864 | 39929 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26865 | 39930 | .each = .{ .once = &.{ |
| 26866 | | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 39931 | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 26867 | 39932 | } }, |
| 26868 | 39933 | }, .{ |
| 26869 | 39934 | .required_features = .{ .sse4_1, null, null, null }, |
| 26870 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any }, |
| 39935 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 26871 | 39936 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26872 | 39937 | .patterns = &.{ |
| 26873 | | .{ .src = .{ .mem, .none } }, |
| 26874 | | .{ .src = .{ .to_sse, .none } }, |
| 39938 | .{ .src = .{ .mem, .none, .none } }, |
| 39939 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26875 | 39940 | }, |
| 26876 | 39941 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26877 | 39942 | .each = .{ .once = &.{ |
| 26878 | | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 39943 | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 26879 | 39944 | } }, |
| 26880 | 39945 | }, .{ |
| 26881 | 39946 | .required_features = .{ .sse2, null, null, null }, |
| 26882 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any }, |
| 39947 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 26883 | 39948 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26884 | 39949 | .patterns = &.{ |
| 26885 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 39950 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26886 | 39951 | }, |
| 26887 | 39952 | .extra_temps = .{ |
| 26888 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 39953 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 26889 | 39954 | .unused, |
| 26890 | 39955 | .unused, |
| 26891 | 39956 | .unused, |
| ... | ... | @@ -26898,22 +39963,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26898 | 39963 | .dst_temps = .{.{ .ref = .src0 }}, |
| 26899 | 39964 | .each = .{ .once = &.{ |
| 26900 | 39965 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26901 | | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 26902 | | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 26903 | | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 39966 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 26904 | 39967 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 26905 | 39968 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 26906 | 39969 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26907 | 39970 | } }, |
| 26908 | 39971 | }, .{ |
| 26909 | 39972 | .required_features = .{ .sse2, null, null, null }, |
| 26910 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any }, |
| 39973 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 26911 | 39974 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26912 | 39975 | .patterns = &.{ |
| 26913 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 39976 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26914 | 39977 | }, |
| 26915 | 39978 | .extra_temps = .{ |
| 26916 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 39979 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 26917 | 39980 | .unused, |
| 26918 | 39981 | .unused, |
| 26919 | 39982 | .unused, |
| ... | ... | @@ -26926,40 +39989,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26926 | 39989 | .dst_temps = .{.{ .ref = .src0 }}, |
| 26927 | 39990 | .each = .{ .once = &.{ |
| 26928 | 39991 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26929 | | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 26930 | 39992 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 26931 | 39993 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26932 | 39994 | } }, |
| 26933 | 39995 | }, .{ |
| 26934 | 39996 | .required_features = .{ .avx2, null, null, null }, |
| 26935 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 39997 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26936 | 39998 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26937 | 39999 | .patterns = &.{ |
| 26938 | | .{ .src = .{ .mem, .none } }, |
| 26939 | | .{ .src = .{ .to_sse, .none } }, |
| 40000 | .{ .src = .{ .mem, .none, .none } }, |
| 40001 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26940 | 40002 | }, |
| 26941 | 40003 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26942 | 40004 | .each = .{ .once = &.{ |
| 26943 | | .{ ._, .vp_q, .movsxb, .dst0y, .src0d, ._, ._ }, |
| 40005 | .{ ._, .vp_q, .movsxw, .dst0y, .src0q, ._, ._ }, |
| 26944 | 40006 | } }, |
| 26945 | 40007 | }, .{ |
| 26946 | 40008 | .required_features = .{ .avx2, null, null, null }, |
| 26947 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 40009 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26948 | 40010 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26949 | 40011 | .patterns = &.{ |
| 26950 | | .{ .src = .{ .mem, .none } }, |
| 26951 | | .{ .src = .{ .to_sse, .none } }, |
| 40012 | .{ .src = .{ .mem, .none, .none } }, |
| 40013 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26952 | 40014 | }, |
| 26953 | 40015 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26954 | 40016 | .each = .{ .once = &.{ |
| 26955 | | .{ ._, .vp_q, .movzxb, .dst0y, .src0d, ._, ._ }, |
| 40017 | .{ ._, .vp_q, .movzxw, .dst0y, .src0q, ._, ._ }, |
| 26956 | 40018 | } }, |
| 26957 | 40019 | }, .{ |
| 26958 | 40020 | .required_features = .{ .avx2, null, null, null }, |
| 26959 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 40021 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26960 | 40022 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26961 | 40023 | .patterns = &.{ |
| 26962 | | .{ .src = .{ .to_mem, .none } }, |
| 40024 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26963 | 40025 | }, |
| 26964 | 40026 | .extra_temps = .{ |
| 26965 | 40027 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -26976,17 +40038,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26976 | 40038 | .clobbers = .{ .eflags = true }, |
| 26977 | 40039 | .each = .{ .once = &.{ |
| 26978 | 40040 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26979 | | .{ .@"0:", .vp_q, .movsxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26980 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26981 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 40041 | .{ .@"0:", .vp_q, .movsxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40042 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 40043 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26982 | 40044 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26983 | 40045 | } }, |
| 26984 | 40046 | }, .{ |
| 26985 | 40047 | .required_features = .{ .avx2, null, null, null }, |
| 26986 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any }, |
| 40048 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26987 | 40049 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26988 | 40050 | .patterns = &.{ |
| 26989 | | .{ .src = .{ .to_mem, .none } }, |
| 40051 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26990 | 40052 | }, |
| 26991 | 40053 | .extra_temps = .{ |
| 26992 | 40054 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27003,17 +40065,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27003 | 40065 | .clobbers = .{ .eflags = true }, |
| 27004 | 40066 | .each = .{ .once = &.{ |
| 27005 | 40067 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27006 | | .{ .@"0:", .vp_q, .movzxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27007 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27008 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 40068 | .{ .@"0:", .vp_q, .movzxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40069 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 40070 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27009 | 40071 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27010 | 40072 | } }, |
| 27011 | 40073 | }, .{ |
| 27012 | 40074 | .required_features = .{ .avx, null, null, null }, |
| 27013 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any }, |
| 40075 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 27014 | 40076 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27015 | 40077 | .patterns = &.{ |
| 27016 | | .{ .src = .{ .to_mem, .none } }, |
| 40078 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27017 | 40079 | }, |
| 27018 | 40080 | .extra_temps = .{ |
| 27019 | 40081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27030,17 +40092,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27030 | 40092 | .clobbers = .{ .eflags = true }, |
| 27031 | 40093 | .each = .{ .once = &.{ |
| 27032 | 40094 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27033 | | .{ .@"0:", .vp_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27034 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27035 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40095 | .{ .@"0:", .vp_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40096 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 40097 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27036 | 40098 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27037 | 40099 | } }, |
| 27038 | 40100 | }, .{ |
| 27039 | 40101 | .required_features = .{ .avx, null, null, null }, |
| 27040 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any }, |
| 40102 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 27041 | 40103 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27042 | 40104 | .patterns = &.{ |
| 27043 | | .{ .src = .{ .to_mem, .none } }, |
| 40105 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27044 | 40106 | }, |
| 27045 | 40107 | .extra_temps = .{ |
| 27046 | 40108 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27057,17 +40119,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27057 | 40119 | .clobbers = .{ .eflags = true }, |
| 27058 | 40120 | .each = .{ .once = &.{ |
| 27059 | 40121 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27060 | | .{ .@"0:", .vp_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27061 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27062 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40122 | .{ .@"0:", .vp_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40123 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 40124 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27063 | 40125 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27064 | 40126 | } }, |
| 27065 | 40127 | }, .{ |
| 27066 | 40128 | .required_features = .{ .sse4_1, null, null, null }, |
| 27067 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any }, |
| 40129 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 27068 | 40130 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27069 | 40131 | .patterns = &.{ |
| 27070 | | .{ .src = .{ .to_mem, .none } }, |
| 40132 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27071 | 40133 | }, |
| 27072 | 40134 | .extra_temps = .{ |
| 27073 | 40135 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27084,17 +40146,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27084 | 40146 | .clobbers = .{ .eflags = true }, |
| 27085 | 40147 | .each = .{ .once = &.{ |
| 27086 | 40148 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27087 | | .{ .@"0:", .p_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27088 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27089 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40149 | .{ .@"0:", .p_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40150 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 40151 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27090 | 40152 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27091 | 40153 | } }, |
| 27092 | 40154 | }, .{ |
| 27093 | 40155 | .required_features = .{ .sse4_1, null, null, null }, |
| 27094 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any }, |
| 40156 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 27095 | 40157 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27096 | 40158 | .patterns = &.{ |
| 27097 | | .{ .src = .{ .to_mem, .none } }, |
| 40159 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27098 | 40160 | }, |
| 27099 | 40161 | .extra_temps = .{ |
| 27100 | 40162 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27111,44 +40173,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27111 | 40173 | .clobbers = .{ .eflags = true }, |
| 27112 | 40174 | .each = .{ .once = &.{ |
| 27113 | 40175 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27114 | | .{ .@"0:", .p_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27115 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27116 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27117 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27118 | | } }, |
| 27119 | | }, .{ |
| 27120 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 27121 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 27122 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 27123 | | .patterns = &.{ |
| 27124 | | .{ .src = .{ .to_mem, .none } }, |
| 27125 | | }, |
| 27126 | | .extra_temps = .{ |
| 27127 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27128 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 27129 | | .unused, |
| 27130 | | .unused, |
| 27131 | | .unused, |
| 27132 | | .unused, |
| 27133 | | .unused, |
| 27134 | | .unused, |
| 27135 | | .unused, |
| 27136 | | }, |
| 27137 | | .dst_temps = .{.mem}, |
| 27138 | | .clobbers = .{ .eflags = true }, |
| 27139 | | .each = .{ .once = &.{ |
| 27140 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27141 | | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27142 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27143 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 40176 | .{ .@"0:", .p_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40177 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 40178 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27144 | 40179 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27145 | 40180 | } }, |
| 27146 | 40181 | }, .{ |
| 27147 | 40182 | .required_features = .{ .@"64bit", null, null, null }, |
| 27148 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40183 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27149 | 40184 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 27150 | 40185 | .patterns = &.{ |
| 27151 | | .{ .src = .{ .to_mem, .none } }, |
| 40186 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27152 | 40187 | }, |
| 27153 | 40188 | .extra_temps = .{ |
| 27154 | 40189 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27164,48 +40199,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27164 | 40199 | .dst_temps = .{.mem}, |
| 27165 | 40200 | .clobbers = .{ .eflags = true }, |
| 27166 | 40201 | .each = .{ .once = &.{ |
| 27167 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27168 | | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27169 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27170 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 27171 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 27172 | | } }, |
| 27173 | | }, .{ |
| 27174 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 27175 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 27176 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 27177 | | .patterns = &.{ |
| 27178 | | .{ .src = .{ .to_mem, .none } }, |
| 27179 | | }, |
| 27180 | | .extra_temps = .{ |
| 27181 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27182 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 27183 | | .unused, |
| 27184 | | .unused, |
| 27185 | | .unused, |
| 27186 | | .unused, |
| 27187 | | .unused, |
| 27188 | | .unused, |
| 27189 | | .unused, |
| 27190 | | }, |
| 27191 | | .dst_temps = .{.mem}, |
| 27192 | | .clobbers = .{ .eflags = true }, |
| 27193 | | .each = .{ .once = &.{ |
| 27194 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27195 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27196 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27197 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 40202 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 40203 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40204 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 40205 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27198 | 40206 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27199 | 40207 | } }, |
| 27200 | 40208 | }, .{ |
| 27201 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40209 | .required_features = .{ .@"64bit", null, null, null }, |
| 40210 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27202 | 40211 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 27203 | 40212 | .patterns = &.{ |
| 27204 | | .{ .src = .{ .to_mem, .none } }, |
| 40213 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27205 | 40214 | }, |
| 27206 | 40215 | .extra_temps = .{ |
| 27207 | 40216 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27208 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 40217 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 27209 | 40218 | .unused, |
| 27210 | 40219 | .unused, |
| 27211 | 40220 | .unused, |
| ... | ... | @@ -27218,72 +40227,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27218 | 40227 | .clobbers = .{ .eflags = true }, |
| 27219 | 40228 | .each = .{ .once = &.{ |
| 27220 | 40229 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27221 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27222 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27223 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 27224 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 40230 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40231 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 40232 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40233 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27225 | 40234 | } }, |
| 27226 | 40235 | }, .{ |
| 27227 | 40236 | .required_features = .{ .avx, null, null, null }, |
| 27228 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40237 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27229 | 40238 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27230 | 40239 | .patterns = &.{ |
| 27231 | | .{ .src = .{ .mem, .none } }, |
| 27232 | | .{ .src = .{ .to_sse, .none } }, |
| 40240 | .{ .src = .{ .mem, .none, .none } }, |
| 40241 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27233 | 40242 | }, |
| 27234 | 40243 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27235 | 40244 | .each = .{ .once = &.{ |
| 27236 | | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 40245 | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 27237 | 40246 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 27238 | 40247 | } }, |
| 27239 | 40248 | }, .{ |
| 27240 | 40249 | .required_features = .{ .avx, null, null, null }, |
| 27241 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40250 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27242 | 40251 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27243 | 40252 | .patterns = &.{ |
| 27244 | | .{ .src = .{ .mem, .none } }, |
| 27245 | | .{ .src = .{ .to_sse, .none } }, |
| 40253 | .{ .src = .{ .mem, .none, .none } }, |
| 40254 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27246 | 40255 | }, |
| 27247 | 40256 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27248 | 40257 | .each = .{ .once = &.{ |
| 27249 | | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 40258 | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 27250 | 40259 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 27251 | 40260 | } }, |
| 27252 | 40261 | }, .{ |
| 27253 | 40262 | .required_features = .{ .sse4_1, null, null, null }, |
| 27254 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40263 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27255 | 40264 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27256 | 40265 | .patterns = &.{ |
| 27257 | | .{ .src = .{ .mem, .none } }, |
| 27258 | | .{ .src = .{ .to_sse, .none } }, |
| 40266 | .{ .src = .{ .mem, .none, .none } }, |
| 40267 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27259 | 40268 | }, |
| 27260 | 40269 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27261 | 40270 | .each = .{ .once = &.{ |
| 27262 | | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 40271 | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 27263 | 40272 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 27264 | 40273 | } }, |
| 27265 | 40274 | }, .{ |
| 27266 | 40275 | .required_features = .{ .sse4_1, null, null, null }, |
| 27267 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40276 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27268 | 40277 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27269 | 40278 | .patterns = &.{ |
| 27270 | | .{ .src = .{ .mem, .none } }, |
| 27271 | | .{ .src = .{ .to_sse, .none } }, |
| 40279 | .{ .src = .{ .mem, .none, .none } }, |
| 40280 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27272 | 40281 | }, |
| 27273 | 40282 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27274 | 40283 | .each = .{ .once = &.{ |
| 27275 | | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 40284 | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 27276 | 40285 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 27277 | 40286 | } }, |
| 27278 | 40287 | }, .{ |
| 27279 | 40288 | .required_features = .{ .sse2, null, null, null }, |
| 27280 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40289 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27281 | 40290 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27282 | 40291 | .patterns = &.{ |
| 27283 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 40292 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27284 | 40293 | }, |
| 27285 | 40294 | .extra_temps = .{ |
| 27286 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 40295 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 27287 | 40296 | .unused, |
| 27288 | 40297 | .unused, |
| 27289 | 40298 | .unused, |
| ... | ... | @@ -27296,9 +40305,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27296 | 40305 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27297 | 40306 | .each = .{ .once = &.{ |
| 27298 | 40307 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27299 | | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27300 | | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 27301 | | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 40308 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27302 | 40309 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 27303 | 40310 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 27304 | 40311 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| ... | ... | @@ -27307,13 +40314,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27307 | 40314 | } }, |
| 27308 | 40315 | }, .{ |
| 27309 | 40316 | .required_features = .{ .sse2, null, null, null }, |
| 27310 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40317 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27311 | 40318 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27312 | 40319 | .patterns = &.{ |
| 27313 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 40320 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27314 | 40321 | }, |
| 27315 | 40322 | .extra_temps = .{ |
| 27316 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 40323 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 27317 | 40324 | .unused, |
| 27318 | 40325 | .unused, |
| 27319 | 40326 | .unused, |
| ... | ... | @@ -27326,48 +40333,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27326 | 40333 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27327 | 40334 | .each = .{ .once = &.{ |
| 27328 | 40335 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27329 | | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 27330 | 40336 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 27331 | 40337 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 27332 | 40338 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 27333 | 40339 | } }, |
| 27334 | | }, .{ |
| 27335 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 27336 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 27337 | | .dst_constraints = .{.any_scalar_signed_int}, |
| 27338 | | .patterns = &.{ |
| 27339 | | .{ .src = .{ .to_mem, .none } }, |
| 27340 | | }, |
| 27341 | | .extra_temps = .{ |
| 27342 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27343 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 27344 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 27345 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27346 | | .unused, |
| 27347 | | .unused, |
| 27348 | | .unused, |
| 27349 | | .unused, |
| 27350 | | .unused, |
| 27351 | | }, |
| 27352 | | .dst_temps = .{.mem}, |
| 27353 | | .clobbers = .{ .eflags = true }, |
| 27354 | | .each = .{ .once = &.{ |
| 27355 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27356 | | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 27357 | | .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27358 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 27359 | | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 27360 | | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 27361 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 27362 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 27363 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27364 | | } }, |
| 27365 | 40340 | }, .{ |
| 27366 | 40341 | .required_features = .{ .@"64bit", null, null, null }, |
| 27367 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40342 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27368 | 40343 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27369 | 40344 | .patterns = &.{ |
| 27370 | | .{ .src = .{ .to_mem, .none } }, |
| 40345 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27371 | 40346 | }, |
| 27372 | 40347 | .extra_temps = .{ |
| 27373 | 40348 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27385,51 +40360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27385 | 40360 | .each = .{ .once = &.{ |
| 27386 | 40361 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27387 | 40362 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 27388 | | .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40363 | .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27389 | 40364 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 27390 | 40365 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 27391 | 40366 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 27392 | 40367 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 27393 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 27394 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 27395 | | } }, |
| 27396 | | }, .{ |
| 27397 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 27398 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 27399 | | .dst_constraints = .{.any_scalar_int}, |
| 27400 | | .patterns = &.{ |
| 27401 | | .{ .src = .{ .to_mem, .none } }, |
| 27402 | | }, |
| 27403 | | .extra_temps = .{ |
| 27404 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27405 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 27406 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 27407 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27408 | | .unused, |
| 27409 | | .unused, |
| 27410 | | .unused, |
| 27411 | | .unused, |
| 27412 | | .unused, |
| 27413 | | }, |
| 27414 | | .dst_temps = .{.mem}, |
| 27415 | | .clobbers = .{ .eflags = true }, |
| 27416 | | .each = .{ .once = &.{ |
| 27417 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27418 | | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 27419 | | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27420 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 27421 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 27422 | | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 27423 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 27424 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 40368 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27425 | 40369 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27426 | 40370 | } }, |
| 27427 | 40371 | }, .{ |
| 27428 | 40372 | .required_features = .{ .@"64bit", null, null, null }, |
| 27429 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 40373 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 27430 | 40374 | .dst_constraints = .{.any_scalar_int}, |
| 27431 | 40375 | .patterns = &.{ |
| 27432 | | .{ .src = .{ .to_mem, .none } }, |
| 40376 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27433 | 40377 | }, |
| 27434 | 40378 | .extra_temps = .{ |
| 27435 | 40379 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -27447,71 +40391,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27447 | 40391 | .each = .{ .once = &.{ |
| 27448 | 40392 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27449 | 40393 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 27450 | | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40394 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27451 | 40395 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 27452 | 40396 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 27453 | 40397 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 27454 | 40398 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 27455 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 27456 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 40399 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40400 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27457 | 40401 | } }, |
| 27458 | 40402 | }, .{ |
| 27459 | 40403 | .required_features = .{ .avx, null, null, null }, |
| 27460 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27461 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 40404 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40405 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27462 | 40406 | .patterns = &.{ |
| 27463 | | .{ .src = .{ .mem, .none } }, |
| 27464 | | .{ .src = .{ .to_sse, .none } }, |
| 40407 | .{ .src = .{ .mem, .none, .none } }, |
| 40408 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27465 | 40409 | }, |
| 27466 | 40410 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27467 | 40411 | .each = .{ .once = &.{ |
| 27468 | | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 40412 | .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 27469 | 40413 | } }, |
| 27470 | 40414 | }, .{ |
| 27471 | 40415 | .required_features = .{ .avx, null, null, null }, |
| 27472 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27473 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 40416 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40417 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27474 | 40418 | .patterns = &.{ |
| 27475 | | .{ .src = .{ .mem, .none } }, |
| 27476 | | .{ .src = .{ .to_sse, .none } }, |
| 40419 | .{ .src = .{ .mem, .none, .none } }, |
| 40420 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27477 | 40421 | }, |
| 27478 | 40422 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27479 | 40423 | .each = .{ .once = &.{ |
| 27480 | | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 40424 | .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 27481 | 40425 | } }, |
| 27482 | 40426 | }, .{ |
| 27483 | 40427 | .required_features = .{ .sse4_1, null, null, null }, |
| 27484 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27485 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 40428 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40429 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27486 | 40430 | .patterns = &.{ |
| 27487 | | .{ .src = .{ .mem, .none } }, |
| 27488 | | .{ .src = .{ .to_sse, .none } }, |
| 40431 | .{ .src = .{ .mem, .none, .none } }, |
| 40432 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27489 | 40433 | }, |
| 27490 | 40434 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27491 | 40435 | .each = .{ .once = &.{ |
| 27492 | | .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 40436 | .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 27493 | 40437 | } }, |
| 27494 | 40438 | }, .{ |
| 27495 | 40439 | .required_features = .{ .sse4_1, null, null, null }, |
| 27496 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27497 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 40440 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40441 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27498 | 40442 | .patterns = &.{ |
| 27499 | | .{ .src = .{ .mem, .none } }, |
| 27500 | | .{ .src = .{ .to_sse, .none } }, |
| 40443 | .{ .src = .{ .mem, .none, .none } }, |
| 40444 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27501 | 40445 | }, |
| 27502 | 40446 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27503 | 40447 | .each = .{ .once = &.{ |
| 27504 | | .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 40448 | .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 27505 | 40449 | } }, |
| 27506 | 40450 | }, .{ |
| 27507 | 40451 | .required_features = .{ .sse2, null, null, null }, |
| 27508 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27509 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 40452 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40453 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27510 | 40454 | .patterns = &.{ |
| 27511 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 40455 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27512 | 40456 | }, |
| 27513 | 40457 | .extra_temps = .{ |
| 27514 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 40458 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 27515 | 40459 | .unused, |
| 27516 | 40460 | .unused, |
| 27517 | 40461 | .unused, |
| ... | ... | @@ -27524,18 +40468,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27524 | 40468 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27525 | 40469 | .each = .{ .once = &.{ |
| 27526 | 40470 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27527 | | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27528 | | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 40471 | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 40472 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 27529 | 40473 | } }, |
| 27530 | 40474 | }, .{ |
| 27531 | 40475 | .required_features = .{ .sse2, null, null, null }, |
| 27532 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27533 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 40476 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40477 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27534 | 40478 | .patterns = &.{ |
| 27535 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 40479 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27536 | 40480 | }, |
| 27537 | 40481 | .extra_temps = .{ |
| 27538 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 40482 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 27539 | 40483 | .unused, |
| 27540 | 40484 | .unused, |
| 27541 | 40485 | .unused, |
| ... | ... | @@ -27548,42 +40492,42 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27548 | 40492 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27549 | 40493 | .each = .{ .once = &.{ |
| 27550 | 40494 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27551 | | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 40495 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 27552 | 40496 | } }, |
| 27553 | 40497 | }, .{ |
| 27554 | 40498 | .required_features = .{ .avx2, null, null, null }, |
| 27555 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, |
| 27556 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 40499 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 40500 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 27557 | 40501 | .patterns = &.{ |
| 27558 | | .{ .src = .{ .mem, .none } }, |
| 27559 | | .{ .src = .{ .to_sse, .none } }, |
| 40502 | .{ .src = .{ .mem, .none, .none } }, |
| 40503 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27560 | 40504 | }, |
| 27561 | 40505 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27562 | 40506 | .each = .{ .once = &.{ |
| 27563 | | .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ }, |
| 40507 | .{ ._, .vp_q, .movsxd, .dst0y, .src0x, ._, ._ }, |
| 27564 | 40508 | } }, |
| 27565 | 40509 | }, .{ |
| 27566 | 40510 | .required_features = .{ .avx2, null, null, null }, |
| 27567 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 27568 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 40511 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 40512 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 27569 | 40513 | .patterns = &.{ |
| 27570 | | .{ .src = .{ .mem, .none } }, |
| 27571 | | .{ .src = .{ .to_sse, .none } }, |
| 40514 | .{ .src = .{ .mem, .none, .none } }, |
| 40515 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27572 | 40516 | }, |
| 27573 | 40517 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27574 | 40518 | .each = .{ .once = &.{ |
| 27575 | | .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ }, |
| 40519 | .{ ._, .vp_q, .movzxd, .dst0y, .src0x, ._, ._ }, |
| 27576 | 40520 | } }, |
| 27577 | 40521 | }, .{ |
| 27578 | 40522 | .required_features = .{ .avx2, null, null, null }, |
| 27579 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, |
| 27580 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 40523 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 40524 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 27581 | 40525 | .patterns = &.{ |
| 27582 | | .{ .src = .{ .to_mem, .none } }, |
| 40526 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27583 | 40527 | }, |
| 27584 | 40528 | .extra_temps = .{ |
| 27585 | 40529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27586 | | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 40530 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 27587 | 40531 | .unused, |
| 27588 | 40532 | .unused, |
| 27589 | 40533 | .unused, |
| ... | ... | @@ -27596,21 +40540,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27596 | 40540 | .clobbers = .{ .eflags = true }, |
| 27597 | 40541 | .each = .{ .once = &.{ |
| 27598 | 40542 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27599 | | .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40543 | .{ .@"0:", .vp_q, .movsxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27600 | 40544 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27601 | 40545 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 27602 | 40546 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27603 | 40547 | } }, |
| 27604 | 40548 | }, .{ |
| 27605 | 40549 | .required_features = .{ .avx2, null, null, null }, |
| 27606 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any }, |
| 27607 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 40550 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 40551 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 27608 | 40552 | .patterns = &.{ |
| 27609 | | .{ .src = .{ .to_mem, .none } }, |
| 40553 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27610 | 40554 | }, |
| 27611 | 40555 | .extra_temps = .{ |
| 27612 | 40556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27613 | | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 40557 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 27614 | 40558 | .unused, |
| 27615 | 40559 | .unused, |
| 27616 | 40560 | .unused, |
| ... | ... | @@ -27623,21 +40567,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27623 | 40567 | .clobbers = .{ .eflags = true }, |
| 27624 | 40568 | .each = .{ .once = &.{ |
| 27625 | 40569 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27626 | | .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40570 | .{ .@"0:", .vp_q, .movzxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27627 | 40571 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27628 | 40572 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 27629 | 40573 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27630 | 40574 | } }, |
| 27631 | 40575 | }, .{ |
| 27632 | 40576 | .required_features = .{ .avx, null, null, null }, |
| 27633 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27634 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 40577 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40578 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27635 | 40579 | .patterns = &.{ |
| 27636 | | .{ .src = .{ .to_mem, .none } }, |
| 40580 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27637 | 40581 | }, |
| 27638 | 40582 | .extra_temps = .{ |
| 27639 | 40583 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27640 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 40584 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 27641 | 40585 | .unused, |
| 27642 | 40586 | .unused, |
| 27643 | 40587 | .unused, |
| ... | ... | @@ -27650,21 +40594,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27650 | 40594 | .clobbers = .{ .eflags = true }, |
| 27651 | 40595 | .each = .{ .once = &.{ |
| 27652 | 40596 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27653 | | .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40597 | .{ .@"0:", .vp_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27654 | 40598 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27655 | 40599 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27656 | 40600 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27657 | 40601 | } }, |
| 27658 | 40602 | }, .{ |
| 27659 | 40603 | .required_features = .{ .avx, null, null, null }, |
| 27660 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27661 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 40604 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 40605 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27662 | 40606 | .patterns = &.{ |
| 27663 | | .{ .src = .{ .to_mem, .none } }, |
| 40607 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27664 | 40608 | }, |
| 27665 | 40609 | .extra_temps = .{ |
| 27666 | 40610 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27667 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 40611 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 27668 | 40612 | .unused, |
| 27669 | 40613 | .unused, |
| 27670 | 40614 | .unused, |
| ... | ... | @@ -27677,21 +40621,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27677 | 40621 | .clobbers = .{ .eflags = true }, |
| 27678 | 40622 | .each = .{ .once = &.{ |
| 27679 | 40623 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27680 | | .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40624 | .{ .@"0:", .vp_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27681 | 40625 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27682 | 40626 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27683 | 40627 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27684 | 40628 | } }, |
| 27685 | 40629 | }, .{ |
| 27686 | 40630 | .required_features = .{ .sse4_1, null, null, null }, |
| 27687 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27688 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 40631 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40632 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27689 | 40633 | .patterns = &.{ |
| 27690 | | .{ .src = .{ .to_mem, .none } }, |
| 40634 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27691 | 40635 | }, |
| 27692 | 40636 | .extra_temps = .{ |
| 27693 | 40637 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27694 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 40638 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 27695 | 40639 | .unused, |
| 27696 | 40640 | .unused, |
| 27697 | 40641 | .unused, |
| ... | ... | @@ -27704,21 +40648,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27704 | 40648 | .clobbers = .{ .eflags = true }, |
| 27705 | 40649 | .each = .{ .once = &.{ |
| 27706 | 40650 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27707 | | .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40651 | .{ .@"0:", .p_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27708 | 40652 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27709 | 40653 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27710 | 40654 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27711 | 40655 | } }, |
| 27712 | 40656 | }, .{ |
| 27713 | 40657 | .required_features = .{ .sse4_1, null, null, null }, |
| 27714 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27715 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 40658 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 40659 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27716 | 40660 | .patterns = &.{ |
| 27717 | | .{ .src = .{ .to_mem, .none } }, |
| 40661 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27718 | 40662 | }, |
| 27719 | 40663 | .extra_temps = .{ |
| 27720 | 40664 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27721 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 40665 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 27722 | 40666 | .unused, |
| 27723 | 40667 | .unused, |
| 27724 | 40668 | .unused, |
| ... | ... | @@ -27731,20 +40675,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27731 | 40675 | .clobbers = .{ .eflags = true }, |
| 27732 | 40676 | .each = .{ .once = &.{ |
| 27733 | 40677 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27734 | | .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40678 | .{ .@"0:", .p_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27735 | 40679 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27736 | 40680 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27737 | 40681 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27738 | 40682 | } }, |
| 27739 | 40683 | }, .{ |
| 27740 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 27741 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 40684 | .required_features = .{ .@"64bit", null, null, null }, |
| 40685 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40686 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 27742 | 40687 | .patterns = &.{ |
| 27743 | | .{ .src = .{ .to_mem, .none } }, |
| 40688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27744 | 40689 | }, |
| 27745 | 40690 | .extra_temps = .{ |
| 27746 | 40691 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27747 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 40692 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 27748 | 40693 | .unused, |
| 27749 | 40694 | .unused, |
| 27750 | 40695 | .unused, |
| ... | ... | @@ -27757,20 +40702,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27757 | 40702 | .clobbers = .{ .eflags = true }, |
| 27758 | 40703 | .each = .{ .once = &.{ |
| 27759 | 40704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27760 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27761 | | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 27762 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40705 | .{ .@"0:", ._, .movsxd, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40706 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 40707 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27763 | 40708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27764 | 40709 | } }, |
| 27765 | 40710 | }, .{ |
| 27766 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 27767 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 40711 | .required_features = .{ .@"64bit", null, null, null }, |
| 40712 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40713 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 27768 | 40714 | .patterns = &.{ |
| 27769 | | .{ .src = .{ .to_mem, .none } }, |
| 40715 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27770 | 40716 | }, |
| 27771 | 40717 | .extra_temps = .{ |
| 27772 | 40718 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27773 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 40719 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 27774 | 40720 | .unused, |
| 27775 | 40721 | .unused, |
| 27776 | 40722 | .unused, |
| ... | ... | @@ -27783,68 +40729,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27783 | 40729 | .clobbers = .{ .eflags = true }, |
| 27784 | 40730 | .each = .{ .once = &.{ |
| 27785 | 40731 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27786 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27787 | | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 27788 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 40732 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40733 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 40734 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27789 | 40735 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27790 | 40736 | } }, |
| 27791 | 40737 | }, .{ |
| 27792 | 40738 | .required_features = .{ .avx, null, null, null }, |
| 27793 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27794 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 40739 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40740 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27795 | 40741 | .patterns = &.{ |
| 27796 | | .{ .src = .{ .mem, .none } }, |
| 27797 | | .{ .src = .{ .to_sse, .none } }, |
| 40742 | .{ .src = .{ .mem, .none, .none } }, |
| 40743 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27798 | 40744 | }, |
| 27799 | 40745 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27800 | 40746 | .each = .{ .once = &.{ |
| 27801 | | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 40747 | .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 40748 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 27802 | 40749 | } }, |
| 27803 | 40750 | }, .{ |
| 27804 | 40751 | .required_features = .{ .avx, null, null, null }, |
| 27805 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27806 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 40752 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40753 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27807 | 40754 | .patterns = &.{ |
| 27808 | | .{ .src = .{ .mem, .none } }, |
| 27809 | | .{ .src = .{ .to_sse, .none } }, |
| 40755 | .{ .src = .{ .mem, .none, .none } }, |
| 40756 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27810 | 40757 | }, |
| 27811 | 40758 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27812 | 40759 | .each = .{ .once = &.{ |
| 27813 | | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 40760 | .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 40761 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 27814 | 40762 | } }, |
| 27815 | 40763 | }, .{ |
| 27816 | 40764 | .required_features = .{ .sse4_1, null, null, null }, |
| 27817 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27818 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 40765 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40766 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27819 | 40767 | .patterns = &.{ |
| 27820 | | .{ .src = .{ .mem, .none } }, |
| 27821 | | .{ .src = .{ .to_sse, .none } }, |
| 40768 | .{ .src = .{ .mem, .none, .none } }, |
| 40769 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27822 | 40770 | }, |
| 27823 | 40771 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27824 | 40772 | .each = .{ .once = &.{ |
| 27825 | | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 40773 | .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 40774 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 27826 | 40775 | } }, |
| 27827 | 40776 | }, .{ |
| 27828 | 40777 | .required_features = .{ .sse4_1, null, null, null }, |
| 27829 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27830 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 40778 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40779 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27831 | 40780 | .patterns = &.{ |
| 27832 | | .{ .src = .{ .mem, .none } }, |
| 27833 | | .{ .src = .{ .to_sse, .none } }, |
| 40781 | .{ .src = .{ .mem, .none, .none } }, |
| 40782 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27834 | 40783 | }, |
| 27835 | 40784 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27836 | 40785 | .each = .{ .once = &.{ |
| 27837 | | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 40786 | .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 40787 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 27838 | 40788 | } }, |
| 27839 | 40789 | }, .{ |
| 27840 | 40790 | .required_features = .{ .sse2, null, null, null }, |
| 27841 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27842 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 40791 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40792 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27843 | 40793 | .patterns = &.{ |
| 27844 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 40794 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27845 | 40795 | }, |
| 27846 | 40796 | .extra_temps = .{ |
| 27847 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 40797 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 27848 | 40798 | .unused, |
| 27849 | 40799 | .unused, |
| 27850 | 40800 | .unused, |
| ... | ... | @@ -27857,20 +40807,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27857 | 40807 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27858 | 40808 | .each = .{ .once = &.{ |
| 27859 | 40809 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27860 | | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27861 | | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 27862 | | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 40810 | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27863 | 40811 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 40812 | .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ }, |
| 40813 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 27864 | 40814 | } }, |
| 27865 | 40815 | }, .{ |
| 27866 | 40816 | .required_features = .{ .sse2, null, null, null }, |
| 27867 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27868 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 40817 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40818 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27869 | 40819 | .patterns = &.{ |
| 27870 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 40820 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27871 | 40821 | }, |
| 27872 | 40822 | .extra_temps = .{ |
| 27873 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 40823 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 27874 | 40824 | .unused, |
| 27875 | 40825 | .unused, |
| 27876 | 40826 | .unused, |
| ... | ... | @@ -27883,45 +40833,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27883 | 40833 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27884 | 40834 | .each = .{ .once = &.{ |
| 27885 | 40835 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27886 | | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 27887 | 40836 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 40837 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 27888 | 40838 | } }, |
| 27889 | 40839 | }, .{ |
| 27890 | | .required_features = .{ .avx2, null, null, null }, |
| 27891 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27892 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 27893 | | .patterns = &.{ |
| 27894 | | .{ .src = .{ .mem, .none } }, |
| 27895 | | .{ .src = .{ .to_sse, .none } }, |
| 27896 | | }, |
| 27897 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27898 | | .each = .{ .once = &.{ |
| 27899 | | .{ ._, .vp_q, .movsxw, .dst0y, .src0q, ._, ._ }, |
| 27900 | | } }, |
| 27901 | | }, .{ |
| 27902 | | .required_features = .{ .avx2, null, null, null }, |
| 27903 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27904 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 27905 | | .patterns = &.{ |
| 27906 | | .{ .src = .{ .mem, .none } }, |
| 27907 | | .{ .src = .{ .to_sse, .none } }, |
| 27908 | | }, |
| 27909 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27910 | | .each = .{ .once = &.{ |
| 27911 | | .{ ._, .vp_q, .movzxw, .dst0y, .src0q, ._, ._ }, |
| 27912 | | } }, |
| 27913 | | }, .{ |
| 27914 | | .required_features = .{ .avx2, null, null, null }, |
| 27915 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27916 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 40840 | .required_features = .{ .@"64bit", null, null, null }, |
| 40841 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40842 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27917 | 40843 | .patterns = &.{ |
| 27918 | | .{ .src = .{ .to_mem, .none } }, |
| 40844 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27919 | 40845 | }, |
| 27920 | 40846 | .extra_temps = .{ |
| 27921 | 40847 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27922 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 27923 | | .unused, |
| 27924 | | .unused, |
| 40848 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 40849 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 40850 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27925 | 40851 | .unused, |
| 27926 | 40852 | .unused, |
| 27927 | 40853 | .unused, |
| ... | ... | @@ -27932,23 +40858,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27932 | 40858 | .clobbers = .{ .eflags = true }, |
| 27933 | 40859 | .each = .{ .once = &.{ |
| 27934 | 40860 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27935 | | .{ .@"0:", .vp_q, .movsxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27936 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27937 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 40861 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 40862 | .{ .@"0:", ._, .movsxd, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40863 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 40864 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 40865 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 40866 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 40867 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27938 | 40868 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27939 | 40869 | } }, |
| 27940 | 40870 | }, .{ |
| 27941 | | .required_features = .{ .avx2, null, null, null }, |
| 27942 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, |
| 27943 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 40871 | .required_features = .{ .@"64bit", null, null, null }, |
| 40872 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 40873 | .dst_constraints = .{.any_scalar_int}, |
| 27944 | 40874 | .patterns = &.{ |
| 27945 | | .{ .src = .{ .to_mem, .none } }, |
| 40875 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27946 | 40876 | }, |
| 27947 | 40877 | .extra_temps = .{ |
| 27948 | 40878 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27949 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 27950 | | .unused, |
| 27951 | | .unused, |
| 40879 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 40880 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 40881 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27952 | 40882 | .unused, |
| 27953 | 40883 | .unused, |
| 27954 | 40884 | .unused, |
| ... | ... | @@ -27959,24 +40889,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27959 | 40889 | .clobbers = .{ .eflags = true }, |
| 27960 | 40890 | .each = .{ .once = &.{ |
| 27961 | 40891 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27962 | | .{ .@"0:", .vp_q, .movzxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27963 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27964 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 40892 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 40893 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 40894 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 40895 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 40896 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 40897 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 40898 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27965 | 40899 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27966 | 40900 | } }, |
| 27967 | 40901 | }, .{ |
| 27968 | | .required_features = .{ .avx, null, null, null }, |
| 27969 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27970 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 40902 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 40903 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 40904 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27971 | 40905 | .patterns = &.{ |
| 27972 | | .{ .src = .{ .to_mem, .none } }, |
| 40906 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27973 | 40907 | }, |
| 27974 | 40908 | .extra_temps = .{ |
| 27975 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27976 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 27977 | | .unused, |
| 27978 | | .unused, |
| 27979 | | .unused, |
| 40909 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 40910 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 40911 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 40912 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 40913 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 27980 | 40914 | .unused, |
| 27981 | 40915 | .unused, |
| 27982 | 40916 | .unused, |
| ... | ... | @@ -27985,25 +40919,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27985 | 40919 | .dst_temps = .{.mem}, |
| 27986 | 40920 | .clobbers = .{ .eflags = true }, |
| 27987 | 40921 | .each = .{ .once = &.{ |
| 27988 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27989 | | .{ .@"0:", .vp_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27990 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27991 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27992 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 40922 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 40923 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 40924 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 40925 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 40926 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 40927 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 40928 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 40929 | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, |
| 40930 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 40931 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 40932 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 40933 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 27993 | 40934 | } }, |
| 27994 | 40935 | }, .{ |
| 27995 | | .required_features = .{ .avx, null, null, null }, |
| 27996 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any }, |
| 27997 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 40936 | .required_features = .{ .@"64bit", null, null, null }, |
| 40937 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 40938 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27998 | 40939 | .patterns = &.{ |
| 27999 | | .{ .src = .{ .to_mem, .none } }, |
| 40940 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28000 | 40941 | }, |
| 28001 | 40942 | .extra_temps = .{ |
| 28002 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28003 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 28004 | | .unused, |
| 28005 | | .unused, |
| 28006 | | .unused, |
| 40943 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 40944 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 40945 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 40946 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 40947 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 28007 | 40948 | .unused, |
| 28008 | 40949 | .unused, |
| 28009 | 40950 | .unused, |
| ... | ... | @@ -28012,25 +40953,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28012 | 40953 | .dst_temps = .{.mem}, |
| 28013 | 40954 | .clobbers = .{ .eflags = true }, |
| 28014 | 40955 | .each = .{ .once = &.{ |
| 28015 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28016 | | .{ .@"0:", .vp_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28017 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28018 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28019 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 40956 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 40957 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 40958 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 40959 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 40960 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 40961 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 40962 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 40963 | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, |
| 40964 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 40965 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 40966 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 40967 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 28020 | 40968 | } }, |
| 28021 | 40969 | }, .{ |
| 28022 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28023 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, |
| 28024 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 40970 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 40971 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 40972 | .dst_constraints = .{.any_scalar_int}, |
| 28025 | 40973 | .patterns = &.{ |
| 28026 | | .{ .src = .{ .to_mem, .none } }, |
| 40974 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28027 | 40975 | }, |
| 28028 | 40976 | .extra_temps = .{ |
| 28029 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28030 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 28031 | | .unused, |
| 28032 | | .unused, |
| 28033 | | .unused, |
| 40977 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 40978 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 40979 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 40980 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 40981 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28034 | 40982 | .unused, |
| 28035 | 40983 | .unused, |
| 28036 | 40984 | .unused, |
| ... | ... | @@ -28039,319 +40987,374 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28039 | 40987 | .dst_temps = .{.mem}, |
| 28040 | 40988 | .clobbers = .{ .eflags = true }, |
| 28041 | 40989 | .each = .{ .once = &.{ |
| 28042 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28043 | | .{ .@"0:", .p_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28044 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28045 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28046 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 40990 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 40991 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 40992 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 40993 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| 40994 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 40995 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| 40996 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 40997 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 40998 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 40999 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 28047 | 41000 | } }, |
| 28048 | 41001 | }, .{ |
| 28049 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28050 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any }, |
| 28051 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 41002 | .required_features = .{ .@"64bit", null, null, null }, |
| 41003 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 41004 | .dst_constraints = .{.any_scalar_int}, |
| 28052 | 41005 | .patterns = &.{ |
| 28053 | | .{ .src = .{ .to_mem, .none } }, |
| 41006 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28054 | 41007 | }, |
| 28055 | 41008 | .extra_temps = .{ |
| 28056 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28057 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 28058 | | .unused, |
| 28059 | | .unused, |
| 28060 | | .unused, |
| 41009 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 41010 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41011 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41012 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 41013 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28061 | 41014 | .unused, |
| 28062 | 41015 | .unused, |
| 28063 | 41016 | .unused, |
| 28064 | 41017 | .unused, |
| 28065 | 41018 | }, |
| 28066 | | .dst_temps = .{.mem}, |
| 28067 | | .clobbers = .{ .eflags = true }, |
| 41019 | .dst_temps = .{.mem}, |
| 41020 | .clobbers = .{ .eflags = true }, |
| 41021 | .each = .{ .once = &.{ |
| 41022 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 41023 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 41024 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 41025 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| 41026 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41027 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| 41028 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 41029 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 41030 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 41031 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 41032 | } }, |
| 41033 | } }) catch |err| switch (err) { |
| 41034 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 41035 | @tagName(air_tag), |
| 41036 | dst_ty.fmt(pt), |
| 41037 | src_ty.fmt(pt), |
| 41038 | ops[0].tracking(cg), |
| 41039 | }), |
| 41040 | else => |e| return e, |
| 41041 | }; |
| 41042 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 41043 | }, |
| 41044 | .trunc => |air_tag| if (use_old) try cg.airTrunc(inst) else { |
| 41045 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 41046 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 41047 | var res: [1]Temp = undefined; |
| 41048 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 41049 | .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any }, |
| 41050 | .dst_constraints = .{.{ .exact_signed_int = 1 }}, |
| 41051 | .patterns = &.{ |
| 41052 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 41053 | }, |
| 41054 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41055 | .clobbers = .{ .eflags = true }, |
| 41056 | .each = .{ .once = &.{ |
| 41057 | .{ ._, ._, .@"and", .dst0d, .si(1), ._, ._ }, |
| 41058 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 41059 | } }, |
| 41060 | }, .{ |
| 41061 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41062 | .dst_constraints = .{.{ .exact_signed_int = 1 }}, |
| 41063 | .patterns = &.{ |
| 41064 | .{ .src = .{ .to_mem, .none, .none } }, |
| 41065 | }, |
| 41066 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41067 | .clobbers = .{ .eflags = true }, |
| 41068 | .each = .{ .once = &.{ |
| 41069 | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, |
| 41070 | .{ ._, ._, .@"and", .dst0d, .si(1), ._, ._ }, |
| 41071 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 41072 | } }, |
| 41073 | }, .{ |
| 41074 | .src_constraints = .{ .{ .int = .gpr }, .any, .any }, |
| 41075 | .dst_constraints = .{.{ .exact_int = 8 }}, |
| 41076 | .patterns = &.{ |
| 41077 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 41078 | }, |
| 41079 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41080 | .each = .{ .once = &.{} }, |
| 41081 | }, .{ |
| 41082 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41083 | .dst_constraints = .{.{ .exact_signed_int = 8 }}, |
| 41084 | .patterns = &.{ |
| 41085 | .{ .src = .{ .to_mem, .none, .none } }, |
| 41086 | }, |
| 41087 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41088 | .each = .{ .once = &.{ |
| 41089 | .{ ._, ._, .movsx, .dst0d, .mem(.src0b), ._, ._ }, |
| 41090 | } }, |
| 41091 | }, .{ |
| 41092 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41093 | .dst_constraints = .{.{ .exact_unsigned_int = 8 }}, |
| 41094 | .patterns = &.{ |
| 41095 | .{ .src = .{ .to_mem, .none, .none } }, |
| 41096 | }, |
| 41097 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41098 | .each = .{ .once = &.{ |
| 41099 | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, |
| 41100 | } }, |
| 41101 | }, .{ |
| 41102 | .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any }, |
| 41103 | .dst_constraints = .{.{ .signed_int = .byte }}, |
| 41104 | .patterns = &.{ |
| 41105 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 41106 | }, |
| 41107 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41108 | .clobbers = .{ .eflags = true }, |
| 41109 | .each = .{ .once = &.{ |
| 41110 | .{ ._, ._l, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 41111 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 41112 | } }, |
| 41113 | }, .{ |
| 41114 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 41115 | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 41116 | .patterns = &.{ |
| 41117 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 41118 | }, |
| 41119 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41120 | .clobbers = .{ .eflags = true }, |
| 41121 | .each = .{ .once = &.{ |
| 41122 | .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ }, |
| 41123 | } }, |
| 41124 | }, .{ |
| 41125 | .src_constraints = .{ .any_int, .any, .any }, |
| 41126 | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 41127 | .patterns = &.{ |
| 41128 | .{ .src = .{ .to_mem, .none, .none } }, |
| 41129 | }, |
| 41130 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41131 | .clobbers = .{ .eflags = true }, |
| 41132 | .each = .{ .once = &.{ |
| 41133 | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, |
| 41134 | .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ }, |
| 41135 | } }, |
| 41136 | }, .{ |
| 41137 | .src_constraints = .{ .{ .int = .gpr }, .any, .any }, |
| 41138 | .dst_constraints = .{.{ .exact_int = 16 }}, |
| 41139 | .patterns = &.{ |
| 41140 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 41141 | }, |
| 41142 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41143 | .each = .{ .once = &.{} }, |
| 41144 | }, .{ |
| 41145 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41146 | .dst_constraints = .{.{ .exact_signed_int = 16 }}, |
| 41147 | .patterns = &.{ |
| 41148 | .{ .src = .{ .to_mem, .none, .none } }, |
| 41149 | }, |
| 41150 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41151 | .each = .{ .once = &.{ |
| 41152 | .{ ._, ._, .movsx, .dst0d, .mem(.src0w), ._, ._ }, |
| 41153 | } }, |
| 41154 | }, .{ |
| 41155 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41156 | .dst_constraints = .{.{ .exact_unsigned_int = 16 }}, |
| 41157 | .patterns = &.{ |
| 41158 | .{ .src = .{ .to_mem, .none, .none } }, |
| 41159 | }, |
| 41160 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28068 | 41161 | .each = .{ .once = &.{ |
| 28069 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28070 | | .{ .@"0:", .p_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28071 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28072 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28073 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41162 | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, |
| 28074 | 41163 | } }, |
| 28075 | 41164 | }, .{ |
| 28076 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28077 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 28078 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 41165 | .required_features = .{ .fast_imm16, null, null, null }, |
| 41166 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 41167 | .dst_constraints = .{.{ .unsigned_int = .word }}, |
| 28079 | 41168 | .patterns = &.{ |
| 28080 | | .{ .src = .{ .to_mem, .none } }, |
| 28081 | | }, |
| 28082 | | .extra_temps = .{ |
| 28083 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28084 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 28085 | | .unused, |
| 28086 | | .unused, |
| 28087 | | .unused, |
| 28088 | | .unused, |
| 28089 | | .unused, |
| 28090 | | .unused, |
| 28091 | | .unused, |
| 41169 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28092 | 41170 | }, |
| 28093 | | .dst_temps = .{.mem}, |
| 41171 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28094 | 41172 | .clobbers = .{ .eflags = true }, |
| 28095 | 41173 | .each = .{ .once = &.{ |
| 28096 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28097 | | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28098 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 28099 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28100 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41174 | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, |
| 28101 | 41175 | } }, |
| 28102 | 41176 | }, .{ |
| 28103 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28104 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 28105 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 41177 | .required_features = .{ .fast_imm16, null, null, null }, |
| 41178 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41179 | .dst_constraints = .{.{ .unsigned_int = .word }}, |
| 28106 | 41180 | .patterns = &.{ |
| 28107 | | .{ .src = .{ .to_mem, .none } }, |
| 28108 | | }, |
| 28109 | | .extra_temps = .{ |
| 28110 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28111 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 28112 | | .unused, |
| 28113 | | .unused, |
| 28114 | | .unused, |
| 28115 | | .unused, |
| 28116 | | .unused, |
| 28117 | | .unused, |
| 28118 | | .unused, |
| 41181 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28119 | 41182 | }, |
| 28120 | | .dst_temps = .{.mem}, |
| 41183 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28121 | 41184 | .clobbers = .{ .eflags = true }, |
| 28122 | 41185 | .each = .{ .once = &.{ |
| 28123 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28124 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28125 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 28126 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28127 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41186 | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, |
| 41187 | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, |
| 28128 | 41188 | } }, |
| 28129 | 41189 | }, .{ |
| 28130 | | .required_features = .{ .avx, null, null, null }, |
| 28131 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 28132 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 41190 | .src_constraints = .{ .{ .int = .gpr }, .any, .any }, |
| 41191 | .dst_constraints = .{.{ .exact_int = 32 }}, |
| 28133 | 41192 | .patterns = &.{ |
| 28134 | | .{ .src = .{ .mem, .none } }, |
| 28135 | | .{ .src = .{ .to_sse, .none } }, |
| 41193 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28136 | 41194 | }, |
| 28137 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28138 | | .each = .{ .once = &.{ |
| 28139 | | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 28140 | | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 28141 | | } }, |
| 41195 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41196 | .each = .{ .once = &.{} }, |
| 28142 | 41197 | }, .{ |
| 28143 | | .required_features = .{ .avx, null, null, null }, |
| 28144 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 28145 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 41198 | .src_constraints = .{ .any_int, .any, .any }, |
| 41199 | .dst_constraints = .{.{ .exact_int = 32 }}, |
| 28146 | 41200 | .patterns = &.{ |
| 28147 | | .{ .src = .{ .mem, .none } }, |
| 28148 | | .{ .src = .{ .to_sse, .none } }, |
| 41201 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28149 | 41202 | }, |
| 28150 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41203 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28151 | 41204 | .each = .{ .once = &.{ |
| 28152 | | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 28153 | | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 41205 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 28154 | 41206 | } }, |
| 28155 | 41207 | }, .{ |
| 28156 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28157 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 28158 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 41208 | .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any }, |
| 41209 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 28159 | 41210 | .patterns = &.{ |
| 28160 | | .{ .src = .{ .mem, .none } }, |
| 28161 | | .{ .src = .{ .to_sse, .none } }, |
| 41211 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28162 | 41212 | }, |
| 28163 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41213 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41214 | .clobbers = .{ .eflags = true }, |
| 28164 | 41215 | .each = .{ .once = &.{ |
| 28165 | | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 28166 | | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 41216 | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 41217 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 28167 | 41218 | } }, |
| 28168 | 41219 | }, .{ |
| 28169 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28170 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 28171 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 41220 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41221 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 28172 | 41222 | .patterns = &.{ |
| 28173 | | .{ .src = .{ .mem, .none } }, |
| 28174 | | .{ .src = .{ .to_sse, .none } }, |
| 41223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28175 | 41224 | }, |
| 28176 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41225 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41226 | .clobbers = .{ .eflags = true }, |
| 28177 | 41227 | .each = .{ .once = &.{ |
| 28178 | | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 28179 | | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 41228 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 41229 | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 41230 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 28180 | 41231 | } }, |
| 28181 | 41232 | }, .{ |
| 28182 | | .required_features = .{ .sse2, null, null, null }, |
| 28183 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 28184 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 41233 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 41234 | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 28185 | 41235 | .patterns = &.{ |
| 28186 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 28187 | | }, |
| 28188 | | .extra_temps = .{ |
| 28189 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 28190 | | .unused, |
| 28191 | | .unused, |
| 28192 | | .unused, |
| 28193 | | .unused, |
| 28194 | | .unused, |
| 28195 | | .unused, |
| 28196 | | .unused, |
| 28197 | | .unused, |
| 41236 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28198 | 41237 | }, |
| 28199 | 41238 | .dst_temps = .{.{ .ref = .src0 }}, |
| 41239 | .clobbers = .{ .eflags = true }, |
| 28200 | 41240 | .each = .{ .once = &.{ |
| 28201 | | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 28202 | | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 28203 | | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 28204 | | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 28205 | | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 28206 | | .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ }, |
| 28207 | | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 41241 | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, |
| 28208 | 41242 | } }, |
| 28209 | 41243 | }, .{ |
| 28210 | | .required_features = .{ .sse2, null, null, null }, |
| 28211 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 28212 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 41244 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41245 | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 28213 | 41246 | .patterns = &.{ |
| 28214 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 28215 | | }, |
| 28216 | | .extra_temps = .{ |
| 28217 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 28218 | | .unused, |
| 28219 | | .unused, |
| 28220 | | .unused, |
| 28221 | | .unused, |
| 28222 | | .unused, |
| 28223 | | .unused, |
| 28224 | | .unused, |
| 28225 | | .unused, |
| 41247 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28226 | 41248 | }, |
| 28227 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 41249 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41250 | .clobbers = .{ .eflags = true }, |
| 28228 | 41251 | .each = .{ .once = &.{ |
| 28229 | | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 28230 | | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 28231 | | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 28232 | | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 41252 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 41253 | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, |
| 28233 | 41254 | } }, |
| 28234 | 41255 | }, .{ |
| 28235 | 41256 | .required_features = .{ .@"64bit", null, null, null }, |
| 28236 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 28237 | | .dst_constraints = .{.any_scalar_signed_int}, |
| 41257 | .src_constraints = .{ .any_int, .any, .any }, |
| 41258 | .dst_constraints = .{.{ .exact_int = 64 }}, |
| 28238 | 41259 | .patterns = &.{ |
| 28239 | | .{ .src = .{ .to_mem, .none } }, |
| 41260 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28240 | 41261 | }, |
| 28241 | | .extra_temps = .{ |
| 28242 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28243 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28244 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 28245 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28246 | | .unused, |
| 28247 | | .unused, |
| 28248 | | .unused, |
| 28249 | | .unused, |
| 28250 | | .unused, |
| 41262 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41263 | .each = .{ .once = &.{ |
| 41264 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 41265 | } }, |
| 41266 | }, .{ |
| 41267 | .required_features = .{ .@"64bit", null, null, null }, |
| 41268 | .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any }, |
| 41269 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 41270 | .patterns = &.{ |
| 41271 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28251 | 41272 | }, |
| 28252 | | .dst_temps = .{.mem}, |
| 41273 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28253 | 41274 | .clobbers = .{ .eflags = true }, |
| 28254 | 41275 | .each = .{ .once = &.{ |
| 28255 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28256 | | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 28257 | | .{ .@"0:", ._, .movsx, .tmp2q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28258 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 28259 | | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 28260 | | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 28261 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28262 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28263 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41276 | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 41277 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 28264 | 41278 | } }, |
| 28265 | 41279 | }, .{ |
| 28266 | 41280 | .required_features = .{ .@"64bit", null, null, null }, |
| 28267 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 28268 | | .dst_constraints = .{.any_scalar_int}, |
| 41281 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41282 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 28269 | 41283 | .patterns = &.{ |
| 28270 | | .{ .src = .{ .to_mem, .none } }, |
| 28271 | | }, |
| 28272 | | .extra_temps = .{ |
| 28273 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28274 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28275 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28276 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28277 | | .unused, |
| 28278 | | .unused, |
| 28279 | | .unused, |
| 28280 | | .unused, |
| 28281 | | .unused, |
| 41284 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28282 | 41285 | }, |
| 28283 | | .dst_temps = .{.mem}, |
| 41286 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28284 | 41287 | .clobbers = .{ .eflags = true }, |
| 28285 | 41288 | .each = .{ .once = &.{ |
| 28286 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28287 | | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 28288 | | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28289 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 28290 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28291 | | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 28292 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28293 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28294 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41289 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 41290 | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 41291 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 28295 | 41292 | } }, |
| 28296 | 41293 | }, .{ |
| 28297 | | .required_features = .{ .avx, null, null, null }, |
| 28298 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28299 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 41294 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 41295 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 41296 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28300 | 41297 | .patterns = &.{ |
| 28301 | | .{ .src = .{ .mem, .none } }, |
| 28302 | | .{ .src = .{ .to_sse, .none } }, |
| 41298 | .{ .src = .{ .mem, .none, .none } }, |
| 41299 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 28303 | 41300 | }, |
| 28304 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41301 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41302 | .clobbers = .{ .eflags = true }, |
| 28305 | 41303 | .each = .{ .once = &.{ |
| 28306 | | .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 41304 | .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 41305 | .{ ._, ._, .bzhi, .dst0q, .src0q, .dst0q, ._ }, |
| 28307 | 41306 | } }, |
| 28308 | 41307 | }, .{ |
| 28309 | | .required_features = .{ .avx, null, null, null }, |
| 28310 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28311 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 41308 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 41309 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41310 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28312 | 41311 | .patterns = &.{ |
| 28313 | | .{ .src = .{ .mem, .none } }, |
| 28314 | | .{ .src = .{ .to_sse, .none } }, |
| 41312 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28315 | 41313 | }, |
| 28316 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41314 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41315 | .clobbers = .{ .eflags = true }, |
| 28317 | 41316 | .each = .{ .once = &.{ |
| 28318 | | .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 41317 | .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 41318 | .{ ._, ._, .bzhi, .dst0q, .mem(.src0q), .dst0q, ._ }, |
| 28319 | 41319 | } }, |
| 28320 | 41320 | }, .{ |
| 28321 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28322 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28323 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 41321 | .required_features = .{ .@"64bit", null, null, null }, |
| 41322 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 41323 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28324 | 41324 | .patterns = &.{ |
| 28325 | | .{ .src = .{ .mem, .none } }, |
| 28326 | | .{ .src = .{ .to_sse, .none } }, |
| 41325 | .{ .src = .{ .mem, .none, .none } }, |
| 41326 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 28327 | 41327 | }, |
| 28328 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41328 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41329 | .clobbers = .{ .eflags = true }, |
| 28329 | 41330 | .each = .{ .once = &.{ |
| 28330 | | .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 41331 | .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 41332 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| 28331 | 41333 | } }, |
| 28332 | 41334 | }, .{ |
| 28333 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28334 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28335 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 41335 | .required_features = .{ .@"64bit", null, null, null }, |
| 41336 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41337 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28336 | 41338 | .patterns = &.{ |
| 28337 | | .{ .src = .{ .mem, .none } }, |
| 28338 | | .{ .src = .{ .to_sse, .none } }, |
| 41339 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28339 | 41340 | }, |
| 28340 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41341 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41342 | .clobbers = .{ .eflags = true }, |
| 28341 | 41343 | .each = .{ .once = &.{ |
| 28342 | | .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 41344 | .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 41345 | .{ ._, ._, .@"and", .dst0q, .mem(.src0q), ._, ._ }, |
| 28343 | 41346 | } }, |
| 28344 | 41347 | }, .{ |
| 28345 | | .required_features = .{ .sse2, null, null, null }, |
| 28346 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28347 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 41348 | .required_features = .{ .@"64bit", null, null, null }, |
| 41349 | .src_constraints = .{ .any_int, .any, .any }, |
| 41350 | .dst_constraints = .{.{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 28348 | 41351 | .patterns = &.{ |
| 28349 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 41352 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28350 | 41353 | }, |
| 28351 | 41354 | .extra_temps = .{ |
| 28352 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 28353 | | .unused, |
| 28354 | | .unused, |
| 41355 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41356 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41357 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28355 | 41358 | .unused, |
| 28356 | 41359 | .unused, |
| 28357 | 41360 | .unused, |
| ... | ... | @@ -28359,23 +41362,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28359 | 41362 | .unused, |
| 28360 | 41363 | .unused, |
| 28361 | 41364 | }, |
| 28362 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 41365 | .dst_temps = .{.mem}, |
| 28363 | 41366 | .each = .{ .once = &.{ |
| 28364 | | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 28365 | | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 28366 | | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 41367 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41368 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41369 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| 41370 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28367 | 41371 | } }, |
| 28368 | 41372 | }, .{ |
| 28369 | | .required_features = .{ .sse2, null, null, null }, |
| 28370 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28371 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 41373 | .required_features = .{ .@"64bit", null, null, null }, |
| 41374 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41375 | .dst_constraints = .{.{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 28372 | 41376 | .patterns = &.{ |
| 28373 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 41377 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28374 | 41378 | }, |
| 28375 | 41379 | .extra_temps = .{ |
| 28376 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 28377 | | .unused, |
| 28378 | | .unused, |
| 41380 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41381 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41382 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28379 | 41383 | .unused, |
| 28380 | 41384 | .unused, |
| 28381 | 41385 | .unused, |
| ... | ... | @@ -28383,46 +41387,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28383 | 41387 | .unused, |
| 28384 | 41388 | .unused, |
| 28385 | 41389 | }, |
| 28386 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 28387 | | .each = .{ .once = &.{ |
| 28388 | | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 28389 | | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 28390 | | } }, |
| 28391 | | }, .{ |
| 28392 | | .required_features = .{ .avx2, null, null, null }, |
| 28393 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 28394 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 28395 | | .patterns = &.{ |
| 28396 | | .{ .src = .{ .mem, .none } }, |
| 28397 | | .{ .src = .{ .to_sse, .none } }, |
| 28398 | | }, |
| 28399 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28400 | | .each = .{ .once = &.{ |
| 28401 | | .{ ._, .vp_q, .movsxd, .dst0y, .src0x, ._, ._ }, |
| 28402 | | } }, |
| 28403 | | }, .{ |
| 28404 | | .required_features = .{ .avx2, null, null, null }, |
| 28405 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 28406 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 28407 | | .patterns = &.{ |
| 28408 | | .{ .src = .{ .mem, .none } }, |
| 28409 | | .{ .src = .{ .to_sse, .none } }, |
| 28410 | | }, |
| 28411 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41390 | .dst_temps = .{.mem}, |
| 41391 | .clobbers = .{ .eflags = true }, |
| 28412 | 41392 | .each = .{ .once = &.{ |
| 28413 | | .{ ._, .vp_q, .movzxd, .dst0y, .src0x, ._, ._ }, |
| 41393 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41394 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41395 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 41396 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41397 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 41398 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| 41399 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 41400 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 28414 | 41401 | } }, |
| 28415 | 41402 | }, .{ |
| 28416 | | .required_features = .{ .avx2, null, null, null }, |
| 28417 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 28418 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 41403 | .required_features = .{ .@"64bit", null, null, null }, |
| 41404 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41405 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 28419 | 41406 | .patterns = &.{ |
| 28420 | | .{ .src = .{ .to_mem, .none } }, |
| 41407 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28421 | 41408 | }, |
| 28422 | 41409 | .extra_temps = .{ |
| 28423 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28424 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 28425 | | .unused, |
| 41410 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41411 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41412 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28426 | 41413 | .unused, |
| 28427 | 41414 | .unused, |
| 28428 | 41415 | .unused, |
| ... | ... | @@ -28433,23 +41420,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28433 | 41420 | .dst_temps = .{.mem}, |
| 28434 | 41421 | .clobbers = .{ .eflags = true }, |
| 28435 | 41422 | .each = .{ .once = &.{ |
| 28436 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28437 | | .{ .@"0:", .vp_q, .movsxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28438 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 28439 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 28440 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41423 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41424 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41425 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 41426 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41427 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 41428 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 41429 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 41430 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| 41431 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 41432 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 28441 | 41433 | } }, |
| 28442 | 41434 | }, .{ |
| 28443 | | .required_features = .{ .avx2, null, null, null }, |
| 28444 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 28445 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 41435 | .required_features = .{ .@"64bit", null, null, null }, |
| 41436 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 41437 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 28446 | 41438 | .patterns = &.{ |
| 28447 | | .{ .src = .{ .to_mem, .none } }, |
| 41439 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28448 | 41440 | }, |
| 28449 | 41441 | .extra_temps = .{ |
| 28450 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28451 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 28452 | | .unused, |
| 41442 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41443 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41444 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28453 | 41445 | .unused, |
| 28454 | 41446 | .unused, |
| 28455 | 41447 | .unused, |
| ... | ... | @@ -28460,23 +41452,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28460 | 41452 | .dst_temps = .{.mem}, |
| 28461 | 41453 | .clobbers = .{ .eflags = true }, |
| 28462 | 41454 | .each = .{ .once = &.{ |
| 28463 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28464 | | .{ .@"0:", .vp_q, .movzxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28465 | | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 28466 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 28467 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41455 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41456 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41457 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 41458 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41459 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 41460 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 41461 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 41462 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 28468 | 41463 | } }, |
| 28469 | 41464 | }, .{ |
| 28470 | | .required_features = .{ .avx, null, null, null }, |
| 28471 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28472 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 41465 | .required_features = .{ .@"64bit", null, null, null }, |
| 41466 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41467 | .dst_constraints = .{.{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 28473 | 41468 | .patterns = &.{ |
| 28474 | | .{ .src = .{ .to_mem, .none } }, |
| 41469 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28475 | 41470 | }, |
| 28476 | 41471 | .extra_temps = .{ |
| 28477 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28478 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 28479 | | .unused, |
| 41472 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41473 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41474 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28480 | 41475 | .unused, |
| 28481 | 41476 | .unused, |
| 28482 | 41477 | .unused, |
| ... | ... | @@ -28485,25 +41480,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28485 | 41480 | .unused, |
| 28486 | 41481 | }, |
| 28487 | 41482 | .dst_temps = .{.mem}, |
| 28488 | | .clobbers = .{ .eflags = true }, |
| 28489 | 41483 | .each = .{ .once = &.{ |
| 28490 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28491 | | .{ .@"0:", .vp_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28492 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28493 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28494 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41484 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41485 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41486 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 41487 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41488 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 28495 | 41489 | } }, |
| 28496 | 41490 | }, .{ |
| 28497 | | .required_features = .{ .avx, null, null, null }, |
| 28498 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any }, |
| 28499 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 41491 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 41492 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41493 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 28500 | 41494 | .patterns = &.{ |
| 28501 | | .{ .src = .{ .to_mem, .none } }, |
| 41495 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28502 | 41496 | }, |
| 28503 | 41497 | .extra_temps = .{ |
| 28504 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28505 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 28506 | | .unused, |
| 41498 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41499 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41500 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28507 | 41501 | .unused, |
| 28508 | 41502 | .unused, |
| 28509 | 41503 | .unused, |
| ... | ... | @@ -28514,23 +41508,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28514 | 41508 | .dst_temps = .{.mem}, |
| 28515 | 41509 | .clobbers = .{ .eflags = true }, |
| 28516 | 41510 | .each = .{ .once = &.{ |
| 28517 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28518 | | .{ .@"0:", .vp_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28519 | | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28520 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28521 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41511 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41512 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41513 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 41514 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41515 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 41516 | .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_size, -16), .tmp2q, ._ }, |
| 41517 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp2q, ._, ._ }, |
| 41518 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 28522 | 41519 | } }, |
| 28523 | 41520 | }, .{ |
| 28524 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28525 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28526 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 41521 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 41522 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41523 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 28527 | 41524 | .patterns = &.{ |
| 28528 | | .{ .src = .{ .to_mem, .none } }, |
| 41525 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28529 | 41526 | }, |
| 28530 | 41527 | .extra_temps = .{ |
| 28531 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28532 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 28533 | | .unused, |
| 41528 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41529 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41530 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28534 | 41531 | .unused, |
| 28535 | 41532 | .unused, |
| 28536 | 41533 | .unused, |
| ... | ... | @@ -28541,23 +41538,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28541 | 41538 | .dst_temps = .{.mem}, |
| 28542 | 41539 | .clobbers = .{ .eflags = true }, |
| 28543 | 41540 | .each = .{ .once = &.{ |
| 28544 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28545 | | .{ .@"0:", .p_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28546 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28547 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28548 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41541 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41542 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41543 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 41544 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41545 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 41546 | .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_size, -8), .tmp2q, ._ }, |
| 41547 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| 28549 | 41548 | } }, |
| 28550 | 41549 | }, .{ |
| 28551 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28552 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any }, |
| 28553 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 41550 | .required_features = .{ .@"64bit", null, null, null }, |
| 41551 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41552 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 28554 | 41553 | .patterns = &.{ |
| 28555 | | .{ .src = .{ .to_mem, .none } }, |
| 41554 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28556 | 41555 | }, |
| 28557 | 41556 | .extra_temps = .{ |
| 28558 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28559 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 28560 | | .unused, |
| 41557 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41558 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41559 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28561 | 41560 | .unused, |
| 28562 | 41561 | .unused, |
| 28563 | 41562 | .unused, |
| ... | ... | @@ -28568,23 +41567,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28568 | 41567 | .dst_temps = .{.mem}, |
| 28569 | 41568 | .clobbers = .{ .eflags = true }, |
| 28570 | 41569 | .each = .{ .once = &.{ |
| 28571 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28572 | | .{ .@"0:", .p_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28573 | | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 28574 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28575 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41570 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41571 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41572 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 41573 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41574 | .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 41575 | .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 41576 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| 41577 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 28576 | 41578 | } }, |
| 28577 | 41579 | }, .{ |
| 28578 | 41580 | .required_features = .{ .@"64bit", null, null, null }, |
| 28579 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28580 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 41581 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 41582 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 28581 | 41583 | .patterns = &.{ |
| 28582 | | .{ .src = .{ .to_mem, .none } }, |
| 41584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28583 | 41585 | }, |
| 28584 | 41586 | .extra_temps = .{ |
| 28585 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28586 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 28587 | | .unused, |
| 41587 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 41588 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 41589 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28588 | 41590 | .unused, |
| 28589 | 41591 | .unused, |
| 28590 | 41592 | .unused, |
| ... | ... | @@ -28595,23 +41597,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28595 | 41597 | .dst_temps = .{.mem}, |
| 28596 | 41598 | .clobbers = .{ .eflags = true }, |
| 28597 | 41599 | .each = .{ .once = &.{ |
| 28598 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28599 | | .{ .@"0:", ._, .movsxd, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28600 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 28601 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28602 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41600 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 41601 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 41602 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 41603 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 41604 | .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 41605 | .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 41606 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 28603 | 41607 | } }, |
| 28604 | 41608 | }, .{ |
| 28605 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28606 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28607 | | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 41609 | .required_features = .{ .avx, null, null, null }, |
| 41610 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41611 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28608 | 41612 | .patterns = &.{ |
| 28609 | | .{ .src = .{ .to_mem, .none } }, |
| 41613 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28610 | 41614 | }, |
| 28611 | 41615 | .extra_temps = .{ |
| 28612 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28613 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 28614 | | .unused, |
| 41616 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41617 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41618 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28615 | 41619 | .unused, |
| 28616 | 41620 | .unused, |
| 28617 | 41621 | .unused, |
| ... | ... | @@ -28619,77 +41623,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28619 | 41623 | .unused, |
| 28620 | 41624 | .unused, |
| 28621 | 41625 | }, |
| 28622 | | .dst_temps = .{.mem}, |
| 28623 | | .clobbers = .{ .eflags = true }, |
| 28624 | | .each = .{ .once = &.{ |
| 28625 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28626 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28627 | | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 28628 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28629 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28630 | | } }, |
| 28631 | | }, .{ |
| 28632 | | .required_features = .{ .avx, null, null, null }, |
| 28633 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28634 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 28635 | | .patterns = &.{ |
| 28636 | | .{ .src = .{ .mem, .none } }, |
| 28637 | | .{ .src = .{ .to_sse, .none } }, |
| 28638 | | }, |
| 28639 | 41626 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28640 | 41627 | .each = .{ .once = &.{ |
| 28641 | | .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 28642 | | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 41628 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41629 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 41630 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 41631 | .{ ._, .vp_b, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 41632 | .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 28643 | 41633 | } }, |
| 28644 | 41634 | }, .{ |
| 28645 | 41635 | .required_features = .{ .avx, null, null, null }, |
| 28646 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28647 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 41636 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41637 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28648 | 41638 | .patterns = &.{ |
| 28649 | | .{ .src = .{ .mem, .none } }, |
| 28650 | | .{ .src = .{ .to_sse, .none } }, |
| 41639 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28651 | 41640 | }, |
| 28652 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28653 | | .each = .{ .once = &.{ |
| 28654 | | .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 28655 | | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 28656 | | } }, |
| 28657 | | }, .{ |
| 28658 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28659 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28660 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 28661 | | .patterns = &.{ |
| 28662 | | .{ .src = .{ .mem, .none } }, |
| 28663 | | .{ .src = .{ .to_sse, .none } }, |
| 41641 | .extra_temps = .{ |
| 41642 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41643 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 41644 | .unused, |
| 41645 | .unused, |
| 41646 | .unused, |
| 41647 | .unused, |
| 41648 | .unused, |
| 41649 | .unused, |
| 41650 | .unused, |
| 28664 | 41651 | }, |
| 28665 | 41652 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28666 | 41653 | .each = .{ .once = &.{ |
| 28667 | | .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 28668 | | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 41654 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41655 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 28669 | 41656 | } }, |
| 28670 | 41657 | }, .{ |
| 28671 | | .required_features = .{ .sse4_1, null, null, null }, |
| 28672 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28673 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 41658 | .required_features = .{ .sse2, null, null, null }, |
| 41659 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41660 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28674 | 41661 | .patterns = &.{ |
| 28675 | | .{ .src = .{ .mem, .none } }, |
| 28676 | | .{ .src = .{ .to_sse, .none } }, |
| 41662 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28677 | 41663 | }, |
| 28678 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 41664 | .extra_temps = .{ |
| 41665 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41666 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41667 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 41668 | .unused, |
| 41669 | .unused, |
| 41670 | .unused, |
| 41671 | .unused, |
| 41672 | .unused, |
| 41673 | .unused, |
| 41674 | }, |
| 41675 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28679 | 41676 | .each = .{ .once = &.{ |
| 28680 | | .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 28681 | | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 41677 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41678 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 41679 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 41680 | .{ ._, .p_b, .add, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 41681 | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 28682 | 41682 | } }, |
| 28683 | 41683 | }, .{ |
| 28684 | 41684 | .required_features = .{ .sse2, null, null, null }, |
| 28685 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28686 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 41685 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41686 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28687 | 41687 | .patterns = &.{ |
| 28688 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 41688 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28689 | 41689 | }, |
| 28690 | 41690 | .extra_temps = .{ |
| 28691 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 28692 | | .unused, |
| 41691 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41692 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 28693 | 41693 | .unused, |
| 28694 | 41694 | .unused, |
| 28695 | 41695 | .unused, |
| ... | ... | @@ -28700,22 +41700,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28700 | 41700 | }, |
| 28701 | 41701 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28702 | 41702 | .each = .{ .once = &.{ |
| 28703 | | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 28704 | | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 28705 | | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 28706 | | .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ }, |
| 28707 | | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 41703 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41704 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 28708 | 41705 | } }, |
| 28709 | 41706 | }, .{ |
| 28710 | | .required_features = .{ .sse2, null, null, null }, |
| 28711 | | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28712 | | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 41707 | .required_features = .{ .sse, null, null, null }, |
| 41708 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41709 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28713 | 41710 | .patterns = &.{ |
| 28714 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 41711 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28715 | 41712 | }, |
| 28716 | 41713 | .extra_temps = .{ |
| 28717 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 28718 | | .unused, |
| 41714 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41715 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 28719 | 41716 | .unused, |
| 28720 | 41717 | .unused, |
| 28721 | 41718 | .unused, |
| ... | ... | @@ -28726,86 +41723,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28726 | 41723 | }, |
| 28727 | 41724 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28728 | 41725 | .each = .{ .once = &.{ |
| 28729 | | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 28730 | | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 28731 | | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 41726 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41727 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 28732 | 41728 | } }, |
| 28733 | 41729 | }, .{ |
| 28734 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28735 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28736 | | .dst_constraints = .{.any_scalar_signed_int}, |
| 41730 | .required_features = .{ .avx2, null, null, null }, |
| 41731 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 41732 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }}, |
| 28737 | 41733 | .patterns = &.{ |
| 28738 | | .{ .src = .{ .to_mem, .none } }, |
| 41734 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28739 | 41735 | }, |
| 28740 | 41736 | .extra_temps = .{ |
| 28741 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28742 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28743 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 28744 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 41737 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41738 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41739 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 41740 | .unused, |
| 28745 | 41741 | .unused, |
| 28746 | 41742 | .unused, |
| 28747 | 41743 | .unused, |
| 28748 | 41744 | .unused, |
| 28749 | 41745 | .unused, |
| 28750 | 41746 | }, |
| 28751 | | .dst_temps = .{.mem}, |
| 28752 | | .clobbers = .{ .eflags = true }, |
| 41747 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28753 | 41748 | .each = .{ .once = &.{ |
| 28754 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28755 | | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 28756 | | .{ .@"0:", ._, .movsxd, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28757 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 28758 | | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 28759 | | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 28760 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28761 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28762 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41749 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41750 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 41751 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 41752 | .{ ._, .vp_b, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 41753 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 28763 | 41754 | } }, |
| 28764 | 41755 | }, .{ |
| 28765 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28766 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 28767 | | .dst_constraints = .{.any_scalar_int}, |
| 41756 | .required_features = .{ .avx2, null, null, null }, |
| 41757 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 41758 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, |
| 28768 | 41759 | .patterns = &.{ |
| 28769 | | .{ .src = .{ .to_mem, .none } }, |
| 41760 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28770 | 41761 | }, |
| 28771 | 41762 | .extra_temps = .{ |
| 28772 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28773 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28774 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28775 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 41763 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 41764 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 41765 | .unused, |
| 41766 | .unused, |
| 28776 | 41767 | .unused, |
| 28777 | 41768 | .unused, |
| 28778 | 41769 | .unused, |
| 28779 | 41770 | .unused, |
| 28780 | 41771 | .unused, |
| 28781 | 41772 | }, |
| 28782 | | .dst_temps = .{.mem}, |
| 28783 | | .clobbers = .{ .eflags = true }, |
| 41773 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28784 | 41774 | .each = .{ .once = &.{ |
| 28785 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 28786 | | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 28787 | | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 28788 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 28789 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28790 | | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 28791 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28792 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28793 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 41775 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 41776 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 28794 | 41777 | } }, |
| 28795 | 41778 | }, .{ |
| 28796 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 28797 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 28798 | | .dst_constraints = .{.any_scalar_signed_int}, |
| 41779 | .required_features = .{ .avx2, null, null, null }, |
| 41780 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 41781 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }}, |
| 28799 | 41782 | .patterns = &.{ |
| 28800 | | .{ .src = .{ .to_mem, .none } }, |
| 41783 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28801 | 41784 | }, |
| 28802 | 41785 | .extra_temps = .{ |
| 28803 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28804 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28805 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28806 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28807 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 28808 | | .unused, |
| 41786 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41787 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 41788 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 41789 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 41790 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41791 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28809 | 41792 | .unused, |
| 28810 | 41793 | .unused, |
| 28811 | 41794 | .unused, |
| ... | ... | @@ -28813,32 +41796,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28813 | 41796 | .dst_temps = .{.mem}, |
| 28814 | 41797 | .clobbers = .{ .eflags = true }, |
| 28815 | 41798 | .each = .{ .once = &.{ |
| 28816 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 28817 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 28818 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 28819 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 28820 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28821 | | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 28822 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 28823 | | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, |
| 28824 | | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 28825 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28826 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 28827 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 41799 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 41800 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 41801 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 41802 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 41803 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41804 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 41805 | .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 41806 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 41807 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 41808 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 41809 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28828 | 41810 | } }, |
| 28829 | 41811 | }, .{ |
| 28830 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28831 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 28832 | | .dst_constraints = .{.any_scalar_signed_int}, |
| 41812 | .required_features = .{ .avx2, null, null, null }, |
| 41813 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 41814 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, |
| 28833 | 41815 | .patterns = &.{ |
| 28834 | | .{ .src = .{ .to_mem, .none } }, |
| 41816 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28835 | 41817 | }, |
| 28836 | 41818 | .extra_temps = .{ |
| 28837 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28838 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28839 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28840 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28841 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 41819 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41820 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 41821 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 41822 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41823 | .unused, |
| 28842 | 41824 | .unused, |
| 28843 | 41825 | .unused, |
| 28844 | 41826 | .unused, |
| ... | ... | @@ -28847,33 +41829,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28847 | 41829 | .dst_temps = .{.mem}, |
| 28848 | 41830 | .clobbers = .{ .eflags = true }, |
| 28849 | 41831 | .each = .{ .once = &.{ |
| 28850 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 28851 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 28852 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 28853 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 28854 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28855 | | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 28856 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 28857 | | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, |
| 28858 | | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 28859 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28860 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 28861 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 41832 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 41833 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 41834 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41835 | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 41836 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 41837 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 41838 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28862 | 41839 | } }, |
| 28863 | 41840 | }, .{ |
| 28864 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 28865 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 28866 | | .dst_constraints = .{.any_scalar_int}, |
| 41841 | .required_features = .{ .avx, null, null, null }, |
| 41842 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41843 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28867 | 41844 | .patterns = &.{ |
| 28868 | | .{ .src = .{ .to_mem, .none } }, |
| 41845 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28869 | 41846 | }, |
| 28870 | 41847 | .extra_temps = .{ |
| 28871 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28872 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28873 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28874 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28875 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28876 | | .unused, |
| 41848 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41849 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 41850 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 41851 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 41852 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41853 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28877 | 41854 | .unused, |
| 28878 | 41855 | .unused, |
| 28879 | 41856 | .unused, |
| ... | ... | @@ -28881,30 +41858,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28881 | 41858 | .dst_temps = .{.mem}, |
| 28882 | 41859 | .clobbers = .{ .eflags = true }, |
| 28883 | 41860 | .each = .{ .once = &.{ |
| 28884 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 28885 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 28886 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 28887 | | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| 28888 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28889 | | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| 28890 | | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 28891 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28892 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 28893 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 41861 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 41862 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 41863 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 41864 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 41865 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41866 | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 41867 | .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 41868 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 41869 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 41870 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 41871 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28894 | 41872 | } }, |
| 28895 | 41873 | }, .{ |
| 28896 | | .required_features = .{ .@"64bit", null, null, null }, |
| 28897 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 28898 | | .dst_constraints = .{.any_scalar_int}, |
| 41874 | .required_features = .{ .avx, null, null, null }, |
| 41875 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41876 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28899 | 41877 | .patterns = &.{ |
| 28900 | | .{ .src = .{ .to_mem, .none } }, |
| 41878 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28901 | 41879 | }, |
| 28902 | 41880 | .extra_temps = .{ |
| 28903 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28904 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28905 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28906 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28907 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 41881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41882 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 41883 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 41884 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41885 | .unused, |
| 28908 | 41886 | .unused, |
| 28909 | 41887 | .unused, |
| 28910 | 41888 | .unused, |
| ... | ... | @@ -28913,342 +41891,425 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28913 | 41891 | .dst_temps = .{.mem}, |
| 28914 | 41892 | .clobbers = .{ .eflags = true }, |
| 28915 | 41893 | .each = .{ .once = &.{ |
| 28916 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 28917 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 28918 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 28919 | | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| 28920 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28921 | | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| 28922 | | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, |
| 28923 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 28924 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 28925 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 28926 | | } }, |
| 28927 | | } }) catch |err| switch (err) { |
| 28928 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 28929 | | @tagName(air_tag), |
| 28930 | | dst_ty.fmt(pt), |
| 28931 | | src_ty.fmt(pt), |
| 28932 | | ops[0].tracking(cg), |
| 28933 | | }), |
| 28934 | | else => |e| return e, |
| 28935 | | }; |
| 28936 | | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 28937 | | }, |
| 28938 | | .trunc => |air_tag| if (use_old) try cg.airTrunc(inst) else { |
| 28939 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 28940 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 28941 | | var res: [1]Temp = undefined; |
| 28942 | | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 28943 | | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, |
| 28944 | | .dst_constraints = .{.{ .exact_signed_int = 1 }}, |
| 28945 | | .patterns = &.{ |
| 28946 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 28947 | | }, |
| 28948 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 28949 | | .clobbers = .{ .eflags = true }, |
| 28950 | | .each = .{ .once = &.{ |
| 28951 | | .{ ._, ._, .@"and", .dst0d, .si(1), ._, ._ }, |
| 28952 | | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 28953 | | } }, |
| 28954 | | }, .{ |
| 28955 | | .src_constraints = .{ .any_signed_int, .any }, |
| 28956 | | .dst_constraints = .{.{ .exact_signed_int = 1 }}, |
| 28957 | | .patterns = &.{ |
| 28958 | | .{ .src = .{ .to_mem, .none } }, |
| 28959 | | }, |
| 28960 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28961 | | .clobbers = .{ .eflags = true }, |
| 28962 | | .each = .{ .once = &.{ |
| 28963 | | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, |
| 28964 | | .{ ._, ._, .@"and", .dst0d, .si(1), ._, ._ }, |
| 28965 | | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 28966 | | } }, |
| 28967 | | }, .{ |
| 28968 | | .src_constraints = .{ .{ .int = .gpr }, .any }, |
| 28969 | | .dst_constraints = .{.{ .exact_int = 8 }}, |
| 28970 | | .patterns = &.{ |
| 28971 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 28972 | | }, |
| 28973 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 28974 | | .each = .{ .once = &.{} }, |
| 28975 | | }, .{ |
| 28976 | | .src_constraints = .{ .any_signed_int, .any }, |
| 28977 | | .dst_constraints = .{.{ .exact_signed_int = 8 }}, |
| 28978 | | .patterns = &.{ |
| 28979 | | .{ .src = .{ .to_mem, .none } }, |
| 28980 | | }, |
| 28981 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28982 | | .each = .{ .once = &.{ |
| 28983 | | .{ ._, ._, .movsx, .dst0d, .mem(.src0b), ._, ._ }, |
| 41894 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 41895 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 41896 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41897 | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 41898 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 41899 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 41900 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28984 | 41901 | } }, |
| 28985 | 41902 | }, .{ |
| 28986 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 28987 | | .dst_constraints = .{.{ .exact_unsigned_int = 8 }}, |
| 41903 | .required_features = .{ .sse2, null, null, null }, |
| 41904 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41905 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28988 | 41906 | .patterns = &.{ |
| 28989 | | .{ .src = .{ .to_mem, .none } }, |
| 41907 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28990 | 41908 | }, |
| 28991 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28992 | | .each = .{ .once = &.{ |
| 28993 | | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, |
| 28994 | | } }, |
| 28995 | | }, .{ |
| 28996 | | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, |
| 28997 | | .dst_constraints = .{.{ .signed_int = .byte }}, |
| 28998 | | .patterns = &.{ |
| 28999 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 41909 | .extra_temps = .{ |
| 41910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41911 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 41912 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 41913 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 41914 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41915 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 41916 | .unused, |
| 41917 | .unused, |
| 41918 | .unused, |
| 29000 | 41919 | }, |
| 29001 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 41920 | .dst_temps = .{.mem}, |
| 29002 | 41921 | .clobbers = .{ .eflags = true }, |
| 29003 | 41922 | .each = .{ .once = &.{ |
| 29004 | | .{ ._, ._l, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29005 | | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 41923 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 41924 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 41925 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 41926 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 41927 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41928 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ }, |
| 41929 | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 41930 | .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ }, |
| 41931 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| 41932 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 41933 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 41934 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29006 | 41935 | } }, |
| 29007 | 41936 | }, .{ |
| 29008 | | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, |
| 29009 | | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 41937 | .required_features = .{ .sse2, null, null, null }, |
| 41938 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41939 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 29010 | 41940 | .patterns = &.{ |
| 29011 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 41941 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29012 | 41942 | }, |
| 29013 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 29014 | | .clobbers = .{ .eflags = true }, |
| 29015 | | .each = .{ .once = &.{ |
| 29016 | | .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29017 | | } }, |
| 29018 | | }, .{ |
| 29019 | | .src_constraints = .{ .any_int, .any }, |
| 29020 | | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 29021 | | .patterns = &.{ |
| 29022 | | .{ .src = .{ .to_mem, .none } }, |
| 41943 | .extra_temps = .{ |
| 41944 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41945 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 41946 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 41947 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41948 | .unused, |
| 41949 | .unused, |
| 41950 | .unused, |
| 41951 | .unused, |
| 41952 | .unused, |
| 29023 | 41953 | }, |
| 29024 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41954 | .dst_temps = .{.mem}, |
| 29025 | 41955 | .clobbers = .{ .eflags = true }, |
| 29026 | 41956 | .each = .{ .once = &.{ |
| 29027 | | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, |
| 29028 | | .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ }, |
| 41957 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 41958 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 41959 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41960 | .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 41961 | .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 41962 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 41963 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 41964 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29029 | 41965 | } }, |
| 29030 | 41966 | }, .{ |
| 29031 | | .src_constraints = .{ .{ .int = .gpr }, .any }, |
| 29032 | | .dst_constraints = .{.{ .exact_int = 16 }}, |
| 41967 | .required_features = .{ .sse, null, null, null }, |
| 41968 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 41969 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 29033 | 41970 | .patterns = &.{ |
| 29034 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 41971 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29035 | 41972 | }, |
| 29036 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 29037 | | .each = .{ .once = &.{} }, |
| 29038 | | }, .{ |
| 29039 | | .src_constraints = .{ .any_signed_int, .any }, |
| 29040 | | .dst_constraints = .{.{ .exact_signed_int = 16 }}, |
| 29041 | | .patterns = &.{ |
| 29042 | | .{ .src = .{ .to_mem, .none } }, |
| 41973 | .extra_temps = .{ |
| 41974 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 41975 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 41976 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 41977 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 41978 | .unused, |
| 41979 | .unused, |
| 41980 | .unused, |
| 41981 | .unused, |
| 41982 | .unused, |
| 29043 | 41983 | }, |
| 29044 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 41984 | .dst_temps = .{.mem}, |
| 41985 | .clobbers = .{ .eflags = true }, |
| 29045 | 41986 | .each = .{ .once = &.{ |
| 29046 | | .{ ._, ._, .movsx, .dst0d, .mem(.src0w), ._, ._ }, |
| 41987 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 41988 | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 41989 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 41990 | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 41991 | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 41992 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 41993 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 41994 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29047 | 41995 | } }, |
| 29048 | 41996 | }, .{ |
| 29049 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29050 | | .dst_constraints = .{.{ .exact_unsigned_int = 16 }}, |
| 41997 | .required_features = .{ .slow_incdec, null, null, null }, |
| 41998 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 41999 | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, |
| 29051 | 42000 | .patterns = &.{ |
| 29052 | | .{ .src = .{ .to_mem, .none } }, |
| 42001 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29053 | 42002 | }, |
| 29054 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 29055 | | .each = .{ .once = &.{ |
| 29056 | | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, |
| 29057 | | } }, |
| 29058 | | }, .{ |
| 29059 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 29060 | | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, |
| 29061 | | .dst_constraints = .{.{ .unsigned_int = .word }}, |
| 29062 | | .patterns = &.{ |
| 29063 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 42003 | .extra_temps = .{ |
| 42004 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42005 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42006 | .unused, |
| 42007 | .unused, |
| 42008 | .unused, |
| 42009 | .unused, |
| 42010 | .unused, |
| 42011 | .unused, |
| 42012 | .unused, |
| 29064 | 42013 | }, |
| 29065 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42014 | .dst_temps = .{.mem}, |
| 29066 | 42015 | .clobbers = .{ .eflags = true }, |
| 29067 | 42016 | .each = .{ .once = &.{ |
| 29068 | | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, |
| 42017 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42018 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 42019 | .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ }, |
| 42020 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 42021 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42022 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42023 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29069 | 42024 | } }, |
| 29070 | 42025 | }, .{ |
| 29071 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 29072 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29073 | | .dst_constraints = .{.{ .unsigned_int = .word }}, |
| 42026 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 42027 | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, |
| 29074 | 42028 | .patterns = &.{ |
| 29075 | | .{ .src = .{ .to_mem, .none } }, |
| 42029 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29076 | 42030 | }, |
| 29077 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42031 | .extra_temps = .{ |
| 42032 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42033 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42034 | .unused, |
| 42035 | .unused, |
| 42036 | .unused, |
| 42037 | .unused, |
| 42038 | .unused, |
| 42039 | .unused, |
| 42040 | .unused, |
| 42041 | }, |
| 42042 | .dst_temps = .{.mem}, |
| 29078 | 42043 | .clobbers = .{ .eflags = true }, |
| 29079 | 42044 | .each = .{ .once = &.{ |
| 29080 | | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, |
| 29081 | | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, |
| 42045 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42046 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 42047 | .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ }, |
| 42048 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 42049 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42050 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42051 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29082 | 42052 | } }, |
| 29083 | 42053 | }, .{ |
| 29084 | | .src_constraints = .{ .{ .int = .gpr }, .any }, |
| 29085 | | .dst_constraints = .{.{ .exact_int = 32 }}, |
| 29086 | | .patterns = &.{ |
| 29087 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 29088 | | }, |
| 29089 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 29090 | | .each = .{ .once = &.{} }, |
| 29091 | | }, .{ |
| 29092 | | .src_constraints = .{ .any_int, .any }, |
| 29093 | | .dst_constraints = .{.{ .exact_int = 32 }}, |
| 42054 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42055 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 42056 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29094 | 42057 | .patterns = &.{ |
| 29095 | | .{ .src = .{ .to_mem, .none } }, |
| 42058 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29096 | 42059 | }, |
| 29097 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 29098 | | .each = .{ .once = &.{ |
| 29099 | | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 29100 | | } }, |
| 29101 | | }, .{ |
| 29102 | | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, |
| 29103 | | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 29104 | | .patterns = &.{ |
| 29105 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 42060 | .extra_temps = .{ |
| 42061 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42062 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42063 | .unused, |
| 42064 | .unused, |
| 42065 | .unused, |
| 42066 | .unused, |
| 42067 | .unused, |
| 42068 | .unused, |
| 42069 | .unused, |
| 29106 | 42070 | }, |
| 29107 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42071 | .dst_temps = .{.mem}, |
| 29108 | 42072 | .clobbers = .{ .eflags = true }, |
| 29109 | 42073 | .each = .{ .once = &.{ |
| 29110 | | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 29111 | | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 42074 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42075 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 42076 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42077 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42078 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42079 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42080 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29112 | 42081 | } }, |
| 29113 | 42082 | }, .{ |
| 29114 | | .src_constraints = .{ .any_signed_int, .any }, |
| 29115 | | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 42083 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 42084 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29116 | 42085 | .patterns = &.{ |
| 29117 | | .{ .src = .{ .to_mem, .none } }, |
| 42086 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29118 | 42087 | }, |
| 29119 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 29120 | | .clobbers = .{ .eflags = true }, |
| 29121 | | .each = .{ .once = &.{ |
| 29122 | | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 29123 | | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 29124 | | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 29125 | | } }, |
| 29126 | | }, .{ |
| 29127 | | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, |
| 29128 | | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 29129 | | .patterns = &.{ |
| 29130 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 42088 | .extra_temps = .{ |
| 42089 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42090 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42091 | .unused, |
| 42092 | .unused, |
| 42093 | .unused, |
| 42094 | .unused, |
| 42095 | .unused, |
| 42096 | .unused, |
| 42097 | .unused, |
| 29131 | 42098 | }, |
| 29132 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42099 | .dst_temps = .{.mem}, |
| 29133 | 42100 | .clobbers = .{ .eflags = true }, |
| 29134 | 42101 | .each = .{ .once = &.{ |
| 29135 | | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, |
| 42102 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42103 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 42104 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42105 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42106 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42107 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42108 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29136 | 42109 | } }, |
| 29137 | 42110 | }, .{ |
| 29138 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29139 | | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 42111 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42112 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 42113 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29140 | 42114 | .patterns = &.{ |
| 29141 | | .{ .src = .{ .to_mem, .none } }, |
| 42115 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29142 | 42116 | }, |
| 29143 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42117 | .extra_temps = .{ |
| 42118 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42119 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42120 | .unused, |
| 42121 | .unused, |
| 42122 | .unused, |
| 42123 | .unused, |
| 42124 | .unused, |
| 42125 | .unused, |
| 42126 | .unused, |
| 42127 | }, |
| 42128 | .dst_temps = .{.mem}, |
| 29144 | 42129 | .clobbers = .{ .eflags = true }, |
| 29145 | 42130 | .each = .{ .once = &.{ |
| 29146 | | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 29147 | | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, |
| 42131 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42132 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 42133 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42134 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42135 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42136 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29148 | 42137 | } }, |
| 29149 | 42138 | }, .{ |
| 29150 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29151 | | .src_constraints = .{ .any_int, .any }, |
| 29152 | | .dst_constraints = .{.{ .exact_int = 64 }}, |
| 42139 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 42140 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29153 | 42141 | .patterns = &.{ |
| 29154 | | .{ .src = .{ .to_mem, .none } }, |
| 42142 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29155 | 42143 | }, |
| 29156 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 29157 | | .each = .{ .once = &.{ |
| 29158 | | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 29159 | | } }, |
| 29160 | | }, .{ |
| 29161 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29162 | | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, |
| 29163 | | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 29164 | | .patterns = &.{ |
| 29165 | | .{ .src = .{ .to_mut_gpr, .none } }, |
| 42144 | .extra_temps = .{ |
| 42145 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42146 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42147 | .unused, |
| 42148 | .unused, |
| 42149 | .unused, |
| 42150 | .unused, |
| 42151 | .unused, |
| 42152 | .unused, |
| 42153 | .unused, |
| 29166 | 42154 | }, |
| 29167 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42155 | .dst_temps = .{.mem}, |
| 29168 | 42156 | .clobbers = .{ .eflags = true }, |
| 29169 | 42157 | .each = .{ .once = &.{ |
| 29170 | | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 29171 | | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 42158 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42159 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 42160 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42161 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42162 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42163 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29172 | 42164 | } }, |
| 29173 | 42165 | }, .{ |
| 29174 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29175 | | .src_constraints = .{ .any_signed_int, .any }, |
| 29176 | | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 42166 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42167 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 42168 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29177 | 42169 | .patterns = &.{ |
| 29178 | | .{ .src = .{ .to_mem, .none } }, |
| 42170 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29179 | 42171 | }, |
| 29180 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42172 | .extra_temps = .{ |
| 42173 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42174 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42175 | .unused, |
| 42176 | .unused, |
| 42177 | .unused, |
| 42178 | .unused, |
| 42179 | .unused, |
| 42180 | .unused, |
| 42181 | .unused, |
| 42182 | }, |
| 42183 | .dst_temps = .{.mem}, |
| 29181 | 42184 | .clobbers = .{ .eflags = true }, |
| 29182 | 42185 | .each = .{ .once = &.{ |
| 29183 | | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 29184 | | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 29185 | | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 42186 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42187 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42188 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42189 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42190 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29186 | 42191 | } }, |
| 29187 | 42192 | }, .{ |
| 29188 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 29189 | | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, |
| 29190 | | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 42193 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 42194 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29191 | 42195 | .patterns = &.{ |
| 29192 | | .{ .src = .{ .mem, .none } }, |
| 29193 | | .{ .src = .{ .to_gpr, .none } }, |
| 42196 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29194 | 42197 | }, |
| 29195 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42198 | .extra_temps = .{ |
| 42199 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42200 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42201 | .unused, |
| 42202 | .unused, |
| 42203 | .unused, |
| 42204 | .unused, |
| 42205 | .unused, |
| 42206 | .unused, |
| 42207 | .unused, |
| 42208 | }, |
| 42209 | .dst_temps = .{.mem}, |
| 29196 | 42210 | .clobbers = .{ .eflags = true }, |
| 29197 | 42211 | .each = .{ .once = &.{ |
| 29198 | | .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29199 | | .{ ._, ._, .bzhi, .dst0q, .src0q, .dst0q, ._ }, |
| 42212 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42213 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42214 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42215 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42216 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29200 | 42217 | } }, |
| 29201 | 42218 | }, .{ |
| 29202 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 29203 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29204 | | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 42219 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42220 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 42221 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29205 | 42222 | .patterns = &.{ |
| 29206 | | .{ .src = .{ .to_mem, .none } }, |
| 42223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29207 | 42224 | }, |
| 29208 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42225 | .extra_temps = .{ |
| 42226 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42227 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42228 | .unused, |
| 42229 | .unused, |
| 42230 | .unused, |
| 42231 | .unused, |
| 42232 | .unused, |
| 42233 | .unused, |
| 42234 | .unused, |
| 42235 | }, |
| 42236 | .dst_temps = .{.mem}, |
| 29209 | 42237 | .clobbers = .{ .eflags = true }, |
| 29210 | 42238 | .each = .{ .once = &.{ |
| 29211 | | .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29212 | | .{ ._, ._, .bzhi, .dst0q, .mem(.src0q), .dst0q, ._ }, |
| 42239 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42240 | .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42241 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42242 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42243 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42244 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42245 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29213 | 42246 | } }, |
| 29214 | 42247 | }, .{ |
| 29215 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29216 | | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, |
| 29217 | | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 42248 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 42249 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29218 | 42250 | .patterns = &.{ |
| 29219 | | .{ .src = .{ .mem, .none } }, |
| 29220 | | .{ .src = .{ .to_gpr, .none } }, |
| 42251 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29221 | 42252 | }, |
| 29222 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42253 | .extra_temps = .{ |
| 42254 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42255 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42256 | .unused, |
| 42257 | .unused, |
| 42258 | .unused, |
| 42259 | .unused, |
| 42260 | .unused, |
| 42261 | .unused, |
| 42262 | .unused, |
| 42263 | }, |
| 42264 | .dst_temps = .{.mem}, |
| 29223 | 42265 | .clobbers = .{ .eflags = true }, |
| 29224 | 42266 | .each = .{ .once = &.{ |
| 29225 | | .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 29226 | | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| 42267 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42268 | .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42269 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42270 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42271 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42272 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42273 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29227 | 42274 | } }, |
| 29228 | 42275 | }, .{ |
| 29229 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29230 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29231 | | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 42276 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42277 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 42278 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29232 | 42279 | .patterns = &.{ |
| 29233 | | .{ .src = .{ .to_mem, .none } }, |
| 42280 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29234 | 42281 | }, |
| 29235 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 42282 | .extra_temps = .{ |
| 42283 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42284 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42285 | .unused, |
| 42286 | .unused, |
| 42287 | .unused, |
| 42288 | .unused, |
| 42289 | .unused, |
| 42290 | .unused, |
| 42291 | .unused, |
| 42292 | }, |
| 42293 | .dst_temps = .{.mem}, |
| 29236 | 42294 | .clobbers = .{ .eflags = true }, |
| 29237 | 42295 | .each = .{ .once = &.{ |
| 29238 | | .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 29239 | | .{ ._, ._, .@"and", .dst0q, .mem(.src0q), ._, ._ }, |
| 42296 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42297 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42298 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42299 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42300 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42301 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29240 | 42302 | } }, |
| 29241 | 42303 | }, .{ |
| 29242 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29243 | | .src_constraints = .{ .any_int, .any }, |
| 29244 | | .dst_constraints = .{.{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 42304 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 42305 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29245 | 42306 | .patterns = &.{ |
| 29246 | | .{ .src = .{ .to_mem, .none } }, |
| 42307 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29247 | 42308 | }, |
| 29248 | 42309 | .extra_temps = .{ |
| 29249 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29250 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29251 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42310 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42311 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42312 | .unused, |
| 29252 | 42313 | .unused, |
| 29253 | 42314 | .unused, |
| 29254 | 42315 | .unused, |
| ... | ... | @@ -29257,23 +42318,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29257 | 42318 | .unused, |
| 29258 | 42319 | }, |
| 29259 | 42320 | .dst_temps = .{.mem}, |
| 42321 | .clobbers = .{ .eflags = true }, |
| 29260 | 42322 | .each = .{ .once = &.{ |
| 29261 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29262 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29263 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| 29264 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 42323 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42324 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42325 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42326 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42327 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42328 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29265 | 42329 | } }, |
| 29266 | 42330 | }, .{ |
| 29267 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29268 | | .src_constraints = .{ .any_signed_int, .any }, |
| 29269 | | .dst_constraints = .{.{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 42331 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42332 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42333 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29270 | 42334 | .patterns = &.{ |
| 29271 | | .{ .src = .{ .to_mem, .none } }, |
| 42335 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29272 | 42336 | }, |
| 29273 | 42337 | .extra_temps = .{ |
| 29274 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29275 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29276 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42338 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42339 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42340 | .unused, |
| 29277 | 42341 | .unused, |
| 29278 | 42342 | .unused, |
| 29279 | 42343 | .unused, |
| ... | ... | @@ -29284,26 +42348,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29284 | 42348 | .dst_temps = .{.mem}, |
| 29285 | 42349 | .clobbers = .{ .eflags = true }, |
| 29286 | 42350 | .each = .{ .once = &.{ |
| 29287 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29288 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29289 | | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 29290 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29291 | | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 29292 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| 29293 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 29294 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 42351 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42352 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42353 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42354 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42355 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29295 | 42356 | } }, |
| 29296 | 42357 | }, .{ |
| 29297 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29298 | | .src_constraints = .{ .any_signed_int, .any }, |
| 29299 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 42358 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42359 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29300 | 42360 | .patterns = &.{ |
| 29301 | | .{ .src = .{ .to_mem, .none } }, |
| 42361 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29302 | 42362 | }, |
| 29303 | 42363 | .extra_temps = .{ |
| 29304 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29305 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29306 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42364 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42365 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42366 | .unused, |
| 29307 | 42367 | .unused, |
| 29308 | 42368 | .unused, |
| 29309 | 42369 | .unused, |
| ... | ... | @@ -29314,28 +42374,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29314 | 42374 | .dst_temps = .{.mem}, |
| 29315 | 42375 | .clobbers = .{ .eflags = true }, |
| 29316 | 42376 | .each = .{ .once = &.{ |
| 29317 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29318 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29319 | | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 29320 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29321 | | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 29322 | | .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 29323 | | .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 29324 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| 29325 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 29326 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 42377 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42378 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42379 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42380 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42381 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29327 | 42382 | } }, |
| 29328 | 42383 | }, .{ |
| 29329 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29330 | | .src_constraints = .{ .any_signed_int, .any }, |
| 29331 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 42384 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42385 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42386 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29332 | 42387 | .patterns = &.{ |
| 29333 | | .{ .src = .{ .to_mem, .none } }, |
| 42388 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29334 | 42389 | }, |
| 29335 | 42390 | .extra_temps = .{ |
| 29336 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29337 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29338 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42391 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42392 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42393 | .unused, |
| 29339 | 42394 | .unused, |
| 29340 | 42395 | .unused, |
| 29341 | 42396 | .unused, |
| ... | ... | @@ -29346,26 +42401,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29346 | 42401 | .dst_temps = .{.mem}, |
| 29347 | 42402 | .clobbers = .{ .eflags = true }, |
| 29348 | 42403 | .each = .{ .once = &.{ |
| 29349 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29350 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29351 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 29352 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29353 | | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 29354 | | .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 29355 | | .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 29356 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 42404 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42405 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42406 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42407 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42408 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42409 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42410 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29357 | 42411 | } }, |
| 29358 | 42412 | }, .{ |
| 29359 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29360 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29361 | | .dst_constraints = .{.{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 42413 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42414 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29362 | 42415 | .patterns = &.{ |
| 29363 | | .{ .src = .{ .to_mem, .none } }, |
| 42416 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29364 | 42417 | }, |
| 29365 | 42418 | .extra_temps = .{ |
| 29366 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29367 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29368 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42419 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42420 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42421 | .unused, |
| 29369 | 42422 | .unused, |
| 29370 | 42423 | .unused, |
| 29371 | 42424 | .unused, |
| ... | ... | @@ -29374,24 +42427,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29374 | 42427 | .unused, |
| 29375 | 42428 | }, |
| 29376 | 42429 | .dst_temps = .{.mem}, |
| 42430 | .clobbers = .{ .eflags = true }, |
| 29377 | 42431 | .each = .{ .once = &.{ |
| 29378 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29379 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29380 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 29381 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29382 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 42432 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42433 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42434 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42435 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42436 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42437 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42438 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29383 | 42439 | } }, |
| 29384 | 42440 | }, .{ |
| 29385 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 29386 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29387 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 42441 | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 42442 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42443 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29388 | 42444 | .patterns = &.{ |
| 29389 | | .{ .src = .{ .to_mem, .none } }, |
| 42445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29390 | 42446 | }, |
| 29391 | 42447 | .extra_temps = .{ |
| 29392 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29393 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29394 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42449 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42450 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29395 | 42451 | .unused, |
| 29396 | 42452 | .unused, |
| 29397 | 42453 | .unused, |
| ... | ... | @@ -29402,26 +42458,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29402 | 42458 | .dst_temps = .{.mem}, |
| 29403 | 42459 | .clobbers = .{ .eflags = true }, |
| 29404 | 42460 | .each = .{ .once = &.{ |
| 29405 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29406 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29407 | | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 29408 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29409 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 29410 | | .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_size, -16), .tmp2q, ._ }, |
| 29411 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp2q, ._, ._ }, |
| 29412 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 42461 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42462 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 42463 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 42464 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42465 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42466 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29413 | 42467 | } }, |
| 29414 | 42468 | }, .{ |
| 29415 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 29416 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29417 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 42469 | .required_features = .{ .bmi2, null, null, null }, |
| 42470 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42471 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29418 | 42472 | .patterns = &.{ |
| 29419 | | .{ .src = .{ .to_mem, .none } }, |
| 42473 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29420 | 42474 | }, |
| 29421 | 42475 | .extra_temps = .{ |
| 29422 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29423 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29424 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42477 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42478 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29425 | 42479 | .unused, |
| 29426 | 42480 | .unused, |
| 29427 | 42481 | .unused, |
| ... | ... | @@ -29432,25 +42486,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29432 | 42486 | .dst_temps = .{.mem}, |
| 29433 | 42487 | .clobbers = .{ .eflags = true }, |
| 29434 | 42488 | .each = .{ .once = &.{ |
| 29435 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29436 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29437 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 29438 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29439 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 29440 | | .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_size, -8), .tmp2q, ._ }, |
| 29441 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| 42489 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42490 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 42491 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 42492 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42493 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42494 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29442 | 42495 | } }, |
| 29443 | 42496 | }, .{ |
| 29444 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29445 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29446 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 42497 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42498 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42499 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29447 | 42500 | .patterns = &.{ |
| 29448 | | .{ .src = .{ .to_mem, .none } }, |
| 42501 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29449 | 42502 | }, |
| 29450 | 42503 | .extra_temps = .{ |
| 29451 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29452 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29453 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42505 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42506 | .unused, |
| 29454 | 42507 | .unused, |
| 29455 | 42508 | .unused, |
| 29456 | 42509 | .unused, |
| ... | ... | @@ -29461,26 +42514,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29461 | 42514 | .dst_temps = .{.mem}, |
| 29462 | 42515 | .clobbers = .{ .eflags = true }, |
| 29463 | 42516 | .each = .{ .once = &.{ |
| 29464 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29465 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29466 | | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 29467 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29468 | | .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 29469 | | .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 29470 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, |
| 29471 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 42517 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42518 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42519 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42520 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42521 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42522 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29472 | 42523 | } }, |
| 29473 | 42524 | }, .{ |
| 29474 | | .required_features = .{ .@"64bit", null, null, null }, |
| 29475 | | .src_constraints = .{ .any_unsigned_int, .any }, |
| 29476 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 42525 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 42526 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29477 | 42527 | .patterns = &.{ |
| 29478 | | .{ .src = .{ .to_mem, .none } }, |
| 42528 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29479 | 42529 | }, |
| 29480 | 42530 | .extra_temps = .{ |
| 29481 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 29482 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 29483 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 42531 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42532 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42533 | .unused, |
| 29484 | 42534 | .unused, |
| 29485 | 42535 | .unused, |
| 29486 | 42536 | .unused, |
| ... | ... | @@ -29491,25 +42541,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29491 | 42541 | .dst_temps = .{.mem}, |
| 29492 | 42542 | .clobbers = .{ .eflags = true }, |
| 29493 | 42543 | .each = .{ .once = &.{ |
| 29494 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 29495 | | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 29496 | | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 29497 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 29498 | | .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ }, |
| 29499 | | .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 29500 | | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| 42544 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42545 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42546 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42547 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42548 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42549 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29501 | 42550 | } }, |
| 29502 | 42551 | }, .{ |
| 29503 | | .required_features = .{ .avx, null, null, null }, |
| 29504 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29505 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 42552 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42553 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42554 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29506 | 42555 | .patterns = &.{ |
| 29507 | | .{ .src = .{ .to_sse, .none } }, |
| 42556 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29508 | 42557 | }, |
| 29509 | 42558 | .extra_temps = .{ |
| 29510 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29511 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29512 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 42559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42560 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42561 | .unused, |
| 29513 | 42562 | .unused, |
| 29514 | 42563 | .unused, |
| 29515 | 42564 | .unused, |
| ... | ... | @@ -29517,24 +42566,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29517 | 42566 | .unused, |
| 29518 | 42567 | .unused, |
| 29519 | 42568 | }, |
| 29520 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 42569 | .dst_temps = .{.mem}, |
| 42570 | .clobbers = .{ .eflags = true }, |
| 29521 | 42571 | .each = .{ .once = &.{ |
| 29522 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29523 | | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 29524 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 29525 | | .{ ._, .vp_b, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 29526 | | .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 42572 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42573 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42574 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42575 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42576 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29527 | 42577 | } }, |
| 29528 | 42578 | }, .{ |
| 29529 | | .required_features = .{ .avx, null, null, null }, |
| 29530 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29531 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 42579 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42580 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29532 | 42581 | .patterns = &.{ |
| 29533 | | .{ .src = .{ .to_sse, .none } }, |
| 42582 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29534 | 42583 | }, |
| 29535 | 42584 | .extra_temps = .{ |
| 29536 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29537 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 42585 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42586 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29538 | 42587 | .unused, |
| 29539 | 42588 | .unused, |
| 29540 | 42589 | .unused, |
| ... | ... | @@ -29543,22 +42592,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29543 | 42592 | .unused, |
| 29544 | 42593 | .unused, |
| 29545 | 42594 | }, |
| 29546 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 42595 | .dst_temps = .{.mem}, |
| 42596 | .clobbers = .{ .eflags = true }, |
| 29547 | 42597 | .each = .{ .once = &.{ |
| 29548 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29549 | | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 42598 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42599 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42600 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42601 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42602 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29550 | 42603 | } }, |
| 29551 | 42604 | }, .{ |
| 29552 | | .required_features = .{ .sse2, null, null, null }, |
| 29553 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29554 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 42605 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42606 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42607 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29555 | 42608 | .patterns = &.{ |
| 29556 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 42609 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29557 | 42610 | }, |
| 29558 | 42611 | .extra_temps = .{ |
| 29559 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29560 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29561 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 42612 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42613 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42614 | .unused, |
| 29562 | 42615 | .unused, |
| 29563 | 42616 | .unused, |
| 29564 | 42617 | .unused, |
| ... | ... | @@ -29566,24 +42619,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29566 | 42619 | .unused, |
| 29567 | 42620 | .unused, |
| 29568 | 42621 | }, |
| 29569 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42622 | .dst_temps = .{.mem}, |
| 42623 | .clobbers = .{ .eflags = true }, |
| 29570 | 42624 | .each = .{ .once = &.{ |
| 29571 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29572 | | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 29573 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 29574 | | .{ ._, .p_b, .add, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 29575 | | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 42625 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42626 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42627 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42628 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42629 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42630 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42631 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29576 | 42632 | } }, |
| 29577 | 42633 | }, .{ |
| 29578 | | .required_features = .{ .sse2, null, null, null }, |
| 29579 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29580 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 42634 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42635 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29581 | 42636 | .patterns = &.{ |
| 29582 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 42637 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29583 | 42638 | }, |
| 29584 | 42639 | .extra_temps = .{ |
| 29585 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29586 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 42640 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42641 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29587 | 42642 | .unused, |
| 29588 | 42643 | .unused, |
| 29589 | 42644 | .unused, |
| ... | ... | @@ -29592,22 +42647,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29592 | 42647 | .unused, |
| 29593 | 42648 | .unused, |
| 29594 | 42649 | }, |
| 29595 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42650 | .dst_temps = .{.mem}, |
| 42651 | .clobbers = .{ .eflags = true }, |
| 29596 | 42652 | .each = .{ .once = &.{ |
| 29597 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29598 | | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 42653 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42654 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42655 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42656 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42657 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42658 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42659 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29599 | 42660 | } }, |
| 29600 | 42661 | }, .{ |
| 29601 | | .required_features = .{ .sse, null, null, null }, |
| 29602 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29603 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 42662 | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 42663 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42664 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29604 | 42665 | .patterns = &.{ |
| 29605 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 42666 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29606 | 42667 | }, |
| 29607 | 42668 | .extra_temps = .{ |
| 29608 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29609 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 29610 | | .unused, |
| 42669 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42670 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42671 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29611 | 42672 | .unused, |
| 29612 | 42673 | .unused, |
| 29613 | 42674 | .unused, |
| ... | ... | @@ -29615,22 +42676,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29615 | 42676 | .unused, |
| 29616 | 42677 | .unused, |
| 29617 | 42678 | }, |
| 29618 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 42679 | .dst_temps = .{.mem}, |
| 42680 | .clobbers = .{ .eflags = true }, |
| 29619 | 42681 | .each = .{ .once = &.{ |
| 29620 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29621 | | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 42682 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42683 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 42684 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 42685 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42686 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42687 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29622 | 42688 | } }, |
| 29623 | 42689 | }, .{ |
| 29624 | | .required_features = .{ .avx2, null, null, null }, |
| 29625 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 29626 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }}, |
| 42690 | .required_features = .{ .bmi2, null, null, null }, |
| 42691 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42692 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29627 | 42693 | .patterns = &.{ |
| 29628 | | .{ .src = .{ .to_sse, .none } }, |
| 42694 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29629 | 42695 | }, |
| 29630 | 42696 | .extra_temps = .{ |
| 29631 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29632 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29633 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 42697 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42698 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42699 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29634 | 42700 | .unused, |
| 29635 | 42701 | .unused, |
| 29636 | 42702 | .unused, |
| ... | ... | @@ -29638,24 +42704,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29638 | 42704 | .unused, |
| 29639 | 42705 | .unused, |
| 29640 | 42706 | }, |
| 29641 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 42707 | .dst_temps = .{.mem}, |
| 42708 | .clobbers = .{ .eflags = true }, |
| 29642 | 42709 | .each = .{ .once = &.{ |
| 29643 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29644 | | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 29645 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 29646 | | .{ ._, .vp_b, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 29647 | | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 42710 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42711 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 42712 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 42713 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42714 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42715 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29648 | 42716 | } }, |
| 29649 | 42717 | }, .{ |
| 29650 | | .required_features = .{ .avx2, null, null, null }, |
| 29651 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 29652 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, |
| 42718 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42719 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42720 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29653 | 42721 | .patterns = &.{ |
| 29654 | | .{ .src = .{ .to_sse, .none } }, |
| 42722 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29655 | 42723 | }, |
| 29656 | 42724 | .extra_temps = .{ |
| 29657 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29658 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 42725 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 42726 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29659 | 42727 | .unused, |
| 29660 | 42728 | .unused, |
| 29661 | 42729 | .unused, |
| ... | ... | @@ -29664,25 +42732,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29664 | 42732 | .unused, |
| 29665 | 42733 | .unused, |
| 29666 | 42734 | }, |
| 29667 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 42735 | .dst_temps = .{.mem}, |
| 42736 | .clobbers = .{ .eflags = true }, |
| 29668 | 42737 | .each = .{ .once = &.{ |
| 29669 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29670 | | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 42738 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 42739 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42740 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42741 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42742 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 42743 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29671 | 42744 | } }, |
| 29672 | 42745 | }, .{ |
| 29673 | | .required_features = .{ .avx2, null, null, null }, |
| 29674 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 29675 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }}, |
| 42746 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 42747 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29676 | 42748 | .patterns = &.{ |
| 29677 | | .{ .src = .{ .to_mem, .none } }, |
| 42749 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29678 | 42750 | }, |
| 29679 | 42751 | .extra_temps = .{ |
| 29680 | 42752 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29681 | | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 29682 | | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 29683 | | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 29684 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29685 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 42753 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42754 | .unused, |
| 42755 | .unused, |
| 42756 | .unused, |
| 42757 | .unused, |
| 29686 | 42758 | .unused, |
| 29687 | 42759 | .unused, |
| 29688 | 42760 | .unused, |
| ... | ... | @@ -29690,30 +42762,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29690 | 42762 | .dst_temps = .{.mem}, |
| 29691 | 42763 | .clobbers = .{ .eflags = true }, |
| 29692 | 42764 | .each = .{ .once = &.{ |
| 29693 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 29694 | | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 29695 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 29696 | | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 29697 | 42765 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29698 | | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 29699 | | .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 29700 | | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 29701 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 29702 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 29703 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 42766 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 42767 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42768 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42769 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42770 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29704 | 42771 | } }, |
| 29705 | 42772 | }, .{ |
| 29706 | | .required_features = .{ .avx2, null, null, null }, |
| 29707 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any }, |
| 29708 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, |
| 42773 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42774 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 42775 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29709 | 42776 | .patterns = &.{ |
| 29710 | | .{ .src = .{ .to_mem, .none } }, |
| 42777 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29711 | 42778 | }, |
| 29712 | 42779 | .extra_temps = .{ |
| 29713 | 42780 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29714 | | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 29715 | | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 29716 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 42781 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42782 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42783 | .unused, |
| 29717 | 42784 | .unused, |
| 29718 | 42785 | .unused, |
| 29719 | 42786 | .unused, |
| ... | ... | @@ -29723,28 +42790,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29723 | 42790 | .dst_temps = .{.mem}, |
| 29724 | 42791 | .clobbers = .{ .eflags = true }, |
| 29725 | 42792 | .each = .{ .once = &.{ |
| 29726 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 29727 | | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 29728 | 42793 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29729 | | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 29730 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 29731 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 42794 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42795 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 42796 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42797 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 42798 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29732 | 42799 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29733 | 42800 | } }, |
| 29734 | 42801 | }, .{ |
| 29735 | | .required_features = .{ .avx, null, null, null }, |
| 29736 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29737 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 42802 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 42803 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29738 | 42804 | .patterns = &.{ |
| 29739 | | .{ .src = .{ .to_mem, .none } }, |
| 42805 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29740 | 42806 | }, |
| 29741 | 42807 | .extra_temps = .{ |
| 29742 | 42808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29743 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 29744 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 29745 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 29746 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29747 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 42809 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42810 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42811 | .unused, |
| 42812 | .unused, |
| 42813 | .unused, |
| 29748 | 42814 | .unused, |
| 29749 | 42815 | .unused, |
| 29750 | 42816 | .unused, |
| ... | ... | @@ -29752,30 +42818,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29752 | 42818 | .dst_temps = .{.mem}, |
| 29753 | 42819 | .clobbers = .{ .eflags = true }, |
| 29754 | 42820 | .each = .{ .once = &.{ |
| 29755 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 29756 | | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 29757 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 29758 | | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 29759 | 42821 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29760 | | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 29761 | | .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 29762 | | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 29763 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 29764 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29765 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 42822 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42823 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 42824 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42825 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 42826 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42827 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29766 | 42828 | } }, |
| 29767 | 42829 | }, .{ |
| 29768 | | .required_features = .{ .avx, null, null, null }, |
| 29769 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29770 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 42830 | .required_features = .{ .slow_incdec, null, null, null }, |
| 42831 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 42832 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29771 | 42833 | .patterns = &.{ |
| 29772 | | .{ .src = .{ .to_mem, .none } }, |
| 42834 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29773 | 42835 | }, |
| 29774 | 42836 | .extra_temps = .{ |
| 29775 | 42837 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29776 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29777 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29778 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 42838 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42839 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42840 | .unused, |
| 29779 | 42841 | .unused, |
| 29780 | 42842 | .unused, |
| 29781 | 42843 | .unused, |
| ... | ... | @@ -29785,28 +42847,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29785 | 42847 | .dst_temps = .{.mem}, |
| 29786 | 42848 | .clobbers = .{ .eflags = true }, |
| 29787 | 42849 | .each = .{ .once = &.{ |
| 29788 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 29789 | | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 29790 | 42850 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29791 | | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 29792 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 29793 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 42851 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42852 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 42853 | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42854 | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42855 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42856 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 42857 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29794 | 42858 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29795 | 42859 | } }, |
| 29796 | 42860 | }, .{ |
| 29797 | | .required_features = .{ .sse2, null, null, null }, |
| 29798 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29799 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 42861 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 42862 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29800 | 42863 | .patterns = &.{ |
| 29801 | | .{ .src = .{ .to_mem, .none } }, |
| 42864 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29802 | 42865 | }, |
| 29803 | 42866 | .extra_temps = .{ |
| 29804 | 42867 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29805 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 29806 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 29807 | | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 29808 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29809 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 42868 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42869 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 42870 | .unused, |
| 42871 | .unused, |
| 42872 | .unused, |
| 29810 | 42873 | .unused, |
| 29811 | 42874 | .unused, |
| 29812 | 42875 | .unused, |
| ... | ... | @@ -29814,31 +42877,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29814 | 42877 | .dst_temps = .{.mem}, |
| 29815 | 42878 | .clobbers = .{ .eflags = true }, |
| 29816 | 42879 | .each = .{ .once = &.{ |
| 29817 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 29818 | | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 29819 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 29820 | | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 29821 | 42880 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29822 | | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ }, |
| 29823 | | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29824 | | .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ }, |
| 29825 | | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| 29826 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 29827 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29828 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 42881 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42882 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 42883 | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42884 | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 42885 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42886 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 42887 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42888 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29829 | 42889 | } }, |
| 29830 | 42890 | }, .{ |
| 29831 | | .required_features = .{ .sse2, null, null, null }, |
| 29832 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29833 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 42891 | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 42892 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 42893 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29834 | 42894 | .patterns = &.{ |
| 29835 | | .{ .src = .{ .to_mem, .none } }, |
| 42895 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29836 | 42896 | }, |
| 29837 | 42897 | .extra_temps = .{ |
| 29838 | 42898 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29839 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29840 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29841 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 42899 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42900 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42901 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29842 | 42902 | .unused, |
| 29843 | 42903 | .unused, |
| 29844 | 42904 | .unused, |
| ... | ... | @@ -29848,27 +42908,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29848 | 42908 | .dst_temps = .{.mem}, |
| 29849 | 42909 | .clobbers = .{ .eflags = true }, |
| 29850 | 42910 | .each = .{ .once = &.{ |
| 29851 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 29852 | | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 29853 | 42911 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29854 | | .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 29855 | | .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29856 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 29857 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 42912 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42913 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 42914 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 42915 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 42916 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 42917 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29858 | 42918 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29859 | 42919 | } }, |
| 29860 | 42920 | }, .{ |
| 29861 | | .required_features = .{ .sse, null, null, null }, |
| 29862 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, |
| 29863 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 42921 | .required_features = .{ .bmi2, null, null, null }, |
| 42922 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 42923 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29864 | 42924 | .patterns = &.{ |
| 29865 | | .{ .src = .{ .to_mem, .none } }, |
| 42925 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29866 | 42926 | }, |
| 29867 | 42927 | .extra_temps = .{ |
| 29868 | 42928 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29869 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29870 | | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29871 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 42929 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42930 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 42931 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29872 | 42932 | .unused, |
| 29873 | 42933 | .unused, |
| 29874 | 42934 | .unused, |
| ... | ... | @@ -29878,26 +42938,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29878 | 42938 | .dst_temps = .{.mem}, |
| 29879 | 42939 | .clobbers = .{ .eflags = true }, |
| 29880 | 42940 | .each = .{ .once = &.{ |
| 29881 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 29882 | | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 29883 | 42941 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29884 | | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 29885 | | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29886 | | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 29887 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 29888 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 42942 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42943 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 42944 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 42945 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 42946 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 42947 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 42948 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29889 | 42949 | } }, |
| 29890 | 42950 | }, .{ |
| 29891 | 42951 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29892 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 29893 | | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, |
| 42952 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 42953 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29894 | 42954 | .patterns = &.{ |
| 29895 | | .{ .src = .{ .to_mem, .none } }, |
| 42955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29896 | 42956 | }, |
| 29897 | 42957 | .extra_temps = .{ |
| 29898 | 42958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29899 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29900 | | .unused, |
| 42959 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42960 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29901 | 42961 | .unused, |
| 29902 | 42962 | .unused, |
| 29903 | 42963 | .unused, |
| ... | ... | @@ -29909,23 +42969,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29909 | 42969 | .clobbers = .{ .eflags = true }, |
| 29910 | 42970 | .each = .{ .once = &.{ |
| 29911 | 42971 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29912 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29913 | | .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ }, |
| 29914 | | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 29915 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 42972 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 42973 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 42974 | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, |
| 42975 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 42976 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 29916 | 42977 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29917 | 42978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29918 | 42979 | } }, |
| 29919 | 42980 | }, .{ |
| 29920 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 29921 | | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, |
| 42981 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 42982 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29922 | 42983 | .patterns = &.{ |
| 29923 | | .{ .src = .{ .to_mem, .none } }, |
| 42984 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29924 | 42985 | }, |
| 29925 | 42986 | .extra_temps = .{ |
| 29926 | 42987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29927 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29928 | | .unused, |
| 42988 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 42989 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29929 | 42990 | .unused, |
| 29930 | 42991 | .unused, |
| 29931 | 42992 | .unused, |
| ... | ... | @@ -29937,23 +42998,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29937 | 42998 | .clobbers = .{ .eflags = true }, |
| 29938 | 42999 | .each = .{ .once = &.{ |
| 29939 | 43000 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29940 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29941 | | .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ }, |
| 29942 | | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, |
| 29943 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 43001 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 43002 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 43003 | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, |
| 43004 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 43005 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 29944 | 43006 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29945 | 43007 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29946 | 43008 | } }, |
| 29947 | 43009 | }, .{ |
| 29948 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 29949 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 29950 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43010 | .required_features = .{ .avx, null, null, null }, |
| 43011 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43012 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 43013 | .patterns = &.{ |
| 43014 | .{ .src = .{ .to_sse, .none, .none } }, |
| 43015 | }, |
| 43016 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 43017 | .each = .{ .once = &.{ |
| 43018 | .{ ._, .vp_w, .sll, .dst0x, .src0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43019 | .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43020 | } }, |
| 43021 | }, .{ |
| 43022 | .required_features = .{ .avx, null, null, null }, |
| 43023 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43024 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 29951 | 43025 | .patterns = &.{ |
| 29952 | | .{ .src = .{ .to_mem, .none } }, |
| 43026 | .{ .src = .{ .to_sse, .none, .none } }, |
| 29953 | 43027 | }, |
| 29954 | 43028 | .extra_temps = .{ |
| 29955 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29956 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43029 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 43030 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 29957 | 43031 | .unused, |
| 29958 | 43032 | .unused, |
| 29959 | 43033 | .unused, |
| ... | ... | @@ -29962,26 +43036,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29962 | 43036 | .unused, |
| 29963 | 43037 | .unused, |
| 29964 | 43038 | }, |
| 29965 | | .dst_temps = .{.mem}, |
| 29966 | | .clobbers = .{ .eflags = true }, |
| 43039 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 29967 | 43040 | .each = .{ .once = &.{ |
| 29968 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29969 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29970 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29971 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29972 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29973 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29974 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 43041 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 43042 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 29975 | 43043 | } }, |
| 29976 | 43044 | }, .{ |
| 29977 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 29978 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43045 | .required_features = .{ .sse2, null, null, null }, |
| 43046 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43047 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 43048 | .patterns = &.{ |
| 43049 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 43050 | }, |
| 43051 | .dst_temps = .{.{ .ref = .src0 }}, |
| 43052 | .each = .{ .once = &.{ |
| 43053 | .{ ._, .p_w, .sll, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 43054 | .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 43055 | } }, |
| 43056 | }, .{ |
| 43057 | .required_features = .{ .sse2, null, null, null }, |
| 43058 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43059 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 29979 | 43060 | .patterns = &.{ |
| 29980 | | .{ .src = .{ .to_mem, .none } }, |
| 43061 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 29981 | 43062 | }, |
| 29982 | 43063 | .extra_temps = .{ |
| 29983 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29984 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43064 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 43065 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 29985 | 43066 | .unused, |
| 29986 | 43067 | .unused, |
| 29987 | 43068 | .unused, |
| ... | ... | @@ -29990,27 +43071,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29990 | 43071 | .unused, |
| 29991 | 43072 | .unused, |
| 29992 | 43073 | }, |
| 29993 | | .dst_temps = .{.mem}, |
| 29994 | | .clobbers = .{ .eflags = true }, |
| 43074 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29995 | 43075 | .each = .{ .once = &.{ |
| 29996 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29997 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 29998 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29999 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30000 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30001 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30002 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43076 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 43077 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 30003 | 43078 | } }, |
| 30004 | 43079 | }, .{ |
| 30005 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30006 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 30007 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43080 | .required_features = .{ .sse, null, null, null }, |
| 43081 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43082 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 30008 | 43083 | .patterns = &.{ |
| 30009 | | .{ .src = .{ .to_mem, .none } }, |
| 43084 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30010 | 43085 | }, |
| 30011 | 43086 | .extra_temps = .{ |
| 30012 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30013 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43087 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 43088 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 30014 | 43089 | .unused, |
| 30015 | 43090 | .unused, |
| 30016 | 43091 | .unused, |
| ... | ... | @@ -30019,25 +43094,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30019 | 43094 | .unused, |
| 30020 | 43095 | .unused, |
| 30021 | 43096 | }, |
| 30022 | | .dst_temps = .{.mem}, |
| 30023 | | .clobbers = .{ .eflags = true }, |
| 43097 | .dst_temps = .{.{ .ref = .src0 }}, |
| 30024 | 43098 | .each = .{ .once = &.{ |
| 30025 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30026 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30027 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30028 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30029 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 30030 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 43099 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 43100 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 30031 | 43101 | } }, |
| 30032 | 43102 | }, .{ |
| 30033 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any }, |
| 30034 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43103 | .required_features = .{ .avx2, null, null, null }, |
| 43104 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 43105 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 43106 | .patterns = &.{ |
| 43107 | .{ .src = .{ .to_sse, .none, .none } }, |
| 43108 | }, |
| 43109 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 43110 | .each = .{ .once = &.{ |
| 43111 | .{ ._, .vp_w, .sll, .dst0y, .src0y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43112 | .{ ._, .vp_w, .sra, .dst0y, .dst0y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43113 | } }, |
| 43114 | }, .{ |
| 43115 | .required_features = .{ .avx2, null, null, null }, |
| 43116 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 43117 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }}, |
| 30035 | 43118 | .patterns = &.{ |
| 30036 | | .{ .src = .{ .to_mem, .none } }, |
| 43119 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30037 | 43120 | }, |
| 30038 | 43121 | .extra_temps = .{ |
| 30039 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30040 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43122 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 43123 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 30041 | 43124 | .unused, |
| 30042 | 43125 | .unused, |
| 30043 | 43126 | .unused, |
| ... | ... | @@ -30046,26 +43129,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30046 | 43129 | .unused, |
| 30047 | 43130 | .unused, |
| 30048 | 43131 | }, |
| 30049 | | .dst_temps = .{.mem}, |
| 30050 | | .clobbers = .{ .eflags = true }, |
| 43132 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30051 | 43133 | .each = .{ .once = &.{ |
| 30052 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30053 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30054 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30055 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30056 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30057 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43134 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 43135 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 30058 | 43136 | } }, |
| 30059 | 43137 | }, .{ |
| 30060 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30061 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 30062 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43138 | .required_features = .{ .avx2, null, null, null }, |
| 43139 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 43140 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 30063 | 43141 | .patterns = &.{ |
| 30064 | | .{ .src = .{ .to_mem, .none } }, |
| 43142 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30065 | 43143 | }, |
| 30066 | 43144 | .extra_temps = .{ |
| 30067 | 43145 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30068 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43146 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 30069 | 43147 | .unused, |
| 30070 | 43148 | .unused, |
| 30071 | 43149 | .unused, |
| ... | ... | @@ -30078,22 +43156,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30078 | 43156 | .clobbers = .{ .eflags = true }, |
| 30079 | 43157 | .each = .{ .once = &.{ |
| 30080 | 43158 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30081 | | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30082 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30083 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43159 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43160 | .{ ._, .vp_w, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43161 | .{ ._, .vp_w, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43162 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 43163 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 30084 | 43164 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30085 | 43165 | } }, |
| 30086 | 43166 | }, .{ |
| 30087 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 30088 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43167 | .required_features = .{ .avx2, null, null, null }, |
| 43168 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 43169 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }}, |
| 30089 | 43170 | .patterns = &.{ |
| 30090 | | .{ .src = .{ .to_mem, .none } }, |
| 43171 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30091 | 43172 | }, |
| 30092 | 43173 | .extra_temps = .{ |
| 30093 | 43174 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30094 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30095 | | .unused, |
| 30096 | | .unused, |
| 43175 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 43176 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 43177 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 30097 | 43178 | .unused, |
| 30098 | 43179 | .unused, |
| 30099 | 43180 | .unused, |
| ... | ... | @@ -30103,22 +43184,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30103 | 43184 | .dst_temps = .{.mem}, |
| 30104 | 43185 | .clobbers = .{ .eflags = true }, |
| 30105 | 43186 | .each = .{ .once = &.{ |
| 43187 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 43188 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 30106 | 43189 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30107 | | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30108 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30109 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30110 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43190 | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 43191 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 43192 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 43193 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30111 | 43194 | } }, |
| 30112 | 43195 | }, .{ |
| 30113 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30114 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 30115 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43196 | .required_features = .{ .avx, null, null, null }, |
| 43197 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43198 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 30116 | 43199 | .patterns = &.{ |
| 30117 | | .{ .src = .{ .to_mem, .none } }, |
| 43200 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30118 | 43201 | }, |
| 30119 | 43202 | .extra_temps = .{ |
| 30120 | 43203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30121 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43204 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 30122 | 43205 | .unused, |
| 30123 | 43206 | .unused, |
| 30124 | 43207 | .unused, |
| ... | ... | @@ -30131,24 +43214,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30131 | 43214 | .clobbers = .{ .eflags = true }, |
| 30132 | 43215 | .each = .{ .once = &.{ |
| 30133 | 43216 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30134 | | .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30135 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30136 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30137 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30138 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43217 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43218 | .{ ._, .vp_w, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43219 | .{ ._, .vp_w, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 43220 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 43221 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30139 | 43222 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30140 | 43223 | } }, |
| 30141 | 43224 | }, .{ |
| 30142 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 30143 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43225 | .required_features = .{ .avx, null, null, null }, |
| 43226 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43227 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 30144 | 43228 | .patterns = &.{ |
| 30145 | | .{ .src = .{ .to_mem, .none } }, |
| 43229 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30146 | 43230 | }, |
| 30147 | 43231 | .extra_temps = .{ |
| 30148 | 43232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30149 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 30150 | | .unused, |
| 30151 | | .unused, |
| 43233 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 43234 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 43235 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 30152 | 43236 | .unused, |
| 30153 | 43237 | .unused, |
| 30154 | 43238 | .unused, |
| ... | ... | @@ -30158,24 +43242,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30158 | 43242 | .dst_temps = .{.mem}, |
| 30159 | 43243 | .clobbers = .{ .eflags = true }, |
| 30160 | 43244 | .each = .{ .once = &.{ |
| 43245 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 43246 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 30161 | 43247 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30162 | | .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30163 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30164 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30165 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30166 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30167 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43248 | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 43249 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 43250 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 43251 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30168 | 43252 | } }, |
| 30169 | 43253 | }, .{ |
| 30170 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30171 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, |
| 30172 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43254 | .required_features = .{ .sse2, null, null, null }, |
| 43255 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43256 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 30173 | 43257 | .patterns = &.{ |
| 30174 | | .{ .src = .{ .to_mem, .none } }, |
| 43258 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30175 | 43259 | }, |
| 30176 | 43260 | .extra_temps = .{ |
| 30177 | 43261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30178 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43262 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 30179 | 43263 | .unused, |
| 30180 | 43264 | .unused, |
| 30181 | 43265 | .unused, |
| ... | ... | @@ -30188,24 +43272,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30188 | 43272 | .clobbers = .{ .eflags = true }, |
| 30189 | 43273 | .each = .{ .once = &.{ |
| 30190 | 43274 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30191 | | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30192 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30193 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30194 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43275 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43276 | .{ ._, .p_w, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 43277 | .{ ._, .p_w, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 43278 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 43279 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30195 | 43280 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30196 | 43281 | } }, |
| 30197 | 43282 | }, .{ |
| 30198 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, |
| 30199 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43283 | .required_features = .{ .sse2, null, null, null }, |
| 43284 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43285 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 30200 | 43286 | .patterns = &.{ |
| 30201 | | .{ .src = .{ .to_mem, .none } }, |
| 43287 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30202 | 43288 | }, |
| 30203 | 43289 | .extra_temps = .{ |
| 30204 | 43290 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30205 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43291 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 43292 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 43293 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 43294 | .unused, |
| 43295 | .unused, |
| 30206 | 43296 | .unused, |
| 30207 | 43297 | .unused, |
| 30208 | 43298 | .unused, |
| 43299 | }, |
| 43300 | .dst_temps = .{.mem}, |
| 43301 | .clobbers = .{ .eflags = true }, |
| 43302 | .each = .{ .once = &.{ |
| 43303 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 43304 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 43305 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 43306 | .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 43307 | .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43308 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 43309 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 43310 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 43311 | } }, |
| 43312 | }, .{ |
| 43313 | .required_features = .{ .sse, null, null, null }, |
| 43314 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 43315 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 43316 | .patterns = &.{ |
| 43317 | .{ .src = .{ .to_mem, .none, .none } }, |
| 43318 | }, |
| 43319 | .extra_temps = .{ |
| 43320 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 43321 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 43322 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 43323 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 43324 | .unused, |
| 30209 | 43325 | .unused, |
| 30210 | 43326 | .unused, |
| 30211 | 43327 | .unused, |
| ... | ... | @@ -30214,23 +43330,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30214 | 43330 | .dst_temps = .{.mem}, |
| 30215 | 43331 | .clobbers = .{ .eflags = true }, |
| 30216 | 43332 | .each = .{ .once = &.{ |
| 43333 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 43334 | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 30217 | 43335 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30218 | | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30219 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30220 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30221 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30222 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43336 | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 43337 | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43338 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 43339 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 43340 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30223 | 43341 | } }, |
| 30224 | 43342 | }, .{ |
| 30225 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30226 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30227 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43343 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 43344 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30228 | 43345 | .patterns = &.{ |
| 30229 | | .{ .src = .{ .to_mem, .none } }, |
| 43346 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30230 | 43347 | }, |
| 30231 | 43348 | .extra_temps = .{ |
| 30232 | 43349 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30233 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43350 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30234 | 43351 | .unused, |
| 30235 | 43352 | .unused, |
| 30236 | 43353 | .unused, |
| ... | ... | @@ -30243,20 +43360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30243 | 43360 | .clobbers = .{ .eflags = true }, |
| 30244 | 43361 | .each = .{ .once = &.{ |
| 30245 | 43362 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30246 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30247 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30248 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43363 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43364 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43365 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30249 | 43366 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30250 | 43367 | } }, |
| 30251 | 43368 | }, .{ |
| 30252 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30253 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43369 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 43370 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30254 | 43371 | .patterns = &.{ |
| 30255 | | .{ .src = .{ .to_mem, .none } }, |
| 43372 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30256 | 43373 | }, |
| 30257 | 43374 | .extra_temps = .{ |
| 30258 | 43375 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30259 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43376 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30260 | 43377 | .unused, |
| 30261 | 43378 | .unused, |
| 30262 | 43379 | .unused, |
| ... | ... | @@ -30269,21 +43386,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30269 | 43386 | .clobbers = .{ .eflags = true }, |
| 30270 | 43387 | .each = .{ .once = &.{ |
| 30271 | 43388 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30272 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30273 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30274 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30275 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43389 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43390 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43391 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43392 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43393 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43394 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30276 | 43395 | } }, |
| 30277 | 43396 | }, .{ |
| 30278 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30279 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30280 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43397 | .required_features = .{ .fast_imm16, null, null, null }, |
| 43398 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 43399 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30281 | 43400 | .patterns = &.{ |
| 30282 | | .{ .src = .{ .to_mem, .none } }, |
| 43401 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30283 | 43402 | }, |
| 30284 | 43403 | .extra_temps = .{ |
| 30285 | 43404 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30286 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43405 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30287 | 43406 | .unused, |
| 30288 | 43407 | .unused, |
| 30289 | 43408 | .unused, |
| ... | ... | @@ -30296,22 +43415,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30296 | 43415 | .clobbers = .{ .eflags = true }, |
| 30297 | 43416 | .each = .{ .once = &.{ |
| 30298 | 43417 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30299 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30300 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30301 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30302 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30303 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43418 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43419 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 43420 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43421 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30304 | 43422 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30305 | 43423 | } }, |
| 30306 | 43424 | }, .{ |
| 30307 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30308 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43425 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 43426 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30309 | 43427 | .patterns = &.{ |
| 30310 | | .{ .src = .{ .to_mem, .none } }, |
| 43428 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30311 | 43429 | }, |
| 30312 | 43430 | .extra_temps = .{ |
| 30313 | 43431 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30314 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43432 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30315 | 43433 | .unused, |
| 30316 | 43434 | .unused, |
| 30317 | 43435 | .unused, |
| ... | ... | @@ -30324,24 +43442,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30324 | 43442 | .clobbers = .{ .eflags = true }, |
| 30325 | 43443 | .each = .{ .once = &.{ |
| 30326 | 43444 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30327 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30328 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30329 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30330 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30331 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30332 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43445 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 43446 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 43447 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43448 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43449 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30333 | 43450 | } }, |
| 30334 | 43451 | }, .{ |
| 30335 | | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 30336 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30337 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43452 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 43453 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30338 | 43454 | .patterns = &.{ |
| 30339 | | .{ .src = .{ .to_mem, .none } }, |
| 43455 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30340 | 43456 | }, |
| 30341 | 43457 | .extra_temps = .{ |
| 30342 | 43458 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30343 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30344 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43459 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 43460 | .unused, |
| 30345 | 43461 | .unused, |
| 30346 | 43462 | .unused, |
| 30347 | 43463 | .unused, |
| ... | ... | @@ -30353,23 +43469,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30353 | 43469 | .clobbers = .{ .eflags = true }, |
| 30354 | 43470 | .each = .{ .once = &.{ |
| 30355 | 43471 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30356 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30357 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30358 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30359 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43472 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43473 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43474 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30360 | 43475 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30361 | 43476 | } }, |
| 30362 | 43477 | }, .{ |
| 30363 | | .required_features = .{ .bmi2, null, null, null }, |
| 30364 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30365 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43478 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 43479 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30366 | 43480 | .patterns = &.{ |
| 30367 | | .{ .src = .{ .to_mem, .none } }, |
| 43481 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30368 | 43482 | }, |
| 30369 | 43483 | .extra_temps = .{ |
| 30370 | 43484 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30371 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30372 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43485 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 43486 | .unused, |
| 30373 | 43487 | .unused, |
| 30374 | 43488 | .unused, |
| 30375 | 43489 | .unused, |
| ... | ... | @@ -30381,23 +43495,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30381 | 43495 | .clobbers = .{ .eflags = true }, |
| 30382 | 43496 | .each = .{ .once = &.{ |
| 30383 | 43497 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30384 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30385 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30386 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30387 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30388 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43498 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43499 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43500 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43501 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43502 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43503 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30389 | 43504 | } }, |
| 30390 | 43505 | }, .{ |
| 30391 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30392 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30393 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43506 | .required_features = .{ .bmi2, null, null, null }, |
| 43507 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 43508 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30394 | 43509 | .patterns = &.{ |
| 30395 | | .{ .src = .{ .to_mem, .none } }, |
| 43510 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30396 | 43511 | }, |
| 30397 | 43512 | .extra_temps = .{ |
| 30398 | 43513 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30399 | 43514 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30400 | | .unused, |
| 43515 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30401 | 43516 | .unused, |
| 30402 | 43517 | .unused, |
| 30403 | 43518 | .unused, |
| ... | ... | @@ -30409,21 +43524,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30409 | 43524 | .clobbers = .{ .eflags = true }, |
| 30410 | 43525 | .each = .{ .once = &.{ |
| 30411 | 43526 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30412 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30413 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30414 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30415 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43527 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 43528 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 43529 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 43530 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30416 | 43531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30417 | 43532 | } }, |
| 30418 | 43533 | }, .{ |
| 30419 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 30420 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43534 | .required_features = .{ .fast_imm16, null, null, null }, |
| 43535 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 43536 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30421 | 43537 | .patterns = &.{ |
| 30422 | | .{ .src = .{ .to_mem, .none } }, |
| 43538 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30423 | 43539 | }, |
| 30424 | 43540 | .extra_temps = .{ |
| 30425 | 43541 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30426 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43542 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30427 | 43543 | .unused, |
| 30428 | 43544 | .unused, |
| 30429 | 43545 | .unused, |
| ... | ... | @@ -30436,22 +43552,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30436 | 43552 | .clobbers = .{ .eflags = true }, |
| 30437 | 43553 | .each = .{ .once = &.{ |
| 30438 | 43554 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30439 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30440 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30441 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30442 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30443 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43555 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43556 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 43557 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43558 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43559 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30444 | 43560 | } }, |
| 30445 | 43561 | }, .{ |
| 30446 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30447 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30448 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43562 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 43563 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30449 | 43564 | .patterns = &.{ |
| 30450 | | .{ .src = .{ .to_mem, .none } }, |
| 43565 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30451 | 43566 | }, |
| 30452 | 43567 | .extra_temps = .{ |
| 30453 | 43568 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30454 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43569 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30455 | 43570 | .unused, |
| 30456 | 43571 | .unused, |
| 30457 | 43572 | .unused, |
| ... | ... | @@ -30464,20 +43579,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30464 | 43579 | .clobbers = .{ .eflags = true }, |
| 30465 | 43580 | .each = .{ .once = &.{ |
| 30466 | 43581 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30467 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30468 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30469 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43582 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43583 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 43584 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43585 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30470 | 43586 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30471 | 43587 | } }, |
| 30472 | 43588 | }, .{ |
| 30473 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30474 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43589 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 43590 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30475 | 43591 | .patterns = &.{ |
| 30476 | | .{ .src = .{ .to_mem, .none } }, |
| 43592 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30477 | 43593 | }, |
| 30478 | 43594 | .extra_temps = .{ |
| 30479 | 43595 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30480 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43596 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30481 | 43597 | .unused, |
| 30482 | 43598 | .unused, |
| 30483 | 43599 | .unused, |
| ... | ... | @@ -30490,21 +43606,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30490 | 43606 | .clobbers = .{ .eflags = true }, |
| 30491 | 43607 | .each = .{ .once = &.{ |
| 30492 | 43608 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30493 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30494 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30495 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30496 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43609 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43610 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43611 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43612 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30497 | 43613 | } }, |
| 30498 | 43614 | }, .{ |
| 30499 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30500 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30501 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43615 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 43616 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30502 | 43617 | .patterns = &.{ |
| 30503 | | .{ .src = .{ .to_mem, .none } }, |
| 43618 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30504 | 43619 | }, |
| 30505 | 43620 | .extra_temps = .{ |
| 30506 | 43621 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30507 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43622 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30508 | 43623 | .unused, |
| 30509 | 43624 | .unused, |
| 30510 | 43625 | .unused, |
| ... | ... | @@ -30517,23 +43632,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30517 | 43632 | .clobbers = .{ .eflags = true }, |
| 30518 | 43633 | .each = .{ .once = &.{ |
| 30519 | 43634 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30520 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30521 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30522 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30523 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30524 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43635 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43636 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43637 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43638 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43639 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30525 | 43640 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30526 | 43641 | } }, |
| 30527 | 43642 | }, .{ |
| 30528 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30529 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43643 | .required_features = .{ .bmi2, null, null, null }, |
| 43644 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 43645 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30530 | 43646 | .patterns = &.{ |
| 30531 | | .{ .src = .{ .to_mem, .none } }, |
| 43647 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30532 | 43648 | }, |
| 30533 | 43649 | .extra_temps = .{ |
| 30534 | 43650 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30535 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 30536 | | .unused, |
| 43651 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43652 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30537 | 43653 | .unused, |
| 30538 | 43654 | .unused, |
| 30539 | 43655 | .unused, |
| ... | ... | @@ -30545,24 +43661,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30545 | 43661 | .clobbers = .{ .eflags = true }, |
| 30546 | 43662 | .each = .{ .once = &.{ |
| 30547 | 43663 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30548 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30549 | | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30550 | | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30551 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30552 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30553 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43664 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 43665 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 43666 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 43667 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43668 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30554 | 43669 | } }, |
| 30555 | 43670 | }, .{ |
| 30556 | | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 30557 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30558 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43671 | .required_features = .{ .fast_imm16, null, null, null }, |
| 43672 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 43673 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30559 | 43674 | .patterns = &.{ |
| 30560 | | .{ .src = .{ .to_mem, .none } }, |
| 43675 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30561 | 43676 | }, |
| 30562 | 43677 | .extra_temps = .{ |
| 30563 | 43678 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30564 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30565 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43679 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 43680 | .unused, |
| 30566 | 43681 | .unused, |
| 30567 | 43682 | .unused, |
| 30568 | 43683 | .unused, |
| ... | ... | @@ -30574,23 +43689,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30574 | 43689 | .clobbers = .{ .eflags = true }, |
| 30575 | 43690 | .each = .{ .once = &.{ |
| 30576 | 43691 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30577 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30578 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30579 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30580 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43692 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43693 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 43694 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43695 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30581 | 43696 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30582 | 43697 | } }, |
| 30583 | 43698 | }, .{ |
| 30584 | | .required_features = .{ .bmi2, null, null, null }, |
| 30585 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30586 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43699 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 43700 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30587 | 43701 | .patterns = &.{ |
| 30588 | | .{ .src = .{ .to_mem, .none } }, |
| 43702 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30589 | 43703 | }, |
| 30590 | 43704 | .extra_temps = .{ |
| 30591 | 43705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30592 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30593 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43706 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 43707 | .unused, |
| 30594 | 43708 | .unused, |
| 30595 | 43709 | .unused, |
| 30596 | 43710 | .unused, |
| ... | ... | @@ -30602,22 +43716,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30602 | 43716 | .clobbers = .{ .eflags = true }, |
| 30603 | 43717 | .each = .{ .once = &.{ |
| 30604 | 43718 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30605 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30606 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30607 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30608 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30609 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43719 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43720 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 43721 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43722 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43723 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30610 | 43724 | } }, |
| 30611 | 43725 | }, .{ |
| 30612 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30613 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30614 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43726 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 43727 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30615 | 43728 | .patterns = &.{ |
| 30616 | | .{ .src = .{ .to_mem, .none } }, |
| 43729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30617 | 43730 | }, |
| 30618 | 43731 | .extra_temps = .{ |
| 30619 | 43732 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30620 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43733 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30621 | 43734 | .unused, |
| 30622 | 43735 | .unused, |
| 30623 | 43736 | .unused, |
| ... | ... | @@ -30631,20 +43744,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30631 | 43744 | .each = .{ .once = &.{ |
| 30632 | 43745 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30633 | 43746 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30634 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30635 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30636 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43747 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43748 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30637 | 43749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30638 | 43750 | } }, |
| 30639 | 43751 | }, .{ |
| 30640 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 30641 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43752 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 43753 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30642 | 43754 | .patterns = &.{ |
| 30643 | | .{ .src = .{ .to_mem, .none } }, |
| 43755 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30644 | 43756 | }, |
| 30645 | 43757 | .extra_temps = .{ |
| 30646 | 43758 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30647 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43759 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30648 | 43760 | .unused, |
| 30649 | 43761 | .unused, |
| 30650 | 43762 | .unused, |
| ... | ... | @@ -30658,22 +43770,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30658 | 43770 | .each = .{ .once = &.{ |
| 30659 | 43771 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30660 | 43772 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30661 | | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30662 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 30663 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30664 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43773 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43774 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43775 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43776 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43777 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30665 | 43778 | } }, |
| 30666 | 43779 | }, .{ |
| 30667 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30668 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 30669 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43780 | .required_features = .{ .bmi2, null, null, null }, |
| 43781 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 43782 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30670 | 43783 | .patterns = &.{ |
| 30671 | | .{ .src = .{ .to_mem, .none } }, |
| 43784 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30672 | 43785 | }, |
| 30673 | 43786 | .extra_temps = .{ |
| 30674 | 43787 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30675 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30676 | 43788 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43789 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30677 | 43790 | .unused, |
| 30678 | 43791 | .unused, |
| 30679 | 43792 | .unused, |
| ... | ... | @@ -30685,23 +43798,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30685 | 43798 | .clobbers = .{ .eflags = true }, |
| 30686 | 43799 | .each = .{ .once = &.{ |
| 30687 | 43800 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30688 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30689 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30690 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30691 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30692 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43801 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 43802 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 43803 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 43804 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30693 | 43805 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30694 | 43806 | } }, |
| 30695 | 43807 | }, .{ |
| 30696 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 30697 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 43808 | .required_features = .{ .fast_imm16, null, null, null }, |
| 43809 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 43810 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30698 | 43811 | .patterns = &.{ |
| 30699 | | .{ .src = .{ .to_mem, .none } }, |
| 43812 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30700 | 43813 | }, |
| 30701 | 43814 | .extra_temps = .{ |
| 30702 | 43815 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30703 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30704 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43816 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 43817 | .unused, |
| 30705 | 43818 | .unused, |
| 30706 | 43819 | .unused, |
| 30707 | 43820 | .unused, |
| ... | ... | @@ -30713,24 +43826,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30713 | 43826 | .clobbers = .{ .eflags = true }, |
| 30714 | 43827 | .each = .{ .once = &.{ |
| 30715 | 43828 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30716 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30717 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30718 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30719 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30720 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30721 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43829 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43830 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 43831 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43832 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43833 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30722 | 43834 | } }, |
| 30723 | 43835 | }, .{ |
| 30724 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30725 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 30726 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43836 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 43837 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30727 | 43838 | .patterns = &.{ |
| 30728 | | .{ .src = .{ .to_mem, .none } }, |
| 43839 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30729 | 43840 | }, |
| 30730 | 43841 | .extra_temps = .{ |
| 30731 | 43842 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30732 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30733 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43843 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 43844 | .unused, |
| 30734 | 43845 | .unused, |
| 30735 | 43846 | .unused, |
| 30736 | 43847 | .unused, |
| ... | ... | @@ -30742,25 +43853,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30742 | 43853 | .clobbers = .{ .eflags = true }, |
| 30743 | 43854 | .each = .{ .once = &.{ |
| 30744 | 43855 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30745 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30746 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30747 | | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30748 | | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30749 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 30750 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30751 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43856 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 43857 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 43858 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 43859 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30752 | 43860 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30753 | 43861 | } }, |
| 30754 | 43862 | }, .{ |
| 30755 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 30756 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 43863 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 43864 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30757 | 43865 | .patterns = &.{ |
| 30758 | | .{ .src = .{ .to_mem, .none } }, |
| 43866 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30759 | 43867 | }, |
| 30760 | 43868 | .extra_temps = .{ |
| 30761 | 43869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30762 | 43870 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30763 | | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 43871 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30764 | 43872 | .unused, |
| 30765 | 43873 | .unused, |
| 30766 | 43874 | .unused, |
| ... | ... | @@ -30774,25 +43882,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30774 | 43882 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30775 | 43883 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30776 | 43884 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30777 | | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30778 | | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 30779 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 43885 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30780 | 43886 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30781 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30782 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43887 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43888 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30783 | 43889 | } }, |
| 30784 | 43890 | }, .{ |
| 30785 | | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 30786 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 30787 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43891 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 43892 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30788 | 43893 | .patterns = &.{ |
| 30789 | | .{ .src = .{ .to_mem, .none } }, |
| 43894 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30790 | 43895 | }, |
| 30791 | 43896 | .extra_temps = .{ |
| 30792 | 43897 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30793 | 43898 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30794 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30795 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43899 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 43900 | .unused, |
| 30796 | 43901 | .unused, |
| 30797 | 43902 | .unused, |
| 30798 | 43903 | .unused, |
| ... | ... | @@ -30804,25 +43909,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30804 | 43909 | .each = .{ .once = &.{ |
| 30805 | 43910 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30806 | 43911 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30807 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30808 | | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 30809 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 43912 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 43913 | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43914 | .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 43915 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30810 | 43916 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30811 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43917 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30812 | 43918 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30813 | 43919 | } }, |
| 30814 | 43920 | }, .{ |
| 30815 | 43921 | .required_features = .{ .bmi2, null, null, null }, |
| 30816 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 30817 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43922 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 43923 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30818 | 43924 | .patterns = &.{ |
| 30819 | | .{ .src = .{ .to_mem, .none } }, |
| 43925 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30820 | 43926 | }, |
| 30821 | 43927 | .extra_temps = .{ |
| 30822 | 43928 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30823 | 43929 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30824 | 43930 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30825 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43931 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30826 | 43932 | .unused, |
| 30827 | 43933 | .unused, |
| 30828 | 43934 | .unused, |
| ... | ... | @@ -30836,22 +43942,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30836 | 43942 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30837 | 43943 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30838 | 43944 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 30839 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 43945 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 30840 | 43946 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30841 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30842 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 43947 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 43948 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30843 | 43949 | } }, |
| 30844 | 43950 | }, .{ |
| 30845 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 30846 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 30847 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43951 | .required_features = .{ .fast_imm16, null, null, null }, |
| 43952 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 43953 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30848 | 43954 | .patterns = &.{ |
| 30849 | | .{ .src = .{ .to_mem, .none } }, |
| 43955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30850 | 43956 | }, |
| 30851 | 43957 | .extra_temps = .{ |
| 30852 | 43958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30853 | 43959 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30854 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43960 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30855 | 43961 | .unused, |
| 30856 | 43962 | .unused, |
| 30857 | 43963 | .unused, |
| ... | ... | @@ -30865,22 +43971,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30865 | 43971 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30866 | 43972 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30867 | 43973 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30868 | | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30869 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 43974 | .{ ._, ._, .@"and", .tmp2w, .sa(.dst0, .add_umax), ._, ._ }, |
| 43975 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30870 | 43976 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30871 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 43977 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30872 | 43978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30873 | 43979 | } }, |
| 30874 | 43980 | }, .{ |
| 30875 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 30876 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 43981 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 43982 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30877 | 43983 | .patterns = &.{ |
| 30878 | | .{ .src = .{ .to_mem, .none } }, |
| 43984 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30879 | 43985 | }, |
| 30880 | 43986 | .extra_temps = .{ |
| 30881 | 43987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30882 | 43988 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30883 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 43989 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30884 | 43990 | .unused, |
| 30885 | 43991 | .unused, |
| 30886 | 43992 | .unused, |
| ... | ... | @@ -30894,30 +44000,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30894 | 44000 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30895 | 44001 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30896 | 44002 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30897 | | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, |
| 30898 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 44003 | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, |
| 44004 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30899 | 44005 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30900 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 30901 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 44006 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44007 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30902 | 44008 | } }, |
| 30903 | 44009 | }, .{ |
| 30904 | 44010 | .required_features = .{ .avx, null, null, null }, |
| 30905 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30906 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 44011 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44012 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 30907 | 44013 | .patterns = &.{ |
| 30908 | | .{ .src = .{ .to_sse, .none } }, |
| 44014 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30909 | 44015 | }, |
| 30910 | 44016 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30911 | 44017 | .each = .{ .once = &.{ |
| 30912 | | .{ ._, .vp_w, .sll, .dst0x, .src0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 30913 | | .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 44018 | .{ ._, .vp_d, .sll, .dst0x, .src0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 44019 | .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 30914 | 44020 | } }, |
| 30915 | 44021 | }, .{ |
| 30916 | 44022 | .required_features = .{ .avx, null, null, null }, |
| 30917 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30918 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 44023 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44024 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 30919 | 44025 | .patterns = &.{ |
| 30920 | | .{ .src = .{ .to_sse, .none } }, |
| 44026 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30921 | 44027 | }, |
| 30922 | 44028 | .extra_temps = .{ |
| 30923 | 44029 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -30937,22 +44043,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30937 | 44043 | } }, |
| 30938 | 44044 | }, .{ |
| 30939 | 44045 | .required_features = .{ .sse2, null, null, null }, |
| 30940 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30941 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 44046 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44047 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 30942 | 44048 | .patterns = &.{ |
| 30943 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 44049 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30944 | 44050 | }, |
| 30945 | 44051 | .dst_temps = .{.{ .ref = .src0 }}, |
| 30946 | 44052 | .each = .{ .once = &.{ |
| 30947 | | .{ ._, .p_w, .sll, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 30948 | | .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 44053 | .{ ._, .p_d, .sll, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 44054 | .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30949 | 44055 | } }, |
| 30950 | 44056 | }, .{ |
| 30951 | 44057 | .required_features = .{ .sse2, null, null, null }, |
| 30952 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30953 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 44058 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44059 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 30954 | 44060 | .patterns = &.{ |
| 30955 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 44061 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30956 | 44062 | }, |
| 30957 | 44063 | .extra_temps = .{ |
| 30958 | 44064 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -30972,10 +44078,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30972 | 44078 | } }, |
| 30973 | 44079 | }, .{ |
| 30974 | 44080 | .required_features = .{ .sse, null, null, null }, |
| 30975 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, |
| 30976 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 44081 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44082 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 30977 | 44083 | .patterns = &.{ |
| 30978 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 44084 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30979 | 44085 | }, |
| 30980 | 44086 | .extra_temps = .{ |
| 30981 | 44087 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -30995,22 +44101,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30995 | 44101 | } }, |
| 30996 | 44102 | }, .{ |
| 30997 | 44103 | .required_features = .{ .avx2, null, null, null }, |
| 30998 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any }, |
| 30999 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 44104 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 44105 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 31000 | 44106 | .patterns = &.{ |
| 31001 | | .{ .src = .{ .to_sse, .none } }, |
| 44107 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31002 | 44108 | }, |
| 31003 | 44109 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31004 | 44110 | .each = .{ .once = &.{ |
| 31005 | | .{ ._, .vp_w, .sll, .dst0y, .src0y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31006 | | .{ ._, .vp_w, .sra, .dst0y, .dst0y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 44111 | .{ ._, .vp_d, .sll, .dst0y, .src0y, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 44112 | .{ ._, .vp_d, .sra, .dst0y, .dst0y, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 31007 | 44113 | } }, |
| 31008 | 44114 | }, .{ |
| 31009 | 44115 | .required_features = .{ .avx2, null, null, null }, |
| 31010 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any }, |
| 31011 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }}, |
| 44116 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 44117 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, |
| 31012 | 44118 | .patterns = &.{ |
| 31013 | | .{ .src = .{ .to_sse, .none } }, |
| 44119 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31014 | 44120 | }, |
| 31015 | 44121 | .extra_temps = .{ |
| 31016 | 44122 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -31030,14 +44136,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31030 | 44136 | } }, |
| 31031 | 44137 | }, .{ |
| 31032 | 44138 | .required_features = .{ .avx2, null, null, null }, |
| 31033 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any }, |
| 31034 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 44139 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 44140 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 31035 | 44141 | .patterns = &.{ |
| 31036 | | .{ .src = .{ .to_mem, .none } }, |
| 44142 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31037 | 44143 | }, |
| 31038 | 44144 | .extra_temps = .{ |
| 31039 | 44145 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31040 | | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 44146 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 31041 | 44147 | .unused, |
| 31042 | 44148 | .unused, |
| 31043 | 44149 | .unused, |
| ... | ... | @@ -31051,23 +44157,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31051 | 44157 | .each = .{ .once = &.{ |
| 31052 | 44158 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31053 | 44159 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31054 | | .{ ._, .vp_w, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31055 | | .{ ._, .vp_w, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 44160 | .{ ._, .vp_d, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 44161 | .{ ._, .vp_d, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31056 | 44162 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 31057 | 44163 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 31058 | 44164 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31059 | 44165 | } }, |
| 31060 | 44166 | }, .{ |
| 31061 | 44167 | .required_features = .{ .avx2, null, null, null }, |
| 31062 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any }, |
| 31063 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }}, |
| 44168 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 44169 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, |
| 31064 | 44170 | .patterns = &.{ |
| 31065 | | .{ .src = .{ .to_mem, .none } }, |
| 44171 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31066 | 44172 | }, |
| 31067 | 44173 | .extra_temps = .{ |
| 31068 | 44174 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31069 | | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 31070 | | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 44175 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 44176 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 31071 | 44177 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31072 | 44178 | .unused, |
| 31073 | 44179 | .unused, |
| ... | ... | @@ -31088,14 +44194,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31088 | 44194 | } }, |
| 31089 | 44195 | }, .{ |
| 31090 | 44196 | .required_features = .{ .avx, null, null, null }, |
| 31091 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, |
| 31092 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 44197 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44198 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 31093 | 44199 | .patterns = &.{ |
| 31094 | | .{ .src = .{ .to_mem, .none } }, |
| 44200 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31095 | 44201 | }, |
| 31096 | 44202 | .extra_temps = .{ |
| 31097 | 44203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31098 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 44204 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 31099 | 44205 | .unused, |
| 31100 | 44206 | .unused, |
| 31101 | 44207 | .unused, |
| ... | ... | @@ -31109,23 +44215,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31109 | 44215 | .each = .{ .once = &.{ |
| 31110 | 44216 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31111 | 44217 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31112 | | .{ ._, .vp_w, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31113 | | .{ ._, .vp_w, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 44218 | .{ ._, .vp_d, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 44219 | .{ ._, .vp_d, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31114 | 44220 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31115 | 44221 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31116 | 44222 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31117 | 44223 | } }, |
| 31118 | 44224 | }, .{ |
| 31119 | 44225 | .required_features = .{ .avx, null, null, null }, |
| 31120 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, |
| 31121 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 44226 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44227 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 31122 | 44228 | .patterns = &.{ |
| 31123 | | .{ .src = .{ .to_mem, .none } }, |
| 44229 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31124 | 44230 | }, |
| 31125 | 44231 | .extra_temps = .{ |
| 31126 | 44232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31127 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 31128 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 44233 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 44234 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31129 | 44235 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31130 | 44236 | .unused, |
| 31131 | 44237 | .unused, |
| ... | ... | @@ -31146,14 +44252,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31146 | 44252 | } }, |
| 31147 | 44253 | }, .{ |
| 31148 | 44254 | .required_features = .{ .sse2, null, null, null }, |
| 31149 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, |
| 31150 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 44255 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44256 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 31151 | 44257 | .patterns = &.{ |
| 31152 | | .{ .src = .{ .to_mem, .none } }, |
| 44258 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31153 | 44259 | }, |
| 31154 | 44260 | .extra_temps = .{ |
| 31155 | 44261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31156 | | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 44262 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 31157 | 44263 | .unused, |
| 31158 | 44264 | .unused, |
| 31159 | 44265 | .unused, |
| ... | ... | @@ -31167,23 +44273,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31167 | 44273 | .each = .{ .once = &.{ |
| 31168 | 44274 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31169 | 44275 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31170 | | .{ ._, .p_w, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 31171 | | .{ ._, .p_w, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 44276 | .{ ._, .p_d, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 44277 | .{ ._, .p_d, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 31172 | 44278 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31173 | 44279 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31174 | 44280 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31175 | 44281 | } }, |
| 31176 | 44282 | }, .{ |
| 31177 | 44283 | .required_features = .{ .sse2, null, null, null }, |
| 31178 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, |
| 31179 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 44284 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44285 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 31180 | 44286 | .patterns = &.{ |
| 31181 | | .{ .src = .{ .to_mem, .none } }, |
| 44287 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31182 | 44288 | }, |
| 31183 | 44289 | .extra_temps = .{ |
| 31184 | 44290 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31185 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 31186 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 44291 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 44292 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31187 | 44293 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31188 | 44294 | .unused, |
| 31189 | 44295 | .unused, |
| ... | ... | @@ -31205,15 +44311,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31205 | 44311 | } }, |
| 31206 | 44312 | }, .{ |
| 31207 | 44313 | .required_features = .{ .sse, null, null, null }, |
| 31208 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, |
| 31209 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 44314 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 44315 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 31210 | 44316 | .patterns = &.{ |
| 31211 | | .{ .src = .{ .to_mem, .none } }, |
| 44317 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31212 | 44318 | }, |
| 31213 | 44319 | .extra_temps = .{ |
| 31214 | 44320 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31215 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 31216 | | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 44321 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 44322 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31217 | 44323 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31218 | 44324 | .unused, |
| 31219 | 44325 | .unused, |
| ... | ... | @@ -31234,14 +44340,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31234 | 44340 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31235 | 44341 | } }, |
| 31236 | 44342 | }, .{ |
| 31237 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, |
| 31238 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 44343 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 44344 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31239 | 44345 | .patterns = &.{ |
| 31240 | | .{ .src = .{ .to_mem, .none } }, |
| 44346 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31241 | 44347 | }, |
| 31242 | 44348 | .extra_temps = .{ |
| 31243 | 44349 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31244 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44350 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31245 | 44351 | .unused, |
| 31246 | 44352 | .unused, |
| 31247 | 44353 | .unused, |
| ... | ... | @@ -31254,20 +44360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31254 | 44360 | .clobbers = .{ .eflags = true }, |
| 31255 | 44361 | .each = .{ .once = &.{ |
| 31256 | 44362 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31257 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31258 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31259 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44363 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 44364 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44365 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31260 | 44366 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31261 | 44367 | } }, |
| 31262 | 44368 | }, .{ |
| 31263 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, |
| 31264 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 44369 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 44370 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31265 | 44371 | .patterns = &.{ |
| 31266 | | .{ .src = .{ .to_mem, .none } }, |
| 44372 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31267 | 44373 | }, |
| 31268 | 44374 | .extra_temps = .{ |
| 31269 | 44375 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31270 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 44376 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31271 | 44377 | .unused, |
| 31272 | 44378 | .unused, |
| 31273 | 44379 | .unused, |
| ... | ... | @@ -31280,24 +44386,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31280 | 44386 | .clobbers = .{ .eflags = true }, |
| 31281 | 44387 | .each = .{ .once = &.{ |
| 31282 | 44388 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31283 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 44389 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31284 | 44390 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31285 | 44391 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31286 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31287 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44392 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44393 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31288 | 44394 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31289 | 44395 | } }, |
| 31290 | 44396 | }, .{ |
| 31291 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 31292 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, |
| 31293 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44397 | .required_features = .{ .bmi2, null, null, null }, |
| 44398 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 44399 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31294 | 44400 | .patterns = &.{ |
| 31295 | | .{ .src = .{ .to_mem, .none } }, |
| 44401 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31296 | 44402 | }, |
| 31297 | 44403 | .extra_temps = .{ |
| 31298 | 44404 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31299 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 31300 | | .unused, |
| 44405 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 44406 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31301 | 44407 | .unused, |
| 31302 | 44408 | .unused, |
| 31303 | 44409 | .unused, |
| ... | ... | @@ -31309,21 +44415,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31309 | 44415 | .clobbers = .{ .eflags = true }, |
| 31310 | 44416 | .each = .{ .once = &.{ |
| 31311 | 44417 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31312 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31313 | | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 31314 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31315 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44418 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 44419 | .{ .@"0:", ._, .bzhi, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 44420 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 44421 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31316 | 44422 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31317 | 44423 | } }, |
| 31318 | 44424 | }, .{ |
| 31319 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, |
| 31320 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44425 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 44426 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31321 | 44427 | .patterns = &.{ |
| 31322 | | .{ .src = .{ .to_mem, .none } }, |
| 44428 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31323 | 44429 | }, |
| 31324 | 44430 | .extra_temps = .{ |
| 31325 | 44431 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31326 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44432 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31327 | 44433 | .unused, |
| 31328 | 44434 | .unused, |
| 31329 | 44435 | .unused, |
| ... | ... | @@ -31336,21 +44442,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31336 | 44442 | .clobbers = .{ .eflags = true }, |
| 31337 | 44443 | .each = .{ .once = &.{ |
| 31338 | 44444 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31339 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 44445 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31340 | 44446 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31341 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31342 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44447 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44448 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31343 | 44449 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31344 | 44450 | } }, |
| 31345 | 44451 | }, .{ |
| 31346 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31347 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 44452 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 44453 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31348 | 44454 | .patterns = &.{ |
| 31349 | | .{ .src = .{ .to_mem, .none } }, |
| 44455 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31350 | 44456 | }, |
| 31351 | 44457 | .extra_temps = .{ |
| 31352 | 44458 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31353 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44459 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31354 | 44460 | .unused, |
| 31355 | 44461 | .unused, |
| 31356 | 44462 | .unused, |
| ... | ... | @@ -31364,19 +44470,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31364 | 44470 | .each = .{ .once = &.{ |
| 31365 | 44471 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31366 | 44472 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31367 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31368 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44473 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44474 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31369 | 44475 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31370 | 44476 | } }, |
| 31371 | 44477 | }, .{ |
| 31372 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31373 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 44478 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 44479 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31374 | 44480 | .patterns = &.{ |
| 31375 | | .{ .src = .{ .to_mem, .none } }, |
| 44481 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31376 | 44482 | }, |
| 31377 | 44483 | .extra_temps = .{ |
| 31378 | 44484 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31379 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 44485 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31380 | 44486 | .unused, |
| 31381 | 44487 | .unused, |
| 31382 | 44488 | .unused, |
| ... | ... | @@ -31392,21 +44498,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31392 | 44498 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31393 | 44499 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31394 | 44500 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31395 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31396 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44501 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44502 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31397 | 44503 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31398 | 44504 | } }, |
| 31399 | 44505 | }, .{ |
| 31400 | 44506 | .required_features = .{ .bmi2, null, null, null }, |
| 31401 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31402 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44507 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 44508 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31403 | 44509 | .patterns = &.{ |
| 31404 | | .{ .src = .{ .to_mem, .none } }, |
| 44510 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31405 | 44511 | }, |
| 31406 | 44512 | .extra_temps = .{ |
| 31407 | 44513 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31408 | 44514 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31409 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44515 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31410 | 44516 | .unused, |
| 31411 | 44517 | .unused, |
| 31412 | 44518 | .unused, |
| ... | ... | @@ -31420,47 +44526,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31420 | 44526 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31421 | 44527 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31422 | 44528 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31423 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 31424 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31425 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31426 | | } }, |
| 31427 | | }, .{ |
| 31428 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 31429 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31430 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 31431 | | .patterns = &.{ |
| 31432 | | .{ .src = .{ .to_mem, .none } }, |
| 31433 | | }, |
| 31434 | | .extra_temps = .{ |
| 31435 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31436 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 31437 | | .unused, |
| 31438 | | .unused, |
| 31439 | | .unused, |
| 31440 | | .unused, |
| 31441 | | .unused, |
| 31442 | | .unused, |
| 31443 | | .unused, |
| 31444 | | }, |
| 31445 | | .dst_temps = .{.mem}, |
| 31446 | | .clobbers = .{ .eflags = true }, |
| 31447 | | .each = .{ .once = &.{ |
| 31448 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31449 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31450 | | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 31451 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31452 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44529 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 44530 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31453 | 44531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31454 | 44532 | } }, |
| 31455 | 44533 | }, .{ |
| 31456 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 31457 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44534 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 44535 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31458 | 44536 | .patterns = &.{ |
| 31459 | | .{ .src = .{ .to_mem, .none } }, |
| 44537 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31460 | 44538 | }, |
| 31461 | 44539 | .extra_temps = .{ |
| 31462 | 44540 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31463 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44541 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31464 | 44542 | .unused, |
| 31465 | 44543 | .unused, |
| 31466 | 44544 | .unused, |
| ... | ... | @@ -31475,45 +44553,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31475 | 44553 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31476 | 44554 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31477 | 44555 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31478 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31479 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31480 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31481 | | } }, |
| 31482 | | }, .{ |
| 31483 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31484 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 31485 | | .patterns = &.{ |
| 31486 | | .{ .src = .{ .to_mem, .none } }, |
| 31487 | | }, |
| 31488 | | .extra_temps = .{ |
| 31489 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31490 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 31491 | | .unused, |
| 31492 | | .unused, |
| 31493 | | .unused, |
| 31494 | | .unused, |
| 31495 | | .unused, |
| 31496 | | .unused, |
| 31497 | | .unused, |
| 31498 | | }, |
| 31499 | | .dst_temps = .{.mem}, |
| 31500 | | .clobbers = .{ .eflags = true }, |
| 31501 | | .each = .{ .once = &.{ |
| 31502 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31503 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31504 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31505 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44556 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44557 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31506 | 44558 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31507 | 44559 | } }, |
| 31508 | 44560 | }, .{ |
| 31509 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31510 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 44561 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 44562 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31511 | 44563 | .patterns = &.{ |
| 31512 | | .{ .src = .{ .to_mem, .none } }, |
| 44564 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31513 | 44565 | }, |
| 31514 | 44566 | .extra_temps = .{ |
| 31515 | 44567 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31516 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 44568 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31517 | 44569 | .unused, |
| 31518 | 44570 | .unused, |
| 31519 | 44571 | .unused, |
| ... | ... | @@ -31527,23 +44579,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31527 | 44579 | .each = .{ .once = &.{ |
| 31528 | 44580 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31529 | 44581 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31530 | | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31531 | | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31532 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31533 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44582 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44583 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31534 | 44584 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31535 | 44585 | } }, |
| 31536 | 44586 | }, .{ |
| 31537 | | .required_features = .{ .bmi2, null, null, null }, |
| 31538 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31539 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44587 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 44588 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31540 | 44589 | .patterns = &.{ |
| 31541 | | .{ .src = .{ .to_mem, .none } }, |
| 44590 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31542 | 44591 | }, |
| 31543 | 44592 | .extra_temps = .{ |
| 31544 | 44593 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31545 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31546 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44594 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 44595 | .unused, |
| 31547 | 44596 | .unused, |
| 31548 | 44597 | .unused, |
| 31549 | 44598 | .unused, |
| ... | ... | @@ -31555,23 +44604,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31555 | 44604 | .clobbers = .{ .eflags = true }, |
| 31556 | 44605 | .each = .{ .once = &.{ |
| 31557 | 44606 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31558 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31559 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31560 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 31561 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44607 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 44608 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 44609 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 44610 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44611 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31562 | 44612 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31563 | 44613 | } }, |
| 31564 | 44614 | }, .{ |
| 31565 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 31566 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31567 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44615 | .required_features = .{ .bmi2, null, null, null }, |
| 44616 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 44617 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31568 | 44618 | .patterns = &.{ |
| 31569 | | .{ .src = .{ .to_mem, .none } }, |
| 44619 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31570 | 44620 | }, |
| 31571 | 44621 | .extra_temps = .{ |
| 31572 | 44622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31573 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 31574 | | .unused, |
| 44623 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 44624 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31575 | 44625 | .unused, |
| 31576 | 44626 | .unused, |
| 31577 | 44627 | .unused, |
| ... | ... | @@ -31583,21 +44633,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31583 | 44633 | .clobbers = .{ .eflags = true }, |
| 31584 | 44634 | .each = .{ .once = &.{ |
| 31585 | 44635 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31586 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31587 | | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 31588 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31589 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44636 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 44637 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 44638 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 44639 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31590 | 44640 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31591 | 44641 | } }, |
| 31592 | 44642 | }, .{ |
| 31593 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 31594 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44643 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 44644 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31595 | 44645 | .patterns = &.{ |
| 31596 | | .{ .src = .{ .to_mem, .none } }, |
| 44646 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31597 | 44647 | }, |
| 31598 | 44648 | .extra_temps = .{ |
| 31599 | 44649 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31600 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44650 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31601 | 44651 | .unused, |
| 31602 | 44652 | .unused, |
| 31603 | 44653 | .unused, |
| ... | ... | @@ -31612,19 +44662,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31612 | 44662 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31613 | 44663 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31614 | 44664 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31615 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31616 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44665 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44666 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31617 | 44667 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31618 | 44668 | } }, |
| 31619 | 44669 | }, .{ |
| 31620 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 31621 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 44670 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 44671 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31622 | 44672 | .patterns = &.{ |
| 31623 | | .{ .src = .{ .to_mem, .none } }, |
| 44673 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31624 | 44674 | }, |
| 31625 | 44675 | .extra_temps = .{ |
| 31626 | 44676 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31627 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44677 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31628 | 44678 | .unused, |
| 31629 | 44679 | .unused, |
| 31630 | 44680 | .unused, |
| ... | ... | @@ -31638,19 +44688,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31638 | 44688 | .each = .{ .once = &.{ |
| 31639 | 44689 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31640 | 44690 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31641 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31642 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44691 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44692 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31643 | 44693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31644 | 44694 | } }, |
| 31645 | 44695 | }, .{ |
| 31646 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 31647 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 44696 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 44697 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31648 | 44698 | .patterns = &.{ |
| 31649 | | .{ .src = .{ .to_mem, .none } }, |
| 44699 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31650 | 44700 | }, |
| 31651 | 44701 | .extra_temps = .{ |
| 31652 | 44702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31653 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 44703 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31654 | 44704 | .unused, |
| 31655 | 44705 | .unused, |
| 31656 | 44706 | .unused, |
| ... | ... | @@ -31666,21 +44716,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31666 | 44716 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31667 | 44717 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31668 | 44718 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31669 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31670 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44719 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44720 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31671 | 44721 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31672 | 44722 | } }, |
| 31673 | 44723 | }, .{ |
| 31674 | 44724 | .required_features = .{ .bmi2, null, null, null }, |
| 31675 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 31676 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44725 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 44726 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31677 | 44727 | .patterns = &.{ |
| 31678 | | .{ .src = .{ .to_mem, .none } }, |
| 44728 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31679 | 44729 | }, |
| 31680 | 44730 | .extra_temps = .{ |
| 31681 | 44731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31682 | 44732 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31683 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44733 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31684 | 44734 | .unused, |
| 31685 | 44735 | .unused, |
| 31686 | 44736 | .unused, |
| ... | ... | @@ -31694,47 +44744,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31694 | 44744 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31695 | 44745 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31696 | 44746 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31697 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 31698 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31699 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31700 | | } }, |
| 31701 | | }, .{ |
| 31702 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 31703 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 31704 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 31705 | | .patterns = &.{ |
| 31706 | | .{ .src = .{ .to_mem, .none } }, |
| 31707 | | }, |
| 31708 | | .extra_temps = .{ |
| 31709 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31710 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 31711 | | .unused, |
| 31712 | | .unused, |
| 31713 | | .unused, |
| 31714 | | .unused, |
| 31715 | | .unused, |
| 31716 | | .unused, |
| 31717 | | .unused, |
| 31718 | | }, |
| 31719 | | .dst_temps = .{.mem}, |
| 31720 | | .clobbers = .{ .eflags = true }, |
| 31721 | | .each = .{ .once = &.{ |
| 31722 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31723 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31724 | | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 31725 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31726 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44747 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 44748 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31727 | 44749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31728 | 44750 | } }, |
| 31729 | 44751 | }, .{ |
| 31730 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 31731 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44752 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 44753 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31732 | 44754 | .patterns = &.{ |
| 31733 | | .{ .src = .{ .to_mem, .none } }, |
| 44755 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31734 | 44756 | }, |
| 31735 | 44757 | .extra_temps = .{ |
| 31736 | 44758 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31737 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44759 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31738 | 44760 | .unused, |
| 31739 | 44761 | .unused, |
| 31740 | 44762 | .unused, |
| ... | ... | @@ -31749,20 +44771,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31749 | 44771 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31750 | 44772 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31751 | 44773 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31752 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 31753 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44774 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 44775 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31754 | 44776 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31755 | 44777 | } }, |
| 31756 | 44778 | }, .{ |
| 31757 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 31758 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 44779 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 44780 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31759 | 44781 | .patterns = &.{ |
| 31760 | | .{ .src = .{ .to_mem, .none } }, |
| 44782 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31761 | 44783 | }, |
| 31762 | 44784 | .extra_temps = .{ |
| 31763 | 44785 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31764 | 44786 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31765 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44787 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31766 | 44788 | .unused, |
| 31767 | 44789 | .unused, |
| 31768 | 44790 | .unused, |
| ... | ... | @@ -31776,21 +44798,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31776 | 44798 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31777 | 44799 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31778 | 44800 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 31779 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 44801 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31780 | 44802 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31781 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44803 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31782 | 44804 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31783 | 44805 | } }, |
| 31784 | 44806 | }, .{ |
| 31785 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 31786 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 44807 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 44808 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31787 | 44809 | .patterns = &.{ |
| 31788 | | .{ .src = .{ .to_mem, .none } }, |
| 44810 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31789 | 44811 | }, |
| 31790 | 44812 | .extra_temps = .{ |
| 31791 | 44813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31792 | 44814 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31793 | | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 44815 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31794 | 44816 | .unused, |
| 31795 | 44817 | .unused, |
| 31796 | 44818 | .unused, |
| ... | ... | @@ -31806,23 +44828,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31806 | 44828 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 31807 | 44829 | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31808 | 44830 | .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31809 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 44831 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31810 | 44832 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31811 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44833 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31812 | 44834 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31813 | 44835 | } }, |
| 31814 | 44836 | }, .{ |
| 31815 | 44837 | .required_features = .{ .bmi2, null, null, null }, |
| 31816 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 31817 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44838 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 44839 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31818 | 44840 | .patterns = &.{ |
| 31819 | | .{ .src = .{ .to_mem, .none } }, |
| 44841 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31820 | 44842 | }, |
| 31821 | 44843 | .extra_temps = .{ |
| 31822 | 44844 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31823 | 44845 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31824 | 44846 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31825 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44847 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31826 | 44848 | .unused, |
| 31827 | 44849 | .unused, |
| 31828 | 44850 | .unused, |
| ... | ... | @@ -31836,22 +44858,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31836 | 44858 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31837 | 44859 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31838 | 44860 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 31839 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 44861 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 31840 | 44862 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31841 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44863 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31842 | 44864 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31843 | 44865 | } }, |
| 31844 | 44866 | }, .{ |
| 31845 | | .required_features = .{ .fast_imm16, null, null, null }, |
| 31846 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 31847 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44867 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 44868 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31848 | 44869 | .patterns = &.{ |
| 31849 | | .{ .src = .{ .to_mem, .none } }, |
| 44870 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31850 | 44871 | }, |
| 31851 | 44872 | .extra_temps = .{ |
| 31852 | 44873 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31853 | 44874 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31854 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44875 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31855 | 44876 | .unused, |
| 31856 | 44877 | .unused, |
| 31857 | 44878 | .unused, |
| ... | ... | @@ -31865,22 +44886,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31865 | 44886 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31866 | 44887 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31867 | 44888 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 31868 | | .{ ._, ._, .@"and", .tmp2w, .sa(.dst0, .add_umax), ._, ._ }, |
| 31869 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 44889 | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, |
| 44890 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31870 | 44891 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31871 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 44892 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31872 | 44893 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31873 | 44894 | } }, |
| 31874 | 44895 | }, .{ |
| 31875 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 31876 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 44896 | .required_features = .{ .avx, null, null, null }, |
| 44897 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 44898 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 31877 | 44899 | .patterns = &.{ |
| 31878 | | .{ .src = .{ .to_mem, .none } }, |
| 44900 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31879 | 44901 | }, |
| 31880 | 44902 | .extra_temps = .{ |
| 31881 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31882 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31883 | | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 44903 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 44904 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 44905 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 31884 | 44906 | .unused, |
| 31885 | 44907 | .unused, |
| 31886 | 44908 | .unused, |
| ... | ... | @@ -31888,36 +44910,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31888 | 44910 | .unused, |
| 31889 | 44911 | .unused, |
| 31890 | 44912 | }, |
| 31891 | | .dst_temps = .{.mem}, |
| 31892 | | .clobbers = .{ .eflags = true }, |
| 31893 | | .each = .{ .once = &.{ |
| 31894 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31895 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31896 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 31897 | | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31898 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 31899 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31900 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 31901 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31902 | | } }, |
| 31903 | | }, .{ |
| 31904 | | .required_features = .{ .avx, null, null, null }, |
| 31905 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 31906 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 31907 | | .patterns = &.{ |
| 31908 | | .{ .src = .{ .to_sse, .none } }, |
| 31909 | | }, |
| 31910 | 44913 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31911 | 44914 | .each = .{ .once = &.{ |
| 31912 | | .{ ._, .vp_d, .sll, .dst0x, .src0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 31913 | | .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 44915 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 44916 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 44917 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 44918 | .{ ._, .vp_q, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 44919 | .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 31914 | 44920 | } }, |
| 31915 | 44921 | }, .{ |
| 31916 | 44922 | .required_features = .{ .avx, null, null, null }, |
| 31917 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 31918 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 44923 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 44924 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 31919 | 44925 | .patterns = &.{ |
| 31920 | | .{ .src = .{ .to_sse, .none } }, |
| 44926 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31921 | 44927 | }, |
| 31922 | 44928 | .extra_temps = .{ |
| 31923 | 44929 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -31937,22 +44943,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31937 | 44943 | } }, |
| 31938 | 44944 | }, .{ |
| 31939 | 44945 | .required_features = .{ .sse2, null, null, null }, |
| 31940 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 31941 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 44946 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 44947 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 31942 | 44948 | .patterns = &.{ |
| 31943 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 44949 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 44950 | }, |
| 44951 | .extra_temps = .{ |
| 44952 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 44953 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 44954 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 44955 | .unused, |
| 44956 | .unused, |
| 44957 | .unused, |
| 44958 | .unused, |
| 44959 | .unused, |
| 44960 | .unused, |
| 31944 | 44961 | }, |
| 31945 | 44962 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31946 | 44963 | .each = .{ .once = &.{ |
| 31947 | | .{ ._, .p_d, .sll, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31948 | | .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 44964 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 44965 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 44966 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 44967 | .{ ._, .p_q, .add, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 44968 | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 31949 | 44969 | } }, |
| 31950 | 44970 | }, .{ |
| 31951 | 44971 | .required_features = .{ .sse2, null, null, null }, |
| 31952 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 31953 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 44972 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 44973 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 31954 | 44974 | .patterns = &.{ |
| 31955 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 44975 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 31956 | 44976 | }, |
| 31957 | 44977 | .extra_temps = .{ |
| 31958 | 44978 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -31972,10 +44992,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31972 | 44992 | } }, |
| 31973 | 44993 | }, .{ |
| 31974 | 44994 | .required_features = .{ .sse, null, null, null }, |
| 31975 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 31976 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 44995 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 44996 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 31977 | 44997 | .patterns = &.{ |
| 31978 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 44998 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 31979 | 44999 | }, |
| 31980 | 45000 | .extra_temps = .{ |
| 31981 | 45001 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -31995,22 +45015,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31995 | 45015 | } }, |
| 31996 | 45016 | }, .{ |
| 31997 | 45017 | .required_features = .{ .avx2, null, null, null }, |
| 31998 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 31999 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 45018 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 45019 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 32000 | 45020 | .patterns = &.{ |
| 32001 | | .{ .src = .{ .to_sse, .none } }, |
| 45021 | .{ .src = .{ .to_sse, .none, .none } }, |
| 45022 | }, |
| 45023 | .extra_temps = .{ |
| 45024 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 45025 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 45026 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 45027 | .unused, |
| 45028 | .unused, |
| 45029 | .unused, |
| 45030 | .unused, |
| 45031 | .unused, |
| 45032 | .unused, |
| 32002 | 45033 | }, |
| 32003 | 45034 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 32004 | 45035 | .each = .{ .once = &.{ |
| 32005 | | .{ ._, .vp_d, .sll, .dst0y, .src0y, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 32006 | | .{ ._, .vp_d, .sra, .dst0y, .dst0y, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 45036 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 45037 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 45038 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 45039 | .{ ._, .vp_q, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 45040 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 32007 | 45041 | } }, |
| 32008 | 45042 | }, .{ |
| 32009 | 45043 | .required_features = .{ .avx2, null, null, null }, |
| 32010 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 32011 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, |
| 45044 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 45045 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, |
| 32012 | 45046 | .patterns = &.{ |
| 32013 | | .{ .src = .{ .to_sse, .none } }, |
| 45047 | .{ .src = .{ .to_sse, .none, .none } }, |
| 32014 | 45048 | }, |
| 32015 | 45049 | .extra_temps = .{ |
| 32016 | 45050 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -32030,18 +45064,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32030 | 45064 | } }, |
| 32031 | 45065 | }, .{ |
| 32032 | 45066 | .required_features = .{ .avx2, null, null, null }, |
| 32033 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 32034 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 45067 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 45068 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 32035 | 45069 | .patterns = &.{ |
| 32036 | | .{ .src = .{ .to_mem, .none } }, |
| 45070 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32037 | 45071 | }, |
| 32038 | 45072 | .extra_temps = .{ |
| 32039 | 45073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32040 | | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 32041 | | .unused, |
| 32042 | | .unused, |
| 32043 | | .unused, |
| 32044 | | .unused, |
| 45074 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 45075 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 45076 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 45077 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 45078 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32045 | 45079 | .unused, |
| 32046 | 45080 | .unused, |
| 32047 | 45081 | .unused, |
| ... | ... | @@ -32049,25 +45083,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32049 | 45083 | .dst_temps = .{.mem}, |
| 32050 | 45084 | .clobbers = .{ .eflags = true }, |
| 32051 | 45085 | .each = .{ .once = &.{ |
| 45086 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 45087 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 45088 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 45089 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 32052 | 45090 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32053 | | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32054 | | .{ ._, .vp_d, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 32055 | | .{ ._, .vp_d, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 32056 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 45091 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 45092 | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 45093 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 45094 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 32057 | 45095 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 32058 | 45096 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32059 | 45097 | } }, |
| 32060 | 45098 | }, .{ |
| 32061 | 45099 | .required_features = .{ .avx2, null, null, null }, |
| 32062 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any }, |
| 32063 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, |
| 45100 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 45101 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, |
| 32064 | 45102 | .patterns = &.{ |
| 32065 | | .{ .src = .{ .to_mem, .none } }, |
| 45103 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32066 | 45104 | }, |
| 32067 | 45105 | .extra_temps = .{ |
| 32068 | 45106 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32069 | | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 32070 | | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 45107 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 45108 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 32071 | 45109 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32072 | 45110 | .unused, |
| 32073 | 45111 | .unused, |
| ... | ... | @@ -32088,18 +45126,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32088 | 45126 | } }, |
| 32089 | 45127 | }, .{ |
| 32090 | 45128 | .required_features = .{ .avx, null, null, null }, |
| 32091 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 32092 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 45129 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 45130 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32093 | 45131 | .patterns = &.{ |
| 32094 | | .{ .src = .{ .to_mem, .none } }, |
| 45132 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32095 | 45133 | }, |
| 32096 | 45134 | .extra_temps = .{ |
| 32097 | 45135 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32098 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 32099 | | .unused, |
| 32100 | | .unused, |
| 32101 | | .unused, |
| 32102 | | .unused, |
| 45136 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 45137 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 45138 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 45139 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 45140 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32103 | 45141 | .unused, |
| 32104 | 45142 | .unused, |
| 32105 | 45143 | .unused, |
| ... | ... | @@ -32107,25 +45145,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32107 | 45145 | .dst_temps = .{.mem}, |
| 32108 | 45146 | .clobbers = .{ .eflags = true }, |
| 32109 | 45147 | .each = .{ .once = &.{ |
| 45148 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 45149 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 45150 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 45151 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 32110 | 45152 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32111 | | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32112 | | .{ ._, .vp_d, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 32113 | | .{ ._, .vp_d, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 32114 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 45153 | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 45154 | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 45155 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 45156 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 32115 | 45157 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32116 | 45158 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32117 | 45159 | } }, |
| 32118 | 45160 | }, .{ |
| 32119 | 45161 | .required_features = .{ .avx, null, null, null }, |
| 32120 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 32121 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 45162 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 45163 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32122 | 45164 | .patterns = &.{ |
| 32123 | | .{ .src = .{ .to_mem, .none } }, |
| 45165 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32124 | 45166 | }, |
| 32125 | 45167 | .extra_temps = .{ |
| 32126 | 45168 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32127 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 32128 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 45169 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 45170 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32129 | 45171 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32130 | 45172 | .unused, |
| 32131 | 45173 | .unused, |
| ... | ... | @@ -32146,18 +45188,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32146 | 45188 | } }, |
| 32147 | 45189 | }, .{ |
| 32148 | 45190 | .required_features = .{ .sse2, null, null, null }, |
| 32149 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 32150 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 45191 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 45192 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32151 | 45193 | .patterns = &.{ |
| 32152 | | .{ .src = .{ .to_mem, .none } }, |
| 45194 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32153 | 45195 | }, |
| 32154 | 45196 | .extra_temps = .{ |
| 32155 | 45197 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32156 | | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 32157 | | .unused, |
| 32158 | | .unused, |
| 32159 | | .unused, |
| 32160 | | .unused, |
| 45198 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 45199 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 45200 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 45201 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 45202 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32161 | 45203 | .unused, |
| 32162 | 45204 | .unused, |
| 32163 | 45205 | .unused, |
| ... | ... | @@ -32165,25 +45207,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32165 | 45207 | .dst_temps = .{.mem}, |
| 32166 | 45208 | .clobbers = .{ .eflags = true }, |
| 32167 | 45209 | .each = .{ .once = &.{ |
| 45210 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 45211 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 45212 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 45213 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 32168 | 45214 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32169 | | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32170 | | .{ ._, .p_d, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 32171 | | .{ ._, .p_d, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 32172 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 45215 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ }, |
| 45216 | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 45217 | .{ ._, .p_q, .add, .tmp3x, .tmp2x, ._, ._ }, |
| 45218 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| 45219 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 32173 | 45220 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32174 | 45221 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32175 | 45222 | } }, |
| 32176 | 45223 | }, .{ |
| 32177 | 45224 | .required_features = .{ .sse2, null, null, null }, |
| 32178 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 32179 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 45225 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 45226 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32180 | 45227 | .patterns = &.{ |
| 32181 | | .{ .src = .{ .to_mem, .none } }, |
| 45228 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32182 | 45229 | }, |
| 32183 | 45230 | .extra_temps = .{ |
| 32184 | 45231 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32185 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 32186 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 45232 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 45233 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32187 | 45234 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32188 | 45235 | .unused, |
| 32189 | 45236 | .unused, |
| ... | ... | @@ -32205,15 +45252,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32205 | 45252 | } }, |
| 32206 | 45253 | }, .{ |
| 32207 | 45254 | .required_features = .{ .sse, null, null, null }, |
| 32208 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, |
| 32209 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 45255 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 45256 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32210 | 45257 | .patterns = &.{ |
| 32211 | | .{ .src = .{ .to_mem, .none } }, |
| 45258 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32212 | 45259 | }, |
| 32213 | 45260 | .extra_temps = .{ |
| 32214 | 45261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32215 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 32216 | | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 45262 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 45263 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32217 | 45264 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32218 | 45265 | .unused, |
| 32219 | 45266 | .unused, |
| ... | ... | @@ -32234,14 +45281,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32234 | 45281 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32235 | 45282 | } }, |
| 32236 | 45283 | }, .{ |
| 32237 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 32238 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 45284 | .required_features = .{ .@"64bit", null, null, null }, |
| 45285 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 45286 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32239 | 45287 | .patterns = &.{ |
| 32240 | | .{ .src = .{ .to_mem, .none } }, |
| 45288 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32241 | 45289 | }, |
| 32242 | 45290 | .extra_temps = .{ |
| 32243 | 45291 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32244 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45292 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32245 | 45293 | .unused, |
| 32246 | 45294 | .unused, |
| 32247 | 45295 | .unused, |
| ... | ... | @@ -32254,20 +45302,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32254 | 45302 | .clobbers = .{ .eflags = true }, |
| 32255 | 45303 | .each = .{ .once = &.{ |
| 32256 | 45304 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32257 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32258 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32259 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45305 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 45306 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45307 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32260 | 45308 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32261 | 45309 | } }, |
| 32262 | 45310 | }, .{ |
| 32263 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 32264 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 45311 | .required_features = .{ .@"64bit", null, null, null }, |
| 45312 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 45313 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 32265 | 45314 | .patterns = &.{ |
| 32266 | | .{ .src = .{ .to_mem, .none } }, |
| 45315 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32267 | 45316 | }, |
| 32268 | 45317 | .extra_temps = .{ |
| 32269 | 45318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32270 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 45319 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 32271 | 45320 | .unused, |
| 32272 | 45321 | .unused, |
| 32273 | 45322 | .unused, |
| ... | ... | @@ -32280,24 +45329,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32280 | 45329 | .clobbers = .{ .eflags = true }, |
| 32281 | 45330 | .each = .{ .once = &.{ |
| 32282 | 45331 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32283 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32284 | | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32285 | | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32286 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32287 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45332 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 45333 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45334 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45335 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45336 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32288 | 45337 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32289 | 45338 | } }, |
| 32290 | 45339 | }, .{ |
| 32291 | | .required_features = .{ .bmi2, null, null, null }, |
| 32292 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 32293 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45340 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 45341 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 45342 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32294 | 45343 | .patterns = &.{ |
| 32295 | | .{ .src = .{ .to_mem, .none } }, |
| 45344 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32296 | 45345 | }, |
| 32297 | 45346 | .extra_temps = .{ |
| 32298 | 45347 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32299 | 45348 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32300 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45349 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32301 | 45350 | .unused, |
| 32302 | 45351 | .unused, |
| 32303 | 45352 | .unused, |
| ... | ... | @@ -32310,20 +45359,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32310 | 45359 | .each = .{ .once = &.{ |
| 32311 | 45360 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32312 | 45361 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32313 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 32314 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32315 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45362 | .{ .@"0:", ._, .bzhi, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 45363 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 45364 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32316 | 45365 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32317 | 45366 | } }, |
| 32318 | 45367 | }, .{ |
| 32319 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, |
| 32320 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45368 | .required_features = .{ .@"64bit", null, null, null }, |
| 45369 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 45370 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32321 | 45371 | .patterns = &.{ |
| 32322 | | .{ .src = .{ .to_mem, .none } }, |
| 45372 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32323 | 45373 | }, |
| 32324 | 45374 | .extra_temps = .{ |
| 32325 | 45375 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32326 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45376 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32327 | 45377 | .unused, |
| 32328 | 45378 | .unused, |
| 32329 | 45379 | .unused, |
| ... | ... | @@ -32336,21 +45386,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32336 | 45386 | .clobbers = .{ .eflags = true }, |
| 32337 | 45387 | .each = .{ .once = &.{ |
| 32338 | 45388 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32339 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32340 | | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 32341 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32342 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45389 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 45390 | .{ ._, ._, .@"and", .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 45391 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45392 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32343 | 45393 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32344 | 45394 | } }, |
| 32345 | 45395 | }, .{ |
| 32346 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 32347 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 45396 | .required_features = .{ .@"64bit", null, null, null }, |
| 45397 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 45398 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32348 | 45399 | .patterns = &.{ |
| 32349 | | .{ .src = .{ .to_mem, .none } }, |
| 45400 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32350 | 45401 | }, |
| 32351 | 45402 | .extra_temps = .{ |
| 32352 | 45403 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32353 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45404 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32354 | 45405 | .unused, |
| 32355 | 45406 | .unused, |
| 32356 | 45407 | .unused, |
| ... | ... | @@ -32363,20 +45414,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32363 | 45414 | .clobbers = .{ .eflags = true }, |
| 32364 | 45415 | .each = .{ .once = &.{ |
| 32365 | 45416 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32366 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32367 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32368 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45417 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 45418 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45419 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32369 | 45420 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32370 | 45421 | } }, |
| 32371 | 45422 | }, .{ |
| 32372 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 32373 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 45423 | .required_features = .{ .@"64bit", null, null, null }, |
| 45424 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 45425 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 32374 | 45426 | .patterns = &.{ |
| 32375 | | .{ .src = .{ .to_mem, .none } }, |
| 45427 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32376 | 45428 | }, |
| 32377 | 45429 | .extra_temps = .{ |
| 32378 | 45430 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32379 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 45431 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 32380 | 45432 | .unused, |
| 32381 | 45433 | .unused, |
| 32382 | 45434 | .unused, |
| ... | ... | @@ -32389,24 +45441,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32389 | 45441 | .clobbers = .{ .eflags = true }, |
| 32390 | 45442 | .each = .{ .once = &.{ |
| 32391 | 45443 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32392 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32393 | | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32394 | | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32395 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32396 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45444 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 45445 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45446 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45447 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45448 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32397 | 45449 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32398 | 45450 | } }, |
| 32399 | 45451 | }, .{ |
| 32400 | | .required_features = .{ .bmi2, null, null, null }, |
| 32401 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 32402 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45452 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 45453 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 45454 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32403 | 45455 | .patterns = &.{ |
| 32404 | | .{ .src = .{ .to_mem, .none } }, |
| 45456 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32405 | 45457 | }, |
| 32406 | 45458 | .extra_temps = .{ |
| 32407 | 45459 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32408 | 45460 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32409 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45461 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32410 | 45462 | .unused, |
| 32411 | 45463 | .unused, |
| 32412 | 45464 | .unused, |
| ... | ... | @@ -32419,20 +45471,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32419 | 45471 | .each = .{ .once = &.{ |
| 32420 | 45472 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32421 | 45473 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32422 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 32423 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32424 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45474 | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 45475 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 45476 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32425 | 45477 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32426 | 45478 | } }, |
| 32427 | 45479 | }, .{ |
| 32428 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 32429 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45480 | .required_features = .{ .@"64bit", null, null, null }, |
| 45481 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 45482 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32430 | 45483 | .patterns = &.{ |
| 32431 | | .{ .src = .{ .to_mem, .none } }, |
| 45484 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32432 | 45485 | }, |
| 32433 | 45486 | .extra_temps = .{ |
| 32434 | 45487 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32435 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45488 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32436 | 45489 | .unused, |
| 32437 | 45490 | .unused, |
| 32438 | 45491 | .unused, |
| ... | ... | @@ -32445,21 +45498,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32445 | 45498 | .clobbers = .{ .eflags = true }, |
| 32446 | 45499 | .each = .{ .once = &.{ |
| 32447 | 45500 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32448 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32449 | | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 32450 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32451 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45501 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 45502 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 45503 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45504 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32452 | 45505 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32453 | 45506 | } }, |
| 32454 | 45507 | }, .{ |
| 32455 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 32456 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 45508 | .required_features = .{ .@"64bit", null, null, null }, |
| 45509 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 45510 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32457 | 45511 | .patterns = &.{ |
| 32458 | | .{ .src = .{ .to_mem, .none } }, |
| 45512 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32459 | 45513 | }, |
| 32460 | 45514 | .extra_temps = .{ |
| 32461 | 45515 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32462 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45516 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32463 | 45517 | .unused, |
| 32464 | 45518 | .unused, |
| 32465 | 45519 | .unused, |
| ... | ... | @@ -32472,20 +45526,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32472 | 45526 | .clobbers = .{ .eflags = true }, |
| 32473 | 45527 | .each = .{ .once = &.{ |
| 32474 | 45528 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32475 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32476 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32477 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45529 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 45530 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45531 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32478 | 45532 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32479 | 45533 | } }, |
| 32480 | 45534 | }, .{ |
| 32481 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 32482 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 45535 | .required_features = .{ .@"64bit", null, null, null }, |
| 45536 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 45537 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 32483 | 45538 | .patterns = &.{ |
| 32484 | | .{ .src = .{ .to_mem, .none } }, |
| 45539 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32485 | 45540 | }, |
| 32486 | 45541 | .extra_temps = .{ |
| 32487 | 45542 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32488 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 45543 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 32489 | 45544 | .unused, |
| 32490 | 45545 | .unused, |
| 32491 | 45546 | .unused, |
| ... | ... | @@ -32498,24 +45553,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32498 | 45553 | .clobbers = .{ .eflags = true }, |
| 32499 | 45554 | .each = .{ .once = &.{ |
| 32500 | 45555 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32501 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32502 | | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32503 | | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32504 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32505 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45556 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 45557 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45558 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45559 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45560 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32506 | 45561 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32507 | 45562 | } }, |
| 32508 | 45563 | }, .{ |
| 32509 | | .required_features = .{ .bmi2, null, null, null }, |
| 32510 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 32511 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45564 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 45565 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 45566 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32512 | 45567 | .patterns = &.{ |
| 32513 | | .{ .src = .{ .to_mem, .none } }, |
| 45568 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32514 | 45569 | }, |
| 32515 | 45570 | .extra_temps = .{ |
| 32516 | 45571 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32517 | 45572 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32518 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45573 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32519 | 45574 | .unused, |
| 32520 | 45575 | .unused, |
| 32521 | 45576 | .unused, |
| ... | ... | @@ -32528,25 +45583,83 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32528 | 45583 | .each = .{ .once = &.{ |
| 32529 | 45584 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32530 | 45585 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32531 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 32532 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32533 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45586 | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 45587 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 45588 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32534 | 45589 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32535 | 45590 | } }, |
| 32536 | 45591 | }, .{ |
| 32537 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 32538 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45592 | .required_features = .{ .@"64bit", null, null, null }, |
| 45593 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 45594 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 45595 | .patterns = &.{ |
| 45596 | .{ .src = .{ .to_mem, .none, .none } }, |
| 45597 | }, |
| 45598 | .extra_temps = .{ |
| 45599 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 45600 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 45601 | .unused, |
| 45602 | .unused, |
| 45603 | .unused, |
| 45604 | .unused, |
| 45605 | .unused, |
| 45606 | .unused, |
| 45607 | .unused, |
| 45608 | }, |
| 45609 | .dst_temps = .{.mem}, |
| 45610 | .clobbers = .{ .eflags = true }, |
| 45611 | .each = .{ .once = &.{ |
| 45612 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 45613 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 45614 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 45615 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 45616 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 45617 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45618 | } }, |
| 45619 | }, .{ |
| 45620 | .required_features = .{ .@"64bit", null, null, null }, |
| 45621 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 45622 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32539 | 45623 | .patterns = &.{ |
| 32540 | | .{ .src = .{ .to_mem, .none } }, |
| 45624 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32541 | 45625 | }, |
| 32542 | 45626 | .extra_temps = .{ |
| 32543 | 45627 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32544 | 45628 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45629 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 45630 | .unused, |
| 32545 | 45631 | .unused, |
| 32546 | 45632 | .unused, |
| 32547 | 45633 | .unused, |
| 32548 | 45634 | .unused, |
| 32549 | 45635 | .unused, |
| 45636 | }, |
| 45637 | .dst_temps = .{.mem}, |
| 45638 | .clobbers = .{ .eflags = true }, |
| 45639 | .each = .{ .once = &.{ |
| 45640 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 45641 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 45642 | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 45643 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 45644 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 45645 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 45646 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45647 | } }, |
| 45648 | }, .{ |
| 45649 | .required_features = .{ .@"64bit", null, null, null }, |
| 45650 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45651 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 45652 | .patterns = &.{ |
| 45653 | .{ .src = .{ .to_mem, .none, .none } }, |
| 45654 | }, |
| 45655 | .extra_temps = .{ |
| 45656 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 45657 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45658 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 45659 | .unused, |
| 45660 | .unused, |
| 45661 | .unused, |
| 45662 | .unused, |
| 32550 | 45663 | .unused, |
| 32551 | 45664 | .unused, |
| 32552 | 45665 | }, |
| ... | ... | @@ -32554,23 +45667,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32554 | 45667 | .clobbers = .{ .eflags = true }, |
| 32555 | 45668 | .each = .{ .once = &.{ |
| 32556 | 45669 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32557 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32558 | | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 32559 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32560 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45670 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 45671 | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 45672 | .{ ._, ._l, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45673 | .{ ._, ._r, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 45674 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 45675 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 45676 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32561 | 45677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32562 | 45678 | } }, |
| 32563 | 45679 | }, .{ |
| 32564 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 32565 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 45680 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 45681 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 45682 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32566 | 45683 | .patterns = &.{ |
| 32567 | | .{ .src = .{ .to_mem, .none } }, |
| 45684 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32568 | 45685 | }, |
| 32569 | 45686 | .extra_temps = .{ |
| 32570 | 45687 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32571 | 45688 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32572 | | .unused, |
| 32573 | | .unused, |
| 45689 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 45690 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32574 | 45691 | .unused, |
| 32575 | 45692 | .unused, |
| 32576 | 45693 | .unused, |
| ... | ... | @@ -32581,21 +45698,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32581 | 45698 | .clobbers = .{ .eflags = true }, |
| 32582 | 45699 | .each = .{ .once = &.{ |
| 32583 | 45700 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32584 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32585 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32586 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45701 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 45702 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 45703 | .{ .@"0:", ._, .bzhi, .tmp3q, .memi(.src0q, .tmp1), .tmp2q, ._ }, |
| 45704 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 45705 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 45706 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32587 | 45707 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32588 | 45708 | } }, |
| 32589 | 45709 | }, .{ |
| 32590 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 32591 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 45710 | .required_features = .{ .@"64bit", null, null, null }, |
| 45711 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 45712 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32592 | 45713 | .patterns = &.{ |
| 32593 | | .{ .src = .{ .to_mem, .none } }, |
| 45714 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32594 | 45715 | }, |
| 32595 | 45716 | .extra_temps = .{ |
| 32596 | 45717 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32597 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 32598 | | .unused, |
| 45718 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45719 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32599 | 45720 | .unused, |
| 32600 | 45721 | .unused, |
| 32601 | 45722 | .unused, |
| ... | ... | @@ -32607,25 +45728,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32607 | 45728 | .clobbers = .{ .eflags = true }, |
| 32608 | 45729 | .each = .{ .once = &.{ |
| 32609 | 45730 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32610 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32611 | | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32612 | | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32613 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32614 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 45731 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 45732 | .{ .@"0:", ._, .mov, .tmp2q, .ua(.dst0, .add_umax), ._, ._ }, |
| 45733 | .{ ._, ._, .@"and", .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 45734 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 45735 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 45736 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32615 | 45737 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32616 | 45738 | } }, |
| 32617 | 45739 | }, .{ |
| 32618 | | .required_features = .{ .bmi2, null, null, null }, |
| 32619 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 32620 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45740 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 45741 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 45742 | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 32621 | 45743 | .patterns = &.{ |
| 32622 | | .{ .src = .{ .to_mem, .none } }, |
| 45744 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32623 | 45745 | }, |
| 32624 | 45746 | .extra_temps = .{ |
| 32625 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32626 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32627 | 45747 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32628 | | .unused, |
| 45748 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45749 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45750 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32629 | 45751 | .unused, |
| 32630 | 45752 | .unused, |
| 32631 | 45753 | .unused, |
| ... | ... | @@ -32635,24 +45757,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32635 | 45757 | .dst_temps = .{.mem}, |
| 32636 | 45758 | .clobbers = .{ .eflags = true }, |
| 32637 | 45759 | .each = .{ .once = &.{ |
| 32638 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32639 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32640 | | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 32641 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32642 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 32643 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45760 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45761 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45762 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45763 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 45764 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45765 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45766 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 45767 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32644 | 45768 | } }, |
| 32645 | 45769 | }, .{ |
| 32646 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 32647 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45770 | .required_features = .{ .@"64bit", null, null, null }, |
| 45771 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 45772 | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 32648 | 45773 | .patterns = &.{ |
| 32649 | | .{ .src = .{ .to_mem, .none } }, |
| 45774 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32650 | 45775 | }, |
| 32651 | 45776 | .extra_temps = .{ |
| 32652 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32653 | 45777 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32654 | | .unused, |
| 32655 | | .unused, |
| 45778 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45779 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45780 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32656 | 45781 | .unused, |
| 32657 | 45782 | .unused, |
| 32658 | 45783 | .unused, |
| ... | ... | @@ -32662,24 +45787,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32662 | 45787 | .dst_temps = .{.mem}, |
| 32663 | 45788 | .clobbers = .{ .eflags = true }, |
| 32664 | 45789 | .each = .{ .once = &.{ |
| 32665 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32666 | | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32667 | | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 32668 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 32669 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 32670 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45790 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45791 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45792 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45793 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 45794 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45795 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45796 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 45797 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32671 | 45798 | } }, |
| 32672 | 45799 | }, .{ |
| 32673 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 32674 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 45800 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 45801 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45802 | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32675 | 45803 | .patterns = &.{ |
| 32676 | | .{ .src = .{ .to_mem, .none } }, |
| 45804 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32677 | 45805 | }, |
| 32678 | 45806 | .extra_temps = .{ |
| 32679 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32680 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32681 | 45807 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32682 | | .unused, |
| 45808 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45809 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45810 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32683 | 45811 | .unused, |
| 32684 | 45812 | .unused, |
| 32685 | 45813 | .unused, |
| ... | ... | @@ -32689,25 +45817,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32689 | 45817 | .dst_temps = .{.mem}, |
| 32690 | 45818 | .clobbers = .{ .eflags = true }, |
| 32691 | 45819 | .each = .{ .once = &.{ |
| 32692 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32693 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32694 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 32695 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32696 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 32697 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 32698 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45820 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45821 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45822 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45823 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 45824 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45825 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 45826 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 45827 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 45828 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 45829 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45830 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 45831 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 45832 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32699 | 45833 | } }, |
| 32700 | 45834 | }, .{ |
| 32701 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 32702 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 45835 | .required_features = .{ .@"64bit", null, null, null }, |
| 45836 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45837 | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32703 | 45838 | .patterns = &.{ |
| 32704 | | .{ .src = .{ .to_mem, .none } }, |
| 45839 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32705 | 45840 | }, |
| 32706 | 45841 | .extra_temps = .{ |
| 32707 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32708 | 45842 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32709 | | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 32710 | | .unused, |
| 45843 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45844 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45845 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32711 | 45846 | .unused, |
| 32712 | 45847 | .unused, |
| 32713 | 45848 | .unused, |
| ... | ... | @@ -32717,28 +45852,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32717 | 45852 | .dst_temps = .{.mem}, |
| 32718 | 45853 | .clobbers = .{ .eflags = true }, |
| 32719 | 45854 | .each = .{ .once = &.{ |
| 32720 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32721 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32722 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 32723 | | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32724 | | .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 32725 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32726 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 32727 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 32728 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45855 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45856 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45857 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45858 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 45859 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45860 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 45861 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 45862 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 45863 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 45864 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45865 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 45866 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 45867 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32729 | 45868 | } }, |
| 32730 | 45869 | }, .{ |
| 32731 | | .required_features = .{ .bmi2, null, null, null }, |
| 32732 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 32733 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45870 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 45871 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45872 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32734 | 45873 | .patterns = &.{ |
| 32735 | | .{ .src = .{ .to_mem, .none } }, |
| 45874 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32736 | 45875 | }, |
| 32737 | 45876 | .extra_temps = .{ |
| 32738 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32739 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32740 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32741 | 45877 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45878 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45879 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45880 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32742 | 45881 | .unused, |
| 32743 | 45882 | .unused, |
| 32744 | 45883 | .unused, |
| ... | ... | @@ -32748,26 +45887,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32748 | 45887 | .dst_temps = .{.mem}, |
| 32749 | 45888 | .clobbers = .{ .eflags = true }, |
| 32750 | 45889 | .each = .{ .once = &.{ |
| 32751 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32752 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32753 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32754 | | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 32755 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 32756 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 32757 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 32758 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45890 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45891 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45892 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45893 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 45894 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45895 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 45896 | .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 45897 | .{ ._, ._r, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 45898 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 45899 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 45900 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 45901 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45902 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 45903 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 45904 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32759 | 45905 | } }, |
| 32760 | 45906 | }, .{ |
| 32761 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 32762 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 45907 | .required_features = .{ .@"64bit", null, null, null }, |
| 45908 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45909 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32763 | 45910 | .patterns = &.{ |
| 32764 | | .{ .src = .{ .to_mem, .none } }, |
| 45911 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32765 | 45912 | }, |
| 32766 | 45913 | .extra_temps = .{ |
| 32767 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32768 | 45914 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32769 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32770 | | .unused, |
| 45915 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45916 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45917 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32771 | 45918 | .unused, |
| 32772 | 45919 | .unused, |
| 32773 | 45920 | .unused, |
| ... | ... | @@ -32777,199 +45924,304 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32777 | 45924 | .dst_temps = .{.mem}, |
| 32778 | 45925 | .clobbers = .{ .eflags = true }, |
| 32779 | 45926 | .each = .{ .once = &.{ |
| 32780 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32781 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32782 | | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 32783 | | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, |
| 32784 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 32785 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 32786 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 32787 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 45927 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45928 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45929 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45930 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 45931 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45932 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 45933 | .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 45934 | .{ ._, ._r, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 45935 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 45936 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 45937 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 45938 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45939 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 45940 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 45941 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32788 | 45942 | } }, |
| 32789 | 45943 | }, .{ |
| 32790 | | .required_features = .{ .avx, null, null, null }, |
| 32791 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 32792 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 45944 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 45945 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45946 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 32793 | 45947 | .patterns = &.{ |
| 32794 | | .{ .src = .{ .to_sse, .none } }, |
| 45948 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32795 | 45949 | }, |
| 32796 | 45950 | .extra_temps = .{ |
| 32797 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32798 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32799 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32800 | | .unused, |
| 32801 | | .unused, |
| 45951 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45952 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45953 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45954 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 45955 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32802 | 45956 | .unused, |
| 32803 | 45957 | .unused, |
| 32804 | 45958 | .unused, |
| 32805 | 45959 | .unused, |
| 32806 | 45960 | }, |
| 32807 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 45961 | .dst_temps = .{.mem}, |
| 45962 | .clobbers = .{ .eflags = true }, |
| 32808 | 45963 | .each = .{ .once = &.{ |
| 32809 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32810 | | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 32811 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 32812 | | .{ ._, .vp_q, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 32813 | | .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 45964 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45965 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 45966 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 45967 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 45968 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 45969 | .{ ._, ._, .mov, .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 45970 | .{ ._, ._l, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 45971 | .{ ._, ._r, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 45972 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 45973 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 45974 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 45975 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32814 | 45976 | } }, |
| 32815 | 45977 | }, .{ |
| 32816 | | .required_features = .{ .avx, null, null, null }, |
| 32817 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 32818 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 45978 | .required_features = .{ .@"64bit", null, null, null }, |
| 45979 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 45980 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 32819 | 45981 | .patterns = &.{ |
| 32820 | | .{ .src = .{ .to_sse, .none } }, |
| 45982 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32821 | 45983 | }, |
| 32822 | 45984 | .extra_temps = .{ |
| 32823 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32824 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 32825 | | .unused, |
| 32826 | | .unused, |
| 32827 | | .unused, |
| 45985 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 45986 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 45987 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 45988 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 45989 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32828 | 45990 | .unused, |
| 32829 | 45991 | .unused, |
| 32830 | 45992 | .unused, |
| 32831 | 45993 | .unused, |
| 32832 | 45994 | }, |
| 32833 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 45995 | .dst_temps = .{.mem}, |
| 45996 | .clobbers = .{ .eflags = true }, |
| 32834 | 45997 | .each = .{ .once = &.{ |
| 32835 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32836 | | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 45998 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 45999 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46000 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46001 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46002 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46003 | .{ ._, ._, .mov, .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 46004 | .{ ._, ._l, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 46005 | .{ ._, ._r, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 46006 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46007 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46008 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 46009 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32837 | 46010 | } }, |
| 32838 | 46011 | }, .{ |
| 32839 | | .required_features = .{ .sse2, null, null, null }, |
| 32840 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 32841 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 46012 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 46013 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46014 | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32842 | 46015 | .patterns = &.{ |
| 32843 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 46016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32844 | 46017 | }, |
| 32845 | 46018 | .extra_temps = .{ |
| 32846 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32847 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32848 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32849 | | .unused, |
| 32850 | | .unused, |
| 46019 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46020 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46021 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46022 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 46023 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32851 | 46024 | .unused, |
| 32852 | 46025 | .unused, |
| 32853 | 46026 | .unused, |
| 32854 | 46027 | .unused, |
| 32855 | 46028 | }, |
| 32856 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 46029 | .dst_temps = .{.mem}, |
| 46030 | .clobbers = .{ .eflags = true }, |
| 32857 | 46031 | .each = .{ .once = &.{ |
| 32858 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32859 | | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 32860 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 32861 | | .{ ._, .p_q, .add, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 32862 | | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 46032 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46033 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46034 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46035 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 46036 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46037 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46038 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46039 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46040 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 46041 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32863 | 46042 | } }, |
| 32864 | 46043 | }, .{ |
| 32865 | | .required_features = .{ .sse2, null, null, null }, |
| 32866 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 32867 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 46044 | .required_features = .{ .@"64bit", null, null, null }, |
| 46045 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46046 | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32868 | 46047 | .patterns = &.{ |
| 32869 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 46048 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32870 | 46049 | }, |
| 32871 | 46050 | .extra_temps = .{ |
| 32872 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32873 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 32874 | | .unused, |
| 32875 | | .unused, |
| 32876 | | .unused, |
| 46051 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46052 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46053 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46054 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 46055 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32877 | 46056 | .unused, |
| 32878 | 46057 | .unused, |
| 32879 | 46058 | .unused, |
| 32880 | 46059 | .unused, |
| 32881 | 46060 | }, |
| 32882 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 46061 | .dst_temps = .{.mem}, |
| 46062 | .clobbers = .{ .eflags = true }, |
| 32883 | 46063 | .each = .{ .once = &.{ |
| 32884 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32885 | | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 46064 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46065 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46066 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46067 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 46068 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46069 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46070 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46071 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46072 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 46073 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32886 | 46074 | } }, |
| 32887 | 46075 | }, .{ |
| 32888 | | .required_features = .{ .sse, null, null, null }, |
| 32889 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 32890 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 46076 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| 46077 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46078 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32891 | 46079 | .patterns = &.{ |
| 32892 | | .{ .src = .{ .to_mut_sse, .none } }, |
| 46080 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32893 | 46081 | }, |
| 32894 | 46082 | .extra_temps = .{ |
| 32895 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32896 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 32897 | | .unused, |
| 32898 | | .unused, |
| 32899 | | .unused, |
| 46083 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46084 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46085 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46086 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 46087 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32900 | 46088 | .unused, |
| 32901 | 46089 | .unused, |
| 32902 | 46090 | .unused, |
| 32903 | 46091 | .unused, |
| 32904 | 46092 | }, |
| 32905 | | .dst_temps = .{.{ .ref = .src0 }}, |
| 46093 | .dst_temps = .{.mem}, |
| 46094 | .clobbers = .{ .eflags = true }, |
| 32906 | 46095 | .each = .{ .once = &.{ |
| 32907 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32908 | | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 46096 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46097 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46098 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46099 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 46100 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46101 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46102 | .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ }, |
| 46103 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ }, |
| 46104 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 46105 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46106 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 46107 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 46108 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32909 | 46109 | } }, |
| 32910 | 46110 | }, .{ |
| 32911 | | .required_features = .{ .avx2, null, null, null }, |
| 32912 | | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any }, |
| 32913 | | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 46111 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 46112 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46113 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32914 | 46114 | .patterns = &.{ |
| 32915 | | .{ .src = .{ .to_sse, .none } }, |
| 46115 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32916 | 46116 | }, |
| 32917 | 46117 | .extra_temps = .{ |
| 32918 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32919 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32920 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32921 | | .unused, |
| 32922 | | .unused, |
| 46118 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46119 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46120 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46121 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 46122 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32923 | 46123 | .unused, |
| 32924 | 46124 | .unused, |
| 32925 | 46125 | .unused, |
| 32926 | 46126 | .unused, |
| 32927 | 46127 | }, |
| 32928 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 46128 | .dst_temps = .{.mem}, |
| 46129 | .clobbers = .{ .eflags = true }, |
| 32929 | 46130 | .each = .{ .once = &.{ |
| 32930 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32931 | | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 32932 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 32933 | | .{ ._, .vp_q, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 32934 | | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 46131 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46132 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46133 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46134 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 46135 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46136 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46137 | .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ }, |
| 46138 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ }, |
| 46139 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 46140 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46141 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 46142 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 46143 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32935 | 46144 | } }, |
| 32936 | 46145 | }, .{ |
| 32937 | | .required_features = .{ .avx2, null, null, null }, |
| 32938 | | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any }, |
| 32939 | | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, |
| 46146 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| 46147 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46148 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 32940 | 46149 | .patterns = &.{ |
| 32941 | | .{ .src = .{ .to_sse, .none } }, |
| 46150 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32942 | 46151 | }, |
| 32943 | 46152 | .extra_temps = .{ |
| 32944 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 32945 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 32946 | | .unused, |
| 46153 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46154 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46155 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46156 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 46157 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 46158 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32947 | 46159 | .unused, |
| 32948 | 46160 | .unused, |
| 32949 | 46161 | .unused, |
| 46162 | }, |
| 46163 | .dst_temps = .{.mem}, |
| 46164 | .clobbers = .{ .eflags = true }, |
| 46165 | .each = .{ .once = &.{ |
| 46166 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46167 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46168 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46169 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 46170 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46171 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46172 | .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ }, |
| 46173 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46174 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46175 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 46176 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 46177 | } }, |
| 46178 | }, .{ |
| 46179 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 46180 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46181 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 46182 | .patterns = &.{ |
| 46183 | .{ .src = .{ .to_mem, .none, .none } }, |
| 46184 | }, |
| 46185 | .extra_temps = .{ |
| 46186 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46187 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46188 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46189 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 46190 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 46191 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32950 | 46192 | .unused, |
| 32951 | 46193 | .unused, |
| 32952 | 46194 | .unused, |
| 32953 | 46195 | }, |
| 32954 | | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 46196 | .dst_temps = .{.mem}, |
| 46197 | .clobbers = .{ .eflags = true }, |
| 32955 | 46198 | .each = .{ .once = &.{ |
| 32956 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32957 | | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 46199 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46200 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46201 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46202 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 46203 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46204 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46205 | .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ }, |
| 46206 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46207 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46208 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 46209 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 32958 | 46210 | } }, |
| 32959 | 46211 | }, .{ |
| 32960 | | .required_features = .{ .avx2, null, null, null }, |
| 32961 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any }, |
| 32962 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 46212 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 46213 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46214 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32963 | 46215 | .patterns = &.{ |
| 32964 | | .{ .src = .{ .to_mem, .none } }, |
| 46216 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32965 | 46217 | }, |
| 32966 | 46218 | .extra_temps = .{ |
| 32967 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32968 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 32969 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 32970 | | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 32971 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32972 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 46219 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46220 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46221 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46222 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 46223 | .unused, |
| 46224 | .unused, |
| 32973 | 46225 | .unused, |
| 32974 | 46226 | .unused, |
| 32975 | 46227 | .unused, |
| ... | ... | @@ -32977,30 +46229,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32977 | 46229 | .dst_temps = .{.mem}, |
| 32978 | 46230 | .clobbers = .{ .eflags = true }, |
| 32979 | 46231 | .each = .{ .once = &.{ |
| 32980 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 32981 | | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 32982 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 32983 | | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 32984 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32985 | | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 32986 | | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 32987 | | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 32988 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 32989 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 32990 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46232 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46233 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46234 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46235 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46236 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46237 | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, |
| 46238 | .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 46239 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 46240 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 46241 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46242 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 46243 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 46244 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 32991 | 46245 | } }, |
| 32992 | 46246 | }, .{ |
| 32993 | | .required_features = .{ .avx2, null, null, null }, |
| 32994 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any }, |
| 32995 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, |
| 46247 | .required_features = .{ .@"64bit", null, null, null }, |
| 46248 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46249 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32996 | 46250 | .patterns = &.{ |
| 32997 | | .{ .src = .{ .to_mem, .none } }, |
| 46251 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32998 | 46252 | }, |
| 32999 | 46253 | .extra_temps = .{ |
| 33000 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33001 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 33002 | | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 33003 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 46254 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46255 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46256 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46257 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33004 | 46258 | .unused, |
| 33005 | 46259 | .unused, |
| 33006 | 46260 | .unused, |
| ... | ... | @@ -33010,28 +46264,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33010 | 46264 | .dst_temps = .{.mem}, |
| 33011 | 46265 | .clobbers = .{ .eflags = true }, |
| 33012 | 46266 | .each = .{ .once = &.{ |
| 33013 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 33014 | | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 33015 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33016 | | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 33017 | | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 33018 | | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 33019 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46267 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46268 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46269 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46270 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46271 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46272 | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, |
| 46273 | .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 46274 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 46275 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 46276 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46277 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 46278 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 46279 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 33020 | 46280 | } }, |
| 33021 | 46281 | }, .{ |
| 33022 | | .required_features = .{ .avx, null, null, null }, |
| 33023 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 33024 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 46282 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 46283 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46284 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 33025 | 46285 | .patterns = &.{ |
| 33026 | | .{ .src = .{ .to_mem, .none } }, |
| 46286 | .{ .src = .{ .to_mem, .none, .none } }, |
| 33027 | 46287 | }, |
| 33028 | 46288 | .extra_temps = .{ |
| 33029 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33030 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 33031 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 33032 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 33033 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 33034 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 46289 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46290 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46291 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46292 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 46293 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 46294 | .unused, |
| 33035 | 46295 | .unused, |
| 33036 | 46296 | .unused, |
| 33037 | 46297 | .unused, |
| ... | ... | @@ -33039,31 +46299,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33039 | 46299 | .dst_temps = .{.mem}, |
| 33040 | 46300 | .clobbers = .{ .eflags = true }, |
| 33041 | 46301 | .each = .{ .once = &.{ |
| 33042 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 33043 | | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 33044 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 33045 | | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 33046 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33047 | | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 33048 | | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 33049 | | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 33050 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 33051 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33052 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46302 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46303 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46304 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46305 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 46306 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46307 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46308 | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, |
| 46309 | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 46310 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46311 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46312 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 46313 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 33053 | 46314 | } }, |
| 33054 | 46315 | }, .{ |
| 33055 | | .required_features = .{ .avx, null, null, null }, |
| 33056 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 33057 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 46316 | .required_features = .{ .@"64bit", null, null, null }, |
| 46317 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 46318 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 33058 | 46319 | .patterns = &.{ |
| 33059 | | .{ .src = .{ .to_mem, .none } }, |
| 46320 | .{ .src = .{ .to_mem, .none, .none } }, |
| 33060 | 46321 | }, |
| 33061 | 46322 | .extra_temps = .{ |
| 33062 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33063 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 33064 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 33065 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 33066 | | .unused, |
| 46323 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 46324 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 46325 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 46326 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 46327 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33067 | 46328 | .unused, |
| 33068 | 46329 | .unused, |
| 33069 | 46330 | .unused, |
| ... | ... | @@ -33072,118 +46333,456 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33072 | 46333 | .dst_temps = .{.mem}, |
| 33073 | 46334 | .clobbers = .{ .eflags = true }, |
| 33074 | 46335 | .each = .{ .once = &.{ |
| 33075 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 33076 | | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 33077 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33078 | | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 33079 | | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 33080 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33081 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46336 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 46337 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 46338 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 46339 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 46340 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 46341 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 46342 | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, |
| 46343 | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 46344 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 46345 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 46346 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 46347 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 46348 | } }, |
| 46349 | } }) catch |err| switch (err) { |
| 46350 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 46351 | @tagName(air_tag), |
| 46352 | ty_op.ty.toType().fmt(pt), |
| 46353 | cg.typeOf(ty_op.operand).fmt(pt), |
| 46354 | ops[0].tracking(cg), |
| 46355 | }), |
| 46356 | else => |e| return e, |
| 46357 | }; |
| 46358 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46359 | }, |
| 46360 | .optional_payload_ptr => if (use_old) try cg.airOptionalPayloadPtr(inst) else { |
| 46361 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46362 | const ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46363 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46364 | }, |
| 46365 | .optional_payload_ptr_set => if (use_old) try cg.airOptionalPayloadPtrSet(inst) else { |
| 46366 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46367 | const opt_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 46368 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46369 | if (!opt_ty.optionalReprIsPayload(zcu)) { |
| 46370 | const opt_child_ty = opt_ty.optionalChild(zcu); |
| 46371 | const opt_child_abi_size: i32 = @intCast(opt_child_ty.abiSize(zcu)); |
| 46372 | try ops[0].toOffset(opt_child_abi_size, cg); |
| 46373 | var has_value = try cg.tempInit(.bool, .{ .immediate = 1 }); |
| 46374 | try ops[0].store(&has_value, .{}, cg); |
| 46375 | try has_value.die(cg); |
| 46376 | try ops[0].toOffset(-opt_child_abi_size, cg); |
| 46377 | } |
| 46378 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46379 | }, |
| 46380 | .unwrap_errunion_payload_ptr => if (use_old) try cg.airUnwrapErrUnionPayloadPtr(inst) else { |
| 46381 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46382 | const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 46383 | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 46384 | const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); |
| 46385 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46386 | try ops[0].toOffset(eu_pl_off, cg); |
| 46387 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46388 | }, |
| 46389 | .unwrap_errunion_err_ptr => if (use_old) try cg.airUnwrapErrUnionErrPtr(inst) else { |
| 46390 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46391 | const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 46392 | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 46393 | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 46394 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46395 | try ops[0].toOffset(eu_err_off, cg); |
| 46396 | const err = try ops[0].load(eu_ty.errorUnionSet(zcu), .{}, cg); |
| 46397 | try err.finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46398 | }, |
| 46399 | .errunion_payload_ptr_set => if (use_old) try cg.airErrUnionPayloadPtrSet(inst) else { |
| 46400 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46401 | const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 46402 | const eu_err_ty = eu_ty.errorUnionSet(zcu); |
| 46403 | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 46404 | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 46405 | const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); |
| 46406 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46407 | try ops[0].toOffset(eu_err_off, cg); |
| 46408 | var no_err = try cg.tempInit(eu_err_ty, .{ .immediate = 0 }); |
| 46409 | try ops[0].store(&no_err, .{}, cg); |
| 46410 | try no_err.die(cg); |
| 46411 | try ops[0].toOffset(eu_pl_off - eu_err_off, cg); |
| 46412 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46413 | }, |
| 46414 | .struct_field_ptr => if (use_old) try cg.airStructFieldPtr(inst) else { |
| 46415 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 46416 | const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; |
| 46417 | var ops = try cg.tempsFromOperands(inst, .{extra.struct_operand}); |
| 46418 | try ops[0].toOffset(cg.fieldOffset( |
| 46419 | cg.typeOf(extra.struct_operand), |
| 46420 | ty_pl.ty.toType(), |
| 46421 | extra.field_index, |
| 46422 | ), cg); |
| 46423 | try ops[0].finish(inst, &.{extra.struct_operand}, &ops, cg); |
| 46424 | }, |
| 46425 | .struct_field_ptr_index_0, |
| 46426 | .struct_field_ptr_index_1, |
| 46427 | .struct_field_ptr_index_2, |
| 46428 | .struct_field_ptr_index_3, |
| 46429 | => |air_tag| if (use_old) try cg.airStructFieldPtrIndex(inst, switch (air_tag) { |
| 46430 | else => unreachable, |
| 46431 | .struct_field_ptr_index_0 => 0, |
| 46432 | .struct_field_ptr_index_1 => 1, |
| 46433 | .struct_field_ptr_index_2 => 2, |
| 46434 | .struct_field_ptr_index_3 => 3, |
| 46435 | }) else { |
| 46436 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46437 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46438 | try ops[0].toOffset(cg.fieldOffset( |
| 46439 | cg.typeOf(ty_op.operand), |
| 46440 | ty_op.ty.toType(), |
| 46441 | switch (air_tag) { |
| 46442 | else => unreachable, |
| 46443 | .struct_field_ptr_index_0 => 0, |
| 46444 | .struct_field_ptr_index_1 => 1, |
| 46445 | .struct_field_ptr_index_2 => 2, |
| 46446 | .struct_field_ptr_index_3 => 3, |
| 46447 | }, |
| 46448 | ), cg); |
| 46449 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46450 | }, |
| 46451 | .struct_field_val => if (use_old) try cg.airStructFieldVal(inst) else fallback: { |
| 46452 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 46453 | const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; |
| 46454 | const agg_ty = cg.typeOf(extra.struct_operand); |
| 46455 | const field_ty = ty_pl.ty.toType(); |
| 46456 | const field_off: u31 = switch (agg_ty.containerLayout(zcu)) { |
| 46457 | .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(extra.field_index, zcu)), |
| 46458 | .@"packed" => break :fallback try cg.airStructFieldVal(inst), |
| 46459 | }; |
| 46460 | var ops = try cg.tempsFromOperands(inst, .{extra.struct_operand}); |
| 46461 | // hack around Sema OPV bugs |
| 46462 | var res = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu)) |
| 46463 | try ops[0].read(field_ty, .{ .disp = field_off }, cg) |
| 46464 | else |
| 46465 | try cg.tempInit(field_ty, .none); |
| 46466 | try res.finish(inst, &.{extra.struct_operand}, &ops, cg); |
| 46467 | }, |
| 46468 | .set_union_tag => if (use_old) try cg.airSetUnionTag(inst) else { |
| 46469 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 46470 | const union_ty = cg.typeOf(bin_op.lhs).childType(zcu); |
| 46471 | const union_layout = union_ty.unionGetLayout(zcu); |
| 46472 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 46473 | // hack around Sema OPV bugs |
| 46474 | if (union_layout.tag_size > 0) try ops[0].store(&ops[1], .{ |
| 46475 | .disp = @intCast(union_layout.tagOffset()), |
| 46476 | }, cg); |
| 46477 | const res = try cg.tempInit(.void, .none); |
| 46478 | try res.finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 46479 | }, |
| 46480 | .get_union_tag => if (use_old) try cg.airGetUnionTag(inst) else { |
| 46481 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46482 | const union_ty = cg.typeOf(ty_op.operand); |
| 46483 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46484 | const union_layout = union_ty.unionGetLayout(zcu); |
| 46485 | assert(union_layout.tag_size > 0); |
| 46486 | const res = try ops[0].read(ty_op.ty.toType(), .{ |
| 46487 | .disp = @intCast(union_layout.tagOffset()), |
| 46488 | }, cg); |
| 46489 | try res.finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46490 | }, |
| 46491 | .slice => if (use_old) try cg.airSlice(inst) else { |
| 46492 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 46493 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 46494 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 46495 | try ops[0].toPair(&ops[1], cg); |
| 46496 | try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 46497 | }, |
| 46498 | .slice_len => if (use_old) try cg.airSliceLen(inst) else { |
| 46499 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46500 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46501 | try ops[0].toSliceLen(cg); |
| 46502 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46503 | }, |
| 46504 | .slice_ptr => if (use_old) try cg.airSlicePtr(inst) else { |
| 46505 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46506 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46507 | try ops[0].toSlicePtr(cg); |
| 46508 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46509 | }, |
| 46510 | .ptr_slice_len_ptr => if (use_old) try cg.airPtrSliceLenPtr(inst) else { |
| 46511 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46512 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46513 | try ops[0].toOffset(8, cg); |
| 46514 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46515 | }, |
| 46516 | .ptr_slice_ptr_ptr => if (use_old) try cg.airPtrSlicePtrPtr(inst) else { |
| 46517 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46518 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46519 | try ops[0].toOffset(0, cg); |
| 46520 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46521 | }, |
| 46522 | .slice_elem_val, .ptr_elem_val => |air_tag| if (use_old) switch (air_tag) { |
| 46523 | else => unreachable, |
| 46524 | .slice_elem_val => try cg.airSliceElemVal(inst), |
| 46525 | .ptr_elem_val => try cg.airPtrElemVal(inst), |
| 46526 | } else { |
| 46527 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 46528 | const res_ty = cg.typeOf(bin_op.lhs).elemType2(zcu); |
| 46529 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 46530 | try ops[0].toSlicePtr(cg); |
| 46531 | var res: [1]Temp = undefined; |
| 46532 | if (res_ty.hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{ |
| 46533 | .dst_constraints = .{.{ .int = .byte }}, |
| 46534 | .patterns = &.{ |
| 46535 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 46536 | }, |
| 46537 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46538 | .each = .{ .once = &.{ |
| 46539 | .{ ._, ._, .movzx, .dst0d, .leaa(.src0b, .add_src0_elem_size_times_src1), ._, ._ }, |
| 33082 | 46540 | } }, |
| 33083 | 46541 | }, .{ |
| 33084 | | .required_features = .{ .sse2, null, null, null }, |
| 33085 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 33086 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 46542 | .dst_constraints = .{.{ .int = .byte }}, |
| 33087 | 46543 | .patterns = &.{ |
| 33088 | | .{ .src = .{ .to_mem, .none } }, |
| 46544 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 33089 | 46545 | }, |
| 33090 | | .extra_temps = .{ |
| 33091 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33092 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 33093 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 33094 | | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 33095 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 33096 | | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 33097 | | .unused, |
| 33098 | | .unused, |
| 33099 | | .unused, |
| 46546 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46547 | .each = .{ .once = &.{ |
| 46548 | .{ ._, ._, .movzx, .dst0d, .leai(.src0b, .src1), ._, ._ }, |
| 46549 | } }, |
| 46550 | }, .{ |
| 46551 | .dst_constraints = .{.{ .int = .word }}, |
| 46552 | .patterns = &.{ |
| 46553 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 33100 | 46554 | }, |
| 33101 | | .dst_temps = .{.mem}, |
| 33102 | | .clobbers = .{ .eflags = true }, |
| 46555 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 33103 | 46556 | .each = .{ .once = &.{ |
| 33104 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 33105 | | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 33106 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 33107 | | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 33108 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33109 | | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ }, |
| 33110 | | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33111 | | .{ ._, .p_q, .add, .tmp3x, .tmp2x, ._, ._ }, |
| 33112 | | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| 33113 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 33114 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33115 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46557 | .{ ._, ._, .movzx, .dst0d, .leaa(.src0w, .add_src0_elem_size_times_src1), ._, ._ }, |
| 33116 | 46558 | } }, |
| 33117 | 46559 | }, .{ |
| 33118 | | .required_features = .{ .sse2, null, null, null }, |
| 33119 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 33120 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 46560 | .dst_constraints = .{.{ .int = .word }}, |
| 33121 | 46561 | .patterns = &.{ |
| 33122 | | .{ .src = .{ .to_mem, .none } }, |
| 46562 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 33123 | 46563 | }, |
| 33124 | | .extra_temps = .{ |
| 33125 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33126 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 33127 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 33128 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 33129 | | .unused, |
| 33130 | | .unused, |
| 33131 | | .unused, |
| 33132 | | .unused, |
| 33133 | | .unused, |
| 46564 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46565 | .each = .{ .once = &.{ |
| 46566 | .{ ._, ._, .movzx, .dst0d, .leasi(.src0w, .@"2", .src1), ._, ._ }, |
| 46567 | } }, |
| 46568 | }, .{ |
| 46569 | .dst_constraints = .{.{ .int = .dword }}, |
| 46570 | .patterns = &.{ |
| 46571 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 46572 | }, |
| 46573 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46574 | .each = .{ .once = &.{ |
| 46575 | .{ ._, ._, .mov, .dst0d, .leaa(.src0d, .add_src0_elem_size_times_src1), ._, ._ }, |
| 46576 | } }, |
| 46577 | }, .{ |
| 46578 | .dst_constraints = .{.{ .int = .dword }}, |
| 46579 | .patterns = &.{ |
| 46580 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 46581 | }, |
| 46582 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46583 | .each = .{ .once = &.{ |
| 46584 | .{ ._, ._, .mov, .dst0d, .leasi(.src0d, .@"4", .src1), ._, ._ }, |
| 46585 | } }, |
| 46586 | }, .{ |
| 46587 | .dst_constraints = .{.{ .int = .qword }}, |
| 46588 | .patterns = &.{ |
| 46589 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 46590 | }, |
| 46591 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46592 | .each = .{ .once = &.{ |
| 46593 | .{ ._, ._, .mov, .dst0q, .leaa(.src0q, .add_src0_elem_size_times_src1), ._, ._ }, |
| 46594 | } }, |
| 46595 | }, .{ |
| 46596 | .required_features = .{ .@"64bit", null, null, null }, |
| 46597 | .dst_constraints = .{.{ .int = .qword }}, |
| 46598 | .patterns = &.{ |
| 46599 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 46600 | }, |
| 46601 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 46602 | .each = .{ .once = &.{ |
| 46603 | .{ ._, ._, .mov, .dst0q, .leasi(.src0q, .@"8", .src1), ._, ._ }, |
| 46604 | } }, |
| 46605 | } }) catch |err| switch (err) { |
| 46606 | error.SelectFailed => { |
| 46607 | const elem_size = res_ty.abiSize(zcu); |
| 46608 | while (true) for (&ops) |*op| { |
| 46609 | if (try op.toRegClass(true, .general_purpose, cg)) break; |
| 46610 | } else break; |
| 46611 | const lhs_reg = ops[0].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 46612 | const rhs_reg = ops[1].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 46613 | if (!std.math.isPowerOfTwo(elem_size)) { |
| 46614 | try cg.spillEflagsIfOccupied(); |
| 46615 | try cg.asmRegisterRegisterImmediate( |
| 46616 | .{ .i_, .mul }, |
| 46617 | rhs_reg, |
| 46618 | rhs_reg, |
| 46619 | .u(elem_size), |
| 46620 | ); |
| 46621 | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 46622 | .base = .{ .reg = lhs_reg }, |
| 46623 | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 46624 | }); |
| 46625 | } else if (elem_size > 8) { |
| 46626 | try cg.spillEflagsIfOccupied(); |
| 46627 | try cg.asmRegisterImmediate( |
| 46628 | .{ ._l, .sh }, |
| 46629 | rhs_reg, |
| 46630 | .u(std.math.log2_int(u64, elem_size)), |
| 46631 | ); |
| 46632 | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 46633 | .base = .{ .reg = lhs_reg }, |
| 46634 | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 46635 | }); |
| 46636 | } else try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 46637 | .base = .{ .reg = lhs_reg }, |
| 46638 | .mod = .{ .rm = .{ |
| 46639 | .size = .qword, |
| 46640 | .index = rhs_reg, |
| 46641 | .scale = .fromFactor(@intCast(elem_size)), |
| 46642 | } }, |
| 46643 | }); |
| 46644 | res[0] = try ops[0].load(res_ty, .{}, cg); |
| 46645 | }, |
| 46646 | else => |e| return e, |
| 46647 | } else { |
| 46648 | // hack around Sema OPV bugs |
| 46649 | res[0] = try cg.tempInit(res_ty, .none); |
| 46650 | } |
| 46651 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 46652 | }, |
| 46653 | .slice_elem_ptr, .ptr_elem_ptr => |air_tag| if (use_old) switch (air_tag) { |
| 46654 | else => unreachable, |
| 46655 | .slice_elem_ptr => try cg.airSliceElemPtr(inst), |
| 46656 | .ptr_elem_ptr => try cg.airPtrElemPtr(inst), |
| 46657 | } else { |
| 46658 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 46659 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 46660 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 46661 | try ops[0].toSlicePtr(cg); |
| 46662 | const dst_ty = ty_pl.ty.toType(); |
| 46663 | if (dst_ty.ptrInfo(zcu).flags.vector_index == .none) zero_offset: { |
| 46664 | const elem_size = dst_ty.childType(zcu).abiSize(zcu); |
| 46665 | // hack around Sema OPV bugs |
| 46666 | if (elem_size == 0) break :zero_offset; |
| 46667 | while (true) for (&ops) |*op| { |
| 46668 | if (try op.toRegClass(true, .general_purpose, cg)) break; |
| 46669 | } else break; |
| 46670 | const lhs_reg = ops[0].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 46671 | const rhs_reg = ops[1].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 46672 | if (!std.math.isPowerOfTwo(elem_size)) { |
| 46673 | try cg.spillEflagsIfOccupied(); |
| 46674 | try cg.asmRegisterRegisterImmediate( |
| 46675 | .{ .i_, .mul }, |
| 46676 | rhs_reg, |
| 46677 | rhs_reg, |
| 46678 | .u(elem_size), |
| 46679 | ); |
| 46680 | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 46681 | .base = .{ .reg = lhs_reg }, |
| 46682 | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 46683 | }); |
| 46684 | } else if (elem_size > 8) { |
| 46685 | try cg.spillEflagsIfOccupied(); |
| 46686 | try cg.asmRegisterImmediate( |
| 46687 | .{ ._l, .sh }, |
| 46688 | rhs_reg, |
| 46689 | .u(std.math.log2_int(u64, elem_size)), |
| 46690 | ); |
| 46691 | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 46692 | .base = .{ .reg = lhs_reg }, |
| 46693 | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 46694 | }); |
| 46695 | } else try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 46696 | .base = .{ .reg = lhs_reg }, |
| 46697 | .mod = .{ .rm = .{ |
| 46698 | .size = .qword, |
| 46699 | .index = rhs_reg, |
| 46700 | .scale = .fromFactor(@intCast(elem_size)), |
| 46701 | } }, |
| 46702 | }); |
| 46703 | } |
| 46704 | try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 46705 | }, |
| 46706 | .array_to_slice => if (use_old) try cg.airArrayToSlice(inst) else { |
| 46707 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 46708 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 46709 | var len = try cg.tempInit(.usize, .{ |
| 46710 | .immediate = cg.typeOf(ty_op.operand).childType(zcu).arrayLen(zcu), |
| 46711 | }); |
| 46712 | try ops[0].toPair(&len, cg); |
| 46713 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 46714 | }, |
| 46715 | .error_set_has_value => return cg.fail("TODO implement error_set_has_value", .{}), |
| 46716 | .union_init => if (use_old) try cg.airUnionInit(inst) else { |
| 46717 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 46718 | const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; |
| 46719 | const union_ty = ty_pl.ty.toType(); |
| 46720 | var ops = try cg.tempsFromOperands(inst, .{extra.init}); |
| 46721 | var res = try cg.tempAllocMem(union_ty); |
| 46722 | const union_layout = union_ty.unionGetLayout(zcu); |
| 46723 | if (union_layout.tag_size > 0) { |
| 46724 | var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex( |
| 46725 | union_ty.unionTagTypeSafety(zcu).?, |
| 46726 | extra.field_index, |
| 46727 | )); |
| 46728 | try res.write(&tag_temp, .{ |
| 46729 | .disp = @intCast(union_layout.tagOffset()), |
| 46730 | }, cg); |
| 46731 | try tag_temp.die(cg); |
| 46732 | } |
| 46733 | try res.write(&ops[0], .{ |
| 46734 | .disp = @intCast(union_layout.payloadOffset()), |
| 46735 | }, cg); |
| 46736 | try res.finish(inst, &.{extra.init}, &ops, cg); |
| 46737 | }, |
| 46738 | .mul_add => |air_tag| if (use_old) try cg.airMulAdd(inst) else { |
| 46739 | const pl_op = air_datas[@intFromEnum(inst)].pl_op; |
| 46740 | const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data; |
| 46741 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand }); |
| 46742 | var res: [1]Temp = undefined; |
| 46743 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 46744 | .required_features = .{ .fma, .f16c, null, null }, |
| 46745 | .src_constraints = .{ |
| 46746 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 46747 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 46748 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 33134 | 46749 | }, |
| 33135 | | .dst_temps = .{.mem}, |
| 33136 | | .clobbers = .{ .eflags = true }, |
| 33137 | | .each = .{ .once = &.{ |
| 33138 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 33139 | | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 33140 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33141 | | .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 33142 | | .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33143 | | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 33144 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33145 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33146 | | } }, |
| 33147 | | }, .{ |
| 33148 | | .required_features = .{ .sse, null, null, null }, |
| 33149 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, |
| 33150 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 33151 | 46750 | .patterns = &.{ |
| 33152 | | .{ .src = .{ .to_mem, .none } }, |
| 46751 | .{ .src = .{ .to_sse, .to_sse, .to_sse } }, |
| 33153 | 46752 | }, |
| 33154 | 46753 | .extra_temps = .{ |
| 33155 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33156 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 33157 | | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 33158 | | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 46754 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 46755 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 46756 | .unused, |
| 46757 | .unused, |
| 33159 | 46758 | .unused, |
| 33160 | 46759 | .unused, |
| 33161 | 46760 | .unused, |
| 33162 | 46761 | .unused, |
| 33163 | 46762 | .unused, |
| 33164 | 46763 | }, |
| 33165 | | .dst_temps = .{.mem}, |
| 33166 | | .clobbers = .{ .eflags = true }, |
| 46764 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 33167 | 46765 | .each = .{ .once = &.{ |
| 33168 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 33169 | | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 33170 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33171 | | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 33172 | | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33173 | | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 33174 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33175 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46766 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 46767 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 46768 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ }, |
| 46769 | .{ ._, .v_ss, .fmadd213, .dst0x, .tmp0x, .tmp1d, ._ }, |
| 46770 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 33176 | 46771 | } }, |
| 33177 | 46772 | }, .{ |
| 33178 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33179 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 33180 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 46773 | .required_features = .{ .sse, null, null, null }, |
| 46774 | .src_constraints = .{ |
| 46775 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 46776 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 46777 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 46778 | }, |
| 33181 | 46779 | .patterns = &.{ |
| 33182 | | .{ .src = .{ .to_mem, .none } }, |
| 46780 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, |
| 33183 | 46781 | }, |
| 46782 | .call_frame = .{ .alignment = .@"16" }, |
| 33184 | 46783 | .extra_temps = .{ |
| 33185 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33186 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 46784 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 46785 | .unused, |
| 33187 | 46786 | .unused, |
| 33188 | 46787 | .unused, |
| 33189 | 46788 | .unused, |
| ... | ... | @@ -33192,25 +46791,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33192 | 46791 | .unused, |
| 33193 | 46792 | .unused, |
| 33194 | 46793 | }, |
| 33195 | | .dst_temps = .{.mem}, |
| 33196 | | .clobbers = .{ .eflags = true }, |
| 46794 | .dst_temps = .{.{ .ref = .src0 }}, |
| 46795 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33197 | 46796 | .each = .{ .once = &.{ |
| 33198 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33199 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33200 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33201 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33202 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46797 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 33203 | 46798 | } }, |
| 33204 | 46799 | }, .{ |
| 33205 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33206 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 33207 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 46800 | .required_features = .{ .fma, .f16c, null, null }, |
| 46801 | .src_constraints = .{ |
| 46802 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 46803 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 46804 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 46805 | }, |
| 33208 | 46806 | .patterns = &.{ |
| 33209 | | .{ .src = .{ .to_mem, .none } }, |
| 46807 | .{ .src = .{ .mem, .mem, .mem } }, |
| 46808 | .{ .src = .{ .to_sse, .mem, .mem } }, |
| 46809 | .{ .src = .{ .mem, .to_sse, .mem } }, |
| 46810 | .{ .src = .{ .mem, .mem, .to_sse } }, |
| 46811 | .{ .src = .{ .to_sse, .to_sse, .mem } }, |
| 46812 | .{ .src = .{ .to_sse, .mem, .to_sse } }, |
| 46813 | .{ .src = .{ .mem, .to_sse, .to_sse } }, |
| 46814 | .{ .src = .{ .to_sse, .to_sse, .to_sse } }, |
| 33210 | 46815 | }, |
| 33211 | 46816 | .extra_temps = .{ |
| 33212 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33213 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 46817 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 46818 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33214 | 46819 | .unused, |
| 33215 | 46820 | .unused, |
| 33216 | 46821 | .unused, |
| ... | ... | @@ -33219,28 +46824,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33219 | 46824 | .unused, |
| 33220 | 46825 | .unused, |
| 33221 | 46826 | }, |
| 33222 | | .dst_temps = .{.mem}, |
| 33223 | | .clobbers = .{ .eflags = true }, |
| 46827 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 33224 | 46828 | .each = .{ .once = &.{ |
| 33225 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33226 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33227 | | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33228 | | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33229 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33230 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33231 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46829 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 46830 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 46831 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ }, |
| 46832 | .{ ._, .v_ps, .fmadd213, .dst0x, .tmp0x, .tmp1x, ._ }, |
| 46833 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 33232 | 46834 | } }, |
| 33233 | 46835 | }, .{ |
| 33234 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 33235 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 33236 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 46836 | .required_features = .{ .fma, .f16c, null, null }, |
| 46837 | .src_constraints = .{ |
| 46838 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 46839 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 46840 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 46841 | }, |
| 33237 | 46842 | .patterns = &.{ |
| 33238 | | .{ .src = .{ .to_mem, .none } }, |
| 46843 | .{ .src = .{ .mem, .mem, .mem } }, |
| 46844 | .{ .src = .{ .to_sse, .mem, .mem } }, |
| 46845 | .{ .src = .{ .mem, .to_sse, .mem } }, |
| 46846 | .{ .src = .{ .mem, .mem, .to_sse } }, |
| 46847 | .{ .src = .{ .to_sse, .to_sse, .mem } }, |
| 46848 | .{ .src = .{ .to_sse, .mem, .to_sse } }, |
| 46849 | .{ .src = .{ .mem, .to_sse, .to_sse } }, |
| 46850 | .{ .src = .{ .to_sse, .to_sse, .to_sse } }, |
| 33239 | 46851 | }, |
| 33240 | 46852 | .extra_temps = .{ |
| 33241 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33242 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 33243 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 46853 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 46854 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 46855 | .unused, |
| 33244 | 46856 | .unused, |
| 33245 | 46857 | .unused, |
| 33246 | 46858 | .unused, |
| ... | ... | @@ -33248,28 +46860,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33248 | 46860 | .unused, |
| 33249 | 46861 | .unused, |
| 33250 | 46862 | }, |
| 33251 | | .dst_temps = .{.mem}, |
| 33252 | | .clobbers = .{ .eflags = true }, |
| 46863 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 33253 | 46864 | .each = .{ .once = &.{ |
| 33254 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33255 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 33256 | | .{ .@"0:", ._, .bzhi, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 33257 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 33258 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33259 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 46865 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 46866 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 46867 | .{ ._, .v_ps, .cvtph2, .tmp1y, .src2x, ._, ._ }, |
| 46868 | .{ ._, .v_ps, .fmadd213, .dst0y, .tmp0y, .tmp1y, ._ }, |
| 46869 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 33260 | 46870 | } }, |
| 33261 | 46871 | }, .{ |
| 33262 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33263 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, |
| 33264 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 46872 | .required_features = .{ .fma, .f16c, null, null }, |
| 46873 | .src_constraints = .{ |
| 46874 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 46875 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 46876 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 46877 | }, |
| 33265 | 46878 | .patterns = &.{ |
| 33266 | | .{ .src = .{ .to_mem, .none } }, |
| 46879 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33267 | 46880 | }, |
| 33268 | 46881 | .extra_temps = .{ |
| 33269 | 46882 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33270 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33271 | | .unused, |
| 33272 | | .unused, |
| 46883 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 46884 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 46885 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33273 | 46886 | .unused, |
| 33274 | 46887 | .unused, |
| 33275 | 46888 | .unused, |
| ... | ... | @@ -33277,221 +46890,232 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33277 | 46890 | .unused, |
| 33278 | 46891 | }, |
| 33279 | 46892 | .dst_temps = .{.mem}, |
| 33280 | | .clobbers = .{ .eflags = true }, |
| 33281 | 46893 | .each = .{ .once = &.{ |
| 33282 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33283 | | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 33284 | | .{ ._, ._, .@"and", .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33285 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33286 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 46894 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 46895 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 46896 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 46897 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 46898 | .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ }, |
| 46899 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 46900 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33287 | 46901 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33288 | 46902 | } }, |
| 33289 | 46903 | }, .{ |
| 33290 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33291 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 33292 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 46904 | .required_features = .{ .avx, null, null, null }, |
| 46905 | .src_constraints = .{ |
| 46906 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46907 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46908 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46909 | }, |
| 33293 | 46910 | .patterns = &.{ |
| 33294 | | .{ .src = .{ .to_mem, .none } }, |
| 46911 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33295 | 46912 | }, |
| 46913 | .call_frame = .{ .alignment = .@"16" }, |
| 33296 | 46914 | .extra_temps = .{ |
| 33297 | 46915 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33298 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33299 | | .unused, |
| 33300 | | .unused, |
| 33301 | | .unused, |
| 46916 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 46917 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 46918 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 46919 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33302 | 46920 | .unused, |
| 33303 | 46921 | .unused, |
| 33304 | 46922 | .unused, |
| 33305 | 46923 | .unused, |
| 33306 | 46924 | }, |
| 33307 | 46925 | .dst_temps = .{.mem}, |
| 33308 | | .clobbers = .{ .eflags = true }, |
| 46926 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33309 | 46927 | .each = .{ .once = &.{ |
| 33310 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33311 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 33312 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33313 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 46928 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 46929 | .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| 46930 | .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 46931 | .{ ._, .vp_w, .insr, .tmp2x, .tmp3x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 46932 | .{ ._, .vp_w, .insr, .tmp3x, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 46933 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 46934 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 46935 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 33314 | 46936 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33315 | 46937 | } }, |
| 33316 | 46938 | }, .{ |
| 33317 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33318 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 33319 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 46939 | .required_features = .{ .sse4_1, null, null, null }, |
| 46940 | .src_constraints = .{ |
| 46941 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46942 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46943 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46944 | }, |
| 33320 | 46945 | .patterns = &.{ |
| 33321 | | .{ .src = .{ .to_mem, .none } }, |
| 46946 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33322 | 46947 | }, |
| 46948 | .call_frame = .{ .alignment = .@"16" }, |
| 33323 | 46949 | .extra_temps = .{ |
| 33324 | 46950 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33325 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 33326 | | .unused, |
| 33327 | | .unused, |
| 33328 | | .unused, |
| 46951 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 46952 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 46953 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 46954 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33329 | 46955 | .unused, |
| 33330 | 46956 | .unused, |
| 33331 | 46957 | .unused, |
| 33332 | 46958 | .unused, |
| 33333 | 46959 | }, |
| 33334 | 46960 | .dst_temps = .{.mem}, |
| 33335 | | .clobbers = .{ .eflags = true }, |
| 46961 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33336 | 46962 | .each = .{ .once = &.{ |
| 33337 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33338 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 33339 | | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33340 | | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33341 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33342 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 46963 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 46964 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 46965 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 46966 | .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 46967 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 46968 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 46969 | .{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 46970 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 46971 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 46972 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 33343 | 46973 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33344 | 46974 | } }, |
| 33345 | 46975 | }, .{ |
| 33346 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 33347 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 33348 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 46976 | .required_features = .{ .sse2, null, null, null }, |
| 46977 | .src_constraints = .{ |
| 46978 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46979 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46980 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 46981 | }, |
| 33349 | 46982 | .patterns = &.{ |
| 33350 | | .{ .src = .{ .to_mem, .none } }, |
| 46983 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33351 | 46984 | }, |
| 46985 | .call_frame = .{ .alignment = .@"16" }, |
| 33352 | 46986 | .extra_temps = .{ |
| 33353 | 46987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33354 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 33355 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33356 | | .unused, |
| 33357 | | .unused, |
| 33358 | | .unused, |
| 46988 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 46989 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 46990 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 46991 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 46992 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 33359 | 46993 | .unused, |
| 33360 | 46994 | .unused, |
| 33361 | 46995 | .unused, |
| 33362 | 46996 | }, |
| 33363 | 46997 | .dst_temps = .{.mem}, |
| 33364 | | .clobbers = .{ .eflags = true }, |
| 46998 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33365 | 46999 | .each = .{ .once = &.{ |
| 33366 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33367 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 33368 | | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 33369 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 33370 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 47000 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47001 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 47002 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 47003 | .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 47004 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 47005 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 47006 | .{ ._, .p_w, .insr, .tmp3x, .memia(.src2w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 47007 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47008 | .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ }, |
| 47009 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ }, |
| 47010 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 33371 | 47011 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33372 | 47012 | } }, |
| 33373 | 47013 | }, .{ |
| 33374 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33375 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, |
| 33376 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 47014 | .required_features = .{ .sse, null, null, null }, |
| 47015 | .src_constraints = .{ |
| 47016 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 47017 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 47018 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 47019 | }, |
| 33377 | 47020 | .patterns = &.{ |
| 33378 | | .{ .src = .{ .to_mem, .none } }, |
| 47021 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33379 | 47022 | }, |
| 47023 | .call_frame = .{ .alignment = .@"16" }, |
| 33380 | 47024 | .extra_temps = .{ |
| 33381 | 47025 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33382 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33383 | | .unused, |
| 33384 | | .unused, |
| 33385 | | .unused, |
| 33386 | | .unused, |
| 33387 | | .unused, |
| 47026 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 47027 | .{ .type = .f32, .kind = .mem }, |
| 47028 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 47029 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 47030 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 47031 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33388 | 47032 | .unused, |
| 33389 | 47033 | .unused, |
| 33390 | 47034 | }, |
| 33391 | 47035 | .dst_temps = .{.mem}, |
| 33392 | | .clobbers = .{ .eflags = true }, |
| 47036 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33393 | 47037 | .each = .{ .once = &.{ |
| 33394 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33395 | | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 33396 | | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 33397 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33398 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 47038 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47039 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47040 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 47041 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 47042 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47043 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 47044 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 47045 | .{ ._, ._, .movzx, .tmp1d, .memia(.src2w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47046 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 47047 | .{ ._, ._ss, .mov, .tmp5x, .mem(.tmp2d), ._, ._ }, |
| 47048 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 47049 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 47050 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 47051 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 47052 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 33399 | 47053 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33400 | 47054 | } }, |
| 33401 | 47055 | }, .{ |
| 33402 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33403 | | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 33404 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 33405 | | .patterns = &.{ |
| 33406 | | .{ .src = .{ .to_mem, .none } }, |
| 47056 | .required_features = .{ .fma, null, null, null }, |
| 47057 | .src_constraints = .{ |
| 47058 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47059 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47060 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33407 | 47061 | }, |
| 33408 | | .extra_temps = .{ |
| 33409 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33410 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33411 | | .unused, |
| 33412 | | .unused, |
| 33413 | | .unused, |
| 33414 | | .unused, |
| 33415 | | .unused, |
| 33416 | | .unused, |
| 33417 | | .unused, |
| 47062 | .patterns = &.{ |
| 47063 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 47064 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 47065 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47066 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33418 | 47067 | }, |
| 33419 | | .dst_temps = .{.mem}, |
| 33420 | | .clobbers = .{ .eflags = true }, |
| 47068 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33421 | 47069 | .each = .{ .once = &.{ |
| 33422 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33423 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 33424 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33425 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33426 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47070 | .{ ._, .v_ss, .fmadd132, .dst0x, .src2x, .src1d, ._ }, |
| 33427 | 47071 | } }, |
| 33428 | 47072 | }, .{ |
| 33429 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33430 | | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 33431 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 33432 | | .patterns = &.{ |
| 33433 | | .{ .src = .{ .to_mem, .none } }, |
| 47073 | .required_features = .{ .fma, null, null, null }, |
| 47074 | .src_constraints = .{ |
| 47075 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47076 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47077 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33434 | 47078 | }, |
| 33435 | | .extra_temps = .{ |
| 33436 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33437 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 33438 | | .unused, |
| 33439 | | .unused, |
| 33440 | | .unused, |
| 33441 | | .unused, |
| 33442 | | .unused, |
| 33443 | | .unused, |
| 33444 | | .unused, |
| 47079 | .patterns = &.{ |
| 47080 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 47081 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 47082 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47083 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33445 | 47084 | }, |
| 33446 | | .dst_temps = .{.mem}, |
| 33447 | | .clobbers = .{ .eflags = true }, |
| 47085 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33448 | 47086 | .each = .{ .once = &.{ |
| 33449 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33450 | | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 33451 | | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33452 | | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33453 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33454 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33455 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47087 | .{ ._, .v_ss, .fmadd213, .dst0x, .src1x, .src2d, ._ }, |
| 33456 | 47088 | } }, |
| 33457 | 47089 | }, .{ |
| 33458 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 33459 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 33460 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 33461 | | .patterns = &.{ |
| 33462 | | .{ .src = .{ .to_mem, .none } }, |
| 47090 | .required_features = .{ .fma, null, null, null }, |
| 47091 | .src_constraints = .{ |
| 47092 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47093 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47094 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33463 | 47095 | }, |
| 33464 | | .extra_temps = .{ |
| 33465 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33466 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 33467 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33468 | | .unused, |
| 33469 | | .unused, |
| 33470 | | .unused, |
| 33471 | | .unused, |
| 33472 | | .unused, |
| 33473 | | .unused, |
| 47096 | .patterns = &.{ |
| 47097 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 47098 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 47099 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 33474 | 47100 | }, |
| 33475 | | .dst_temps = .{.mem}, |
| 33476 | | .clobbers = .{ .eflags = true }, |
| 47101 | .dst_temps = .{.{ .ref = .src2 }}, |
| 33477 | 47102 | .each = .{ .once = &.{ |
| 33478 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33479 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 33480 | | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 33481 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 33482 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33483 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47103 | .{ ._, .v_ss, .fmadd231, .dst0x, .src0x, .src1d, ._ }, |
| 33484 | 47104 | } }, |
| 33485 | 47105 | }, .{ |
| 33486 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33487 | | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, |
| 33488 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 47106 | .required_features = .{ .sse, null, null, null }, |
| 47107 | .src_constraints = .{ |
| 47108 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47109 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47110 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47111 | }, |
| 33489 | 47112 | .patterns = &.{ |
| 33490 | | .{ .src = .{ .to_mem, .none } }, |
| 47113 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, |
| 33491 | 47114 | }, |
| 47115 | .call_frame = .{ .alignment = .@"16" }, |
| 33492 | 47116 | .extra_temps = .{ |
| 33493 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33494 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 47117 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } }, |
| 47118 | .unused, |
| 33495 | 47119 | .unused, |
| 33496 | 47120 | .unused, |
| 33497 | 47121 | .unused, |
| ... | ... | @@ -33500,178 +47124,126 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33500 | 47124 | .unused, |
| 33501 | 47125 | .unused, |
| 33502 | 47126 | }, |
| 33503 | | .dst_temps = .{.mem}, |
| 33504 | | .clobbers = .{ .eflags = true }, |
| 47127 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47128 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33505 | 47129 | .each = .{ .once = &.{ |
| 33506 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33507 | | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 33508 | | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 33509 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 33510 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33511 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47130 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 33512 | 47131 | } }, |
| 33513 | 47132 | }, .{ |
| 33514 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33515 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 33516 | | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 33517 | | .patterns = &.{ |
| 33518 | | .{ .src = .{ .to_mem, .none } }, |
| 47133 | .required_features = .{ .fma, null, null, null }, |
| 47134 | .src_constraints = .{ |
| 47135 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 47136 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 47137 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33519 | 47138 | }, |
| 33520 | | .extra_temps = .{ |
| 33521 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33522 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33523 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33524 | | .unused, |
| 33525 | | .unused, |
| 33526 | | .unused, |
| 33527 | | .unused, |
| 33528 | | .unused, |
| 33529 | | .unused, |
| 47139 | .patterns = &.{ |
| 47140 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 47141 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 47142 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47143 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33530 | 47144 | }, |
| 33531 | | .dst_temps = .{.mem}, |
| 33532 | | .clobbers = .{ .eflags = true }, |
| 47145 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33533 | 47146 | .each = .{ .once = &.{ |
| 33534 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33535 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 33536 | | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 33537 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 33538 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 33539 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33540 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47147 | .{ ._, .v_ps, .fmadd132, .dst0x, .src2x, .src1x, ._ }, |
| 33541 | 47148 | } }, |
| 33542 | 47149 | }, .{ |
| 33543 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33544 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33545 | | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 33546 | | .patterns = &.{ |
| 33547 | | .{ .src = .{ .to_mem, .none } }, |
| 47150 | .required_features = .{ .fma, null, null, null }, |
| 47151 | .src_constraints = .{ |
| 47152 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 47153 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 47154 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33548 | 47155 | }, |
| 33549 | | .extra_temps = .{ |
| 33550 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33551 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33552 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 33553 | | .unused, |
| 33554 | | .unused, |
| 33555 | | .unused, |
| 33556 | | .unused, |
| 33557 | | .unused, |
| 33558 | | .unused, |
| 47156 | .patterns = &.{ |
| 47157 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 47158 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 47159 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47160 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33559 | 47161 | }, |
| 33560 | | .dst_temps = .{.mem}, |
| 33561 | | .clobbers = .{ .eflags = true }, |
| 47162 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33562 | 47163 | .each = .{ .once = &.{ |
| 33563 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33564 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 33565 | | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 33566 | | .{ ._, ._l, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33567 | | .{ ._, ._r, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 33568 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 33569 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 33570 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33571 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47164 | .{ ._, .v_ps, .fmadd213, .dst0x, .src1x, .src2x, ._ }, |
| 33572 | 47165 | } }, |
| 33573 | 47166 | }, .{ |
| 33574 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 33575 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 33576 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 33577 | | .patterns = &.{ |
| 33578 | | .{ .src = .{ .to_mem, .none } }, |
| 47167 | .required_features = .{ .fma, null, null, null }, |
| 47168 | .src_constraints = .{ |
| 47169 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 47170 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 47171 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33579 | 47172 | }, |
| 33580 | | .extra_temps = .{ |
| 33581 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33582 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33583 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 33584 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33585 | | .unused, |
| 33586 | | .unused, |
| 33587 | | .unused, |
| 33588 | | .unused, |
| 33589 | | .unused, |
| 47173 | .patterns = &.{ |
| 47174 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 47175 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 47176 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 33590 | 47177 | }, |
| 33591 | | .dst_temps = .{.mem}, |
| 33592 | | .clobbers = .{ .eflags = true }, |
| 47178 | .dst_temps = .{.{ .ref = .src2 }}, |
| 33593 | 47179 | .each = .{ .once = &.{ |
| 33594 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33595 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 33596 | | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 33597 | | .{ .@"0:", ._, .bzhi, .tmp3q, .memi(.src0q, .tmp1), .tmp2q, ._ }, |
| 33598 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 33599 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 33600 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33601 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47180 | .{ ._, .v_ps, .fmadd231, .dst0x, .src0x, .src1x, ._ }, |
| 33602 | 47181 | } }, |
| 33603 | 47182 | }, .{ |
| 33604 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33605 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 33606 | | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 33607 | | .patterns = &.{ |
| 33608 | | .{ .src = .{ .to_mem, .none } }, |
| 47183 | .required_features = .{ .fma, null, null, null }, |
| 47184 | .src_constraints = .{ |
| 47185 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47186 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47187 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33609 | 47188 | }, |
| 33610 | | .extra_temps = .{ |
| 33611 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33612 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33613 | | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 33614 | | .unused, |
| 33615 | | .unused, |
| 33616 | | .unused, |
| 33617 | | .unused, |
| 33618 | | .unused, |
| 33619 | | .unused, |
| 47189 | .patterns = &.{ |
| 47190 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 47191 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 47192 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47193 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33620 | 47194 | }, |
| 33621 | | .dst_temps = .{.mem}, |
| 33622 | | .clobbers = .{ .eflags = true }, |
| 47195 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33623 | 47196 | .each = .{ .once = &.{ |
| 33624 | | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 33625 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 33626 | | .{ .@"0:", ._, .mov, .tmp2q, .ua(.dst0, .add_umax), ._, ._ }, |
| 33627 | | .{ ._, ._, .@"and", .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 33628 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 33629 | | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 33630 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33631 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 47197 | .{ ._, .v_ps, .fmadd132, .dst0y, .src2y, .src1y, ._ }, |
| 33632 | 47198 | } }, |
| 33633 | 47199 | }, .{ |
| 33634 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 33635 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 33636 | | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 47200 | .required_features = .{ .fma, null, null, null }, |
| 47201 | .src_constraints = .{ |
| 47202 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47203 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47204 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47205 | }, |
| 33637 | 47206 | .patterns = &.{ |
| 33638 | | .{ .src = .{ .to_mem, .none } }, |
| 47207 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 47208 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 47209 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47210 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33639 | 47211 | }, |
| 33640 | | .extra_temps = .{ |
| 33641 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33642 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33643 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33644 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33645 | | .unused, |
| 33646 | | .unused, |
| 33647 | | .unused, |
| 33648 | | .unused, |
| 33649 | | .unused, |
| 47212 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47213 | .each = .{ .once = &.{ |
| 47214 | .{ ._, .v_ps, .fmadd213, .dst0y, .src1y, .src2y, ._ }, |
| 47215 | } }, |
| 47216 | }, .{ |
| 47217 | .required_features = .{ .fma, null, null, null }, |
| 47218 | .src_constraints = .{ |
| 47219 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47220 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47221 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33650 | 47222 | }, |
| 33651 | | .dst_temps = .{.mem}, |
| 33652 | | .clobbers = .{ .eflags = true }, |
| 47223 | .patterns = &.{ |
| 47224 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 47225 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 47226 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 47227 | }, |
| 47228 | .dst_temps = .{.{ .ref = .src2 }}, |
| 33653 | 47229 | .each = .{ .once = &.{ |
| 33654 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33655 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33656 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33657 | | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 33658 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33659 | | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33660 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 33661 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47230 | .{ ._, .v_ps, .fmadd231, .dst0y, .src0y, .src1y, ._ }, |
| 33662 | 47231 | } }, |
| 33663 | 47232 | }, .{ |
| 33664 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33665 | | .src_constraints = .{ .any_scalar_int, .any }, |
| 33666 | | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 47233 | .required_features = .{ .fma, null, null, null }, |
| 47234 | .src_constraints = .{ |
| 47235 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47236 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47237 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 47238 | }, |
| 33667 | 47239 | .patterns = &.{ |
| 33668 | | .{ .src = .{ .to_mem, .none } }, |
| 47240 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33669 | 47241 | }, |
| 33670 | 47242 | .extra_temps = .{ |
| 33671 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33672 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33673 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33674 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47244 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 47245 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 47246 | .unused, |
| 33675 | 47247 | .unused, |
| 33676 | 47248 | .unused, |
| 33677 | 47249 | .unused, |
| ... | ... | @@ -33679,955 +47251,607 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33679 | 47251 | .unused, |
| 33680 | 47252 | }, |
| 33681 | 47253 | .dst_temps = .{.mem}, |
| 33682 | | .clobbers = .{ .eflags = true }, |
| 33683 | 47254 | .each = .{ .once = &.{ |
| 33684 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33685 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33686 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33687 | | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 33688 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33689 | | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33690 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 33691 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47255 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47256 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47257 | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47258 | .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ }, |
| 47259 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 47260 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 47261 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33692 | 47262 | } }, |
| 33693 | 47263 | }, .{ |
| 33694 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 33695 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33696 | | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 47264 | .required_features = .{ .avx, null, null, null }, |
| 47265 | .src_constraints = .{ |
| 47266 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47267 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47268 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47269 | }, |
| 33697 | 47270 | .patterns = &.{ |
| 33698 | | .{ .src = .{ .to_mem, .none } }, |
| 47271 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33699 | 47272 | }, |
| 47273 | .call_frame = .{ .alignment = .@"16" }, |
| 33700 | 47274 | .extra_temps = .{ |
| 33701 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33702 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33703 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33704 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33705 | | .unused, |
| 47275 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47276 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 47277 | .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, |
| 47278 | .{ .type = .f32, .kind = .{ .reg = .xmm2 } }, |
| 47279 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } }, |
| 33706 | 47280 | .unused, |
| 33707 | 47281 | .unused, |
| 33708 | 47282 | .unused, |
| 33709 | 47283 | .unused, |
| 33710 | 47284 | }, |
| 33711 | 47285 | .dst_temps = .{.mem}, |
| 33712 | | .clobbers = .{ .eflags = true }, |
| 47286 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33713 | 47287 | .each = .{ .once = &.{ |
| 33714 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33715 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33716 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33717 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33718 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33719 | | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 33720 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 33721 | | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 33722 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 33723 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33724 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 33725 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 33726 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47288 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47289 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47290 | .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47291 | .{ ._, .v_ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47292 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47293 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47294 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 47295 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33727 | 47296 | } }, |
| 33728 | 47297 | }, .{ |
| 33729 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33730 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33731 | | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 47298 | .required_features = .{ .sse, null, null, null }, |
| 47299 | .src_constraints = .{ |
| 47300 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47301 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47302 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 47303 | }, |
| 33732 | 47304 | .patterns = &.{ |
| 33733 | | .{ .src = .{ .to_mem, .none } }, |
| 47305 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33734 | 47306 | }, |
| 47307 | .call_frame = .{ .alignment = .@"16" }, |
| 33735 | 47308 | .extra_temps = .{ |
| 33736 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33737 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33738 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33739 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33740 | | .unused, |
| 47309 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47310 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 47311 | .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, |
| 47312 | .{ .type = .f32, .kind = .{ .reg = .xmm2 } }, |
| 47313 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } }, |
| 33741 | 47314 | .unused, |
| 33742 | 47315 | .unused, |
| 33743 | 47316 | .unused, |
| 33744 | 47317 | .unused, |
| 33745 | 47318 | }, |
| 33746 | 47319 | .dst_temps = .{.mem}, |
| 33747 | | .clobbers = .{ .eflags = true }, |
| 47320 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33748 | 47321 | .each = .{ .once = &.{ |
| 33749 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33750 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33751 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33752 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33753 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33754 | | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 33755 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 33756 | | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 33757 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 33758 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33759 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 33760 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 33761 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47322 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47323 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47324 | .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47325 | .{ ._, ._ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47326 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47327 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47328 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 47329 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33762 | 47330 | } }, |
| 33763 | 47331 | }, .{ |
| 33764 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 33765 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33766 | | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 47332 | .required_features = .{ .fma, null, null, null }, |
| 47333 | .src_constraints = .{ |
| 47334 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47335 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47336 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47337 | }, |
| 33767 | 47338 | .patterns = &.{ |
| 33768 | | .{ .src = .{ .to_mem, .none } }, |
| 47339 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 47340 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 47341 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47342 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33769 | 47343 | }, |
| 33770 | | .extra_temps = .{ |
| 33771 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33772 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33773 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33774 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33775 | | .unused, |
| 33776 | | .unused, |
| 33777 | | .unused, |
| 33778 | | .unused, |
| 33779 | | .unused, |
| 47344 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47345 | .each = .{ .once = &.{ |
| 47346 | .{ ._, .v_sd, .fmadd132, .dst0x, .src2x, .src1q, ._ }, |
| 47347 | } }, |
| 47348 | }, .{ |
| 47349 | .required_features = .{ .fma, null, null, null }, |
| 47350 | .src_constraints = .{ |
| 47351 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47352 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47353 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 33780 | 47354 | }, |
| 33781 | | .dst_temps = .{.mem}, |
| 33782 | | .clobbers = .{ .eflags = true }, |
| 47355 | .patterns = &.{ |
| 47356 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 47357 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 47358 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47359 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 47360 | }, |
| 47361 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33783 | 47362 | .each = .{ .once = &.{ |
| 33784 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33785 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33786 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33787 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33788 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33789 | | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 33790 | | .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33791 | | .{ ._, ._r, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33792 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 33793 | | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 33794 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 33795 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33796 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 33797 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 33798 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47363 | .{ ._, .v_sd, .fmadd213, .dst0x, .src1x, .src2q, ._ }, |
| 33799 | 47364 | } }, |
| 33800 | 47365 | }, .{ |
| 33801 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33802 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33803 | | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 47366 | .required_features = .{ .fma, null, null, null }, |
| 47367 | .src_constraints = .{ |
| 47368 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47369 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47370 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47371 | }, |
| 47372 | .patterns = &.{ |
| 47373 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 47374 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 47375 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 47376 | }, |
| 47377 | .dst_temps = .{.{ .ref = .src2 }}, |
| 47378 | .each = .{ .once = &.{ |
| 47379 | .{ ._, .v_sd, .fmadd231, .dst0x, .src0x, .src1q, ._ }, |
| 47380 | } }, |
| 47381 | }, .{ |
| 47382 | .required_features = .{ .sse, null, null, null }, |
| 47383 | .src_constraints = .{ |
| 47384 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47385 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47386 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47387 | }, |
| 33804 | 47388 | .patterns = &.{ |
| 33805 | | .{ .src = .{ .to_mem, .none } }, |
| 47389 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, |
| 33806 | 47390 | }, |
| 47391 | .call_frame = .{ .alignment = .@"16" }, |
| 33807 | 47392 | .extra_temps = .{ |
| 33808 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33809 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33810 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33811 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47393 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 47394 | .unused, |
| 47395 | .unused, |
| 47396 | .unused, |
| 33812 | 47397 | .unused, |
| 33813 | 47398 | .unused, |
| 33814 | 47399 | .unused, |
| 33815 | 47400 | .unused, |
| 33816 | 47401 | .unused, |
| 33817 | 47402 | }, |
| 33818 | | .dst_temps = .{.mem}, |
| 33819 | | .clobbers = .{ .eflags = true }, |
| 47403 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47404 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33820 | 47405 | .each = .{ .once = &.{ |
| 33821 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33822 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33823 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33824 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33825 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33826 | | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 33827 | | .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33828 | | .{ ._, ._r, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33829 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 33830 | | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 33831 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .tmp3q, ._, ._ }, |
| 33832 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33833 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 33834 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 33835 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47406 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 33836 | 47407 | } }, |
| 33837 | 47408 | }, .{ |
| 33838 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 33839 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33840 | | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 47409 | .required_features = .{ .fma, null, null, null }, |
| 47410 | .src_constraints = .{ |
| 47411 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47412 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47413 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47414 | }, |
| 33841 | 47415 | .patterns = &.{ |
| 33842 | | .{ .src = .{ .to_mem, .none } }, |
| 47416 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 47417 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 47418 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47419 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33843 | 47420 | }, |
| 33844 | | .extra_temps = .{ |
| 33845 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33846 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33847 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33848 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33849 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 33850 | | .unused, |
| 33851 | | .unused, |
| 33852 | | .unused, |
| 33853 | | .unused, |
| 47421 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47422 | .each = .{ .once = &.{ |
| 47423 | .{ ._, .v_pd, .fmadd132, .dst0x, .src2x, .src1x, ._ }, |
| 47424 | } }, |
| 47425 | }, .{ |
| 47426 | .required_features = .{ .fma, null, null, null }, |
| 47427 | .src_constraints = .{ |
| 47428 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47429 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47430 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 33854 | 47431 | }, |
| 33855 | | .dst_temps = .{.mem}, |
| 33856 | | .clobbers = .{ .eflags = true }, |
| 47432 | .patterns = &.{ |
| 47433 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 47434 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 47435 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47436 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 47437 | }, |
| 47438 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33857 | 47439 | .each = .{ .once = &.{ |
| 33858 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33859 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33860 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33861 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33862 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33863 | | .{ ._, ._, .mov, .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 33864 | | .{ ._, ._l, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33865 | | .{ ._, ._r, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33866 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 33867 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33868 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 33869 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47440 | .{ ._, .v_pd, .fmadd213, .dst0x, .src1x, .src2x, ._ }, |
| 33870 | 47441 | } }, |
| 33871 | 47442 | }, .{ |
| 33872 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33873 | | .src_constraints = .{ .any_scalar_signed_int, .any }, |
| 33874 | | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 47443 | .required_features = .{ .fma, null, null, null }, |
| 47444 | .src_constraints = .{ |
| 47445 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47446 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47447 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 47448 | }, |
| 33875 | 47449 | .patterns = &.{ |
| 33876 | | .{ .src = .{ .to_mem, .none } }, |
| 47450 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 47451 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 47452 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 33877 | 47453 | }, |
| 33878 | | .extra_temps = .{ |
| 33879 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33880 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33881 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33882 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33883 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 33884 | | .unused, |
| 33885 | | .unused, |
| 33886 | | .unused, |
| 33887 | | .unused, |
| 47454 | .dst_temps = .{.{ .ref = .src2 }}, |
| 47455 | .each = .{ .once = &.{ |
| 47456 | .{ ._, .v_pd, .fmadd231, .dst0x, .src0x, .src1x, ._ }, |
| 47457 | } }, |
| 47458 | }, .{ |
| 47459 | .required_features = .{ .fma, null, null, null }, |
| 47460 | .src_constraints = .{ |
| 47461 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47462 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47463 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 33888 | 47464 | }, |
| 33889 | | .dst_temps = .{.mem}, |
| 33890 | | .clobbers = .{ .eflags = true }, |
| 47465 | .patterns = &.{ |
| 47466 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 47467 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 47468 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47469 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 47470 | }, |
| 47471 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33891 | 47472 | .each = .{ .once = &.{ |
| 33892 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33893 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33894 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33895 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33896 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33897 | | .{ ._, ._, .mov, .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 33898 | | .{ ._, ._l, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33899 | | .{ ._, ._r, .sa, .tmp4q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 33900 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 33901 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33902 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 33903 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47473 | .{ ._, .v_pd, .fmadd132, .dst0y, .src2y, .src1y, ._ }, |
| 33904 | 47474 | } }, |
| 33905 | 47475 | }, .{ |
| 33906 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 33907 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 33908 | | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 47476 | .required_features = .{ .fma, null, null, null }, |
| 47477 | .src_constraints = .{ |
| 47478 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47479 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47480 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47481 | }, |
| 47482 | .patterns = &.{ |
| 47483 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 47484 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 47485 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 47486 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 47487 | }, |
| 47488 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47489 | .each = .{ .once = &.{ |
| 47490 | .{ ._, .v_pd, .fmadd213, .dst0y, .src1y, .src2y, ._ }, |
| 47491 | } }, |
| 47492 | }, .{ |
| 47493 | .required_features = .{ .fma, null, null, null }, |
| 47494 | .src_constraints = .{ |
| 47495 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47496 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47497 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47498 | }, |
| 47499 | .patterns = &.{ |
| 47500 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 47501 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 47502 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 47503 | }, |
| 47504 | .dst_temps = .{.{ .ref = .src2 }}, |
| 47505 | .each = .{ .once = &.{ |
| 47506 | .{ ._, .v_pd, .fmadd231, .dst0y, .src0y, .src1y, ._ }, |
| 47507 | } }, |
| 47508 | }, .{ |
| 47509 | .required_features = .{ .fma, null, null, null }, |
| 47510 | .src_constraints = .{ |
| 47511 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47512 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47513 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 47514 | }, |
| 33909 | 47515 | .patterns = &.{ |
| 33910 | | .{ .src = .{ .to_mem, .none } }, |
| 47516 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33911 | 47517 | }, |
| 33912 | 47518 | .extra_temps = .{ |
| 33913 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33914 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33915 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33916 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 33917 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47519 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47520 | .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 47521 | .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 47522 | .unused, |
| 47523 | .unused, |
| 33918 | 47524 | .unused, |
| 33919 | 47525 | .unused, |
| 33920 | 47526 | .unused, |
| 33921 | 47527 | .unused, |
| 33922 | 47528 | }, |
| 33923 | 47529 | .dst_temps = .{.mem}, |
| 33924 | | .clobbers = .{ .eflags = true }, |
| 33925 | 47530 | .each = .{ .once = &.{ |
| 33926 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33927 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33928 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33929 | | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 33930 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33931 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33932 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 33933 | | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33934 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 33935 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47531 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47532 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47533 | .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47534 | .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ }, |
| 47535 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 47536 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 47537 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33936 | 47538 | } }, |
| 33937 | 47539 | }, .{ |
| 33938 | | .required_features = .{ .@"64bit", null, null, null }, |
| 33939 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 33940 | | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 47540 | .required_features = .{ .avx, null, null, null }, |
| 47541 | .src_constraints = .{ |
| 47542 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47543 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47544 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47545 | }, |
| 33941 | 47546 | .patterns = &.{ |
| 33942 | | .{ .src = .{ .to_mem, .none } }, |
| 47547 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33943 | 47548 | }, |
| 47549 | .call_frame = .{ .alignment = .@"16" }, |
| 33944 | 47550 | .extra_temps = .{ |
| 33945 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33946 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33947 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33948 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 33949 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47551 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47552 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 47553 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 47554 | .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, |
| 47555 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 33950 | 47556 | .unused, |
| 33951 | 47557 | .unused, |
| 33952 | 47558 | .unused, |
| 33953 | 47559 | .unused, |
| 33954 | 47560 | }, |
| 33955 | 47561 | .dst_temps = .{.mem}, |
| 33956 | | .clobbers = .{ .eflags = true }, |
| 47562 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33957 | 47563 | .each = .{ .once = &.{ |
| 33958 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33959 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33960 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33961 | | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 33962 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33963 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33964 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 33965 | | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33966 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 33967 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47564 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47565 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47566 | .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47567 | .{ ._, .v_sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47568 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47569 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47570 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 47571 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33968 | 47572 | } }, |
| 33969 | 47573 | }, .{ |
| 33970 | | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| 33971 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 33972 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 47574 | .required_features = .{ .sse2, null, null, null }, |
| 47575 | .src_constraints = .{ |
| 47576 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47577 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47578 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47579 | }, |
| 33973 | 47580 | .patterns = &.{ |
| 33974 | | .{ .src = .{ .to_mem, .none } }, |
| 47581 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33975 | 47582 | }, |
| 47583 | .call_frame = .{ .alignment = .@"16" }, |
| 33976 | 47584 | .extra_temps = .{ |
| 33977 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33978 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33979 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33980 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 33981 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47585 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47586 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 47587 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 47588 | .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, |
| 47589 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 33982 | 47590 | .unused, |
| 33983 | 47591 | .unused, |
| 33984 | 47592 | .unused, |
| 33985 | 47593 | .unused, |
| 33986 | 47594 | }, |
| 33987 | 47595 | .dst_temps = .{.mem}, |
| 33988 | | .clobbers = .{ .eflags = true }, |
| 47596 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33989 | 47597 | .each = .{ .once = &.{ |
| 33990 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33991 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33992 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33993 | | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 33994 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33995 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33996 | | .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ }, |
| 33997 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ }, |
| 33998 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 33999 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34000 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 34001 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 34002 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47598 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47599 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47600 | .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47601 | .{ ._, ._sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47602 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47603 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47604 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 47605 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34003 | 47606 | } }, |
| 34004 | 47607 | }, .{ |
| 34005 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 34006 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34007 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 47608 | .required_features = .{ .sse, null, null, null }, |
| 47609 | .src_constraints = .{ |
| 47610 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47611 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47612 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 47613 | }, |
| 34008 | 47614 | .patterns = &.{ |
| 34009 | | .{ .src = .{ .to_mem, .none } }, |
| 47615 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34010 | 47616 | }, |
| 47617 | .call_frame = .{ .alignment = .@"16" }, |
| 34011 | 47618 | .extra_temps = .{ |
| 34012 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34013 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34014 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34015 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 34016 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47619 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47620 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 47621 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 47622 | .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, |
| 47623 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 34017 | 47624 | .unused, |
| 34018 | 47625 | .unused, |
| 34019 | 47626 | .unused, |
| 34020 | 47627 | .unused, |
| 34021 | 47628 | }, |
| 34022 | 47629 | .dst_temps = .{.mem}, |
| 34023 | | .clobbers = .{ .eflags = true }, |
| 47630 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34024 | 47631 | .each = .{ .once = &.{ |
| 34025 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34026 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34027 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34028 | | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 34029 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34030 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34031 | | .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ }, |
| 34032 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ }, |
| 34033 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 34034 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34035 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 34036 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 34037 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47632 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47633 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 47634 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 47635 | .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 47636 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47637 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47638 | .{ ._, ._ps, .movl, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47639 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47640 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47641 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 47642 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34038 | 47643 | } }, |
| 34039 | 47644 | }, .{ |
| 34040 | | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| 34041 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34042 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 47645 | .required_features = .{ .sse, .x87, null, null }, |
| 47646 | .src_constraints = .{ |
| 47647 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 47648 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 47649 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 47650 | }, |
| 34043 | 47651 | .patterns = &.{ |
| 34044 | | .{ .src = .{ .to_mem, .none } }, |
| 47652 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34045 | 47653 | }, |
| 47654 | .call_frame = .{ .size = 16 * 3, .alignment = .@"16" }, |
| 34046 | 47655 | .extra_temps = .{ |
| 34047 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34048 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34049 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34050 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 34051 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 34052 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 47656 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 47657 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 47658 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmax" } } }, |
| 47659 | .unused, |
| 47660 | .unused, |
| 47661 | .unused, |
| 34053 | 47662 | .unused, |
| 34054 | 47663 | .unused, |
| 34055 | 47664 | .unused, |
| 34056 | 47665 | }, |
| 34057 | | .dst_temps = .{.mem}, |
| 34058 | | .clobbers = .{ .eflags = true }, |
| 47666 | .dst_temps = .{.{ .reg = .st0 }}, |
| 47667 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34059 | 47668 | .each = .{ .once = &.{ |
| 34060 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34061 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34062 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34063 | | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 34064 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34065 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34066 | | .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ }, |
| 34067 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 34068 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34069 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 34070 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47669 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ }, |
| 47670 | .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 47671 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ }, |
| 47672 | .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ }, |
| 47673 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src2x), ._, ._ }, |
| 47674 | .{ ._, ._ps, .mova, .memd(.tmp1x, 16 * 2), .tmp0x, ._, ._ }, |
| 47675 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34071 | 47676 | } }, |
| 34072 | 47677 | }, .{ |
| 34073 | | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 34074 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34075 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 47678 | .required_features = .{ .sse, .x87, null, null }, |
| 47679 | .src_constraints = .{ |
| 47680 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 47681 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 47682 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 47683 | }, |
| 34076 | 47684 | .patterns = &.{ |
| 34077 | | .{ .src = .{ .to_mem, .none } }, |
| 47685 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34078 | 47686 | }, |
| 47687 | .call_frame = .{ .size = 16 * 3, .alignment = .@"16" }, |
| 34079 | 47688 | .extra_temps = .{ |
| 34080 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34081 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34082 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34083 | | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 34084 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 34085 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 47689 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47690 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 47691 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 47692 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmax" } } }, |
| 47693 | .unused, |
| 47694 | .unused, |
| 34086 | 47695 | .unused, |
| 34087 | 47696 | .unused, |
| 34088 | 47697 | .unused, |
| 34089 | 47698 | }, |
| 34090 | 47699 | .dst_temps = .{.mem}, |
| 34091 | | .clobbers = .{ .eflags = true }, |
| 47700 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34092 | 47701 | .each = .{ .once = &.{ |
| 34093 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34094 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34095 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34096 | | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 34097 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34098 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34099 | | .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ }, |
| 34100 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 34101 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34102 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 34103 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47702 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47703 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47704 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 47705 | .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47706 | .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ }, |
| 47707 | .{ ._, ._ps, .mova, .tmp1x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47708 | .{ ._, ._ps, .mova, .memd(.tmp2x, 16 * 2), .tmp1x, ._, ._ }, |
| 47709 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 47710 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 47711 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 47712 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 47713 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34104 | 47714 | } }, |
| 34105 | 47715 | }, .{ |
| 34106 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 34107 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34108 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 47716 | .required_features = .{ .sse, null, null, null }, |
| 47717 | .src_constraints = .{ |
| 47718 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47719 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47720 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47721 | }, |
| 34109 | 47722 | .patterns = &.{ |
| 34110 | | .{ .src = .{ .to_mem, .none } }, |
| 47723 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .{ .to_reg = .xmm2 } } }, |
| 34111 | 47724 | }, |
| 47725 | .call_frame = .{ .alignment = .@"16" }, |
| 34112 | 47726 | .extra_temps = .{ |
| 34113 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34114 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34115 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34116 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47727 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 47728 | .unused, |
| 47729 | .unused, |
| 47730 | .unused, |
| 34117 | 47731 | .unused, |
| 34118 | 47732 | .unused, |
| 34119 | 47733 | .unused, |
| 34120 | 47734 | .unused, |
| 34121 | 47735 | .unused, |
| 34122 | 47736 | }, |
| 34123 | | .dst_temps = .{.mem}, |
| 34124 | | .clobbers = .{ .eflags = true }, |
| 47737 | .dst_temps = .{.{ .ref = .src0 }}, |
| 47738 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34125 | 47739 | .each = .{ .once = &.{ |
| 34126 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34127 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34128 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34129 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34130 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34131 | | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, |
| 34132 | | .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 34133 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 34134 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 34135 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34136 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 34137 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 34138 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47740 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 34139 | 47741 | } }, |
| 34140 | 47742 | }, .{ |
| 34141 | | .required_features = .{ .@"64bit", null, null, null }, |
| 34142 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34143 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 47743 | .required_features = .{ .avx, null, null, null }, |
| 47744 | .src_constraints = .{ |
| 47745 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47746 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47747 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47748 | }, |
| 34144 | 47749 | .patterns = &.{ |
| 34145 | | .{ .src = .{ .to_mem, .none } }, |
| 47750 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34146 | 47751 | }, |
| 47752 | .call_frame = .{ .alignment = .@"16" }, |
| 34147 | 47753 | .extra_temps = .{ |
| 34148 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34149 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34150 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34151 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 34152 | | .unused, |
| 47754 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47755 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 47756 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 47757 | .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, |
| 47758 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34153 | 47759 | .unused, |
| 34154 | 47760 | .unused, |
| 34155 | 47761 | .unused, |
| 34156 | 47762 | .unused, |
| 34157 | 47763 | }, |
| 34158 | 47764 | .dst_temps = .{.mem}, |
| 34159 | | .clobbers = .{ .eflags = true }, |
| 47765 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34160 | 47766 | .each = .{ .once = &.{ |
| 34161 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34162 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34163 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34164 | | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34165 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34166 | | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, |
| 34167 | | .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 34168 | | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 34169 | | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 34170 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34171 | | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, |
| 34172 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 34173 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47767 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47768 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47769 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47770 | .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47771 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47772 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47773 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 47774 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34174 | 47775 | } }, |
| 34175 | 47776 | }, .{ |
| 34176 | | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 34177 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34178 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 47777 | .required_features = .{ .sse2, null, null, null }, |
| 47778 | .src_constraints = .{ |
| 47779 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47780 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47781 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47782 | }, |
| 34179 | 47783 | .patterns = &.{ |
| 34180 | | .{ .src = .{ .to_mem, .none } }, |
| 47784 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34181 | 47785 | }, |
| 47786 | .call_frame = .{ .alignment = .@"16" }, |
| 34182 | 47787 | .extra_temps = .{ |
| 34183 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34184 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34185 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34186 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 34187 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47788 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47789 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 47790 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 47791 | .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, |
| 47792 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34188 | 47793 | .unused, |
| 34189 | 47794 | .unused, |
| 34190 | 47795 | .unused, |
| 34191 | 47796 | .unused, |
| 34192 | 47797 | }, |
| 34193 | 47798 | .dst_temps = .{.mem}, |
| 34194 | | .clobbers = .{ .eflags = true }, |
| 47799 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34195 | 47800 | .each = .{ .once = &.{ |
| 34196 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34197 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34198 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34199 | | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 34200 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34201 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34202 | | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, |
| 34203 | | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 34204 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 34205 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34206 | | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| 34207 | | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 47801 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47802 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47803 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47804 | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47805 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47806 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47807 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 47808 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34208 | 47809 | } }, |
| 34209 | 47810 | }, .{ |
| 34210 | | .required_features = .{ .@"64bit", null, null, null }, |
| 34211 | | .src_constraints = .{ .any_scalar_unsigned_int, .any }, |
| 34212 | | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 47811 | .required_features = .{ .sse, null, null, null }, |
| 47812 | .src_constraints = .{ |
| 47813 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47814 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47815 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 47816 | }, |
| 34213 | 47817 | .patterns = &.{ |
| 34214 | | .{ .src = .{ .to_mem, .none } }, |
| 47818 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34215 | 47819 | }, |
| 47820 | .call_frame = .{ .alignment = .@"16" }, |
| 34216 | 47821 | .extra_temps = .{ |
| 34217 | | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 34218 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 34219 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 34220 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 34221 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 47822 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 47823 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 47824 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 47825 | .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, |
| 47826 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34222 | 47827 | .unused, |
| 34223 | 47828 | .unused, |
| 34224 | 47829 | .unused, |
| 34225 | 47830 | .unused, |
| 34226 | 47831 | }, |
| 34227 | 47832 | .dst_temps = .{.mem}, |
| 34228 | | .clobbers = .{ .eflags = true }, |
| 47833 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34229 | 47834 | .each = .{ .once = &.{ |
| 34230 | | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 34231 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 34232 | | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 34233 | | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 34234 | | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 34235 | | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 34236 | | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, |
| 34237 | | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 34238 | | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 34239 | | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 34240 | | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| 34241 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 47835 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 47836 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47837 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47838 | .{ ._, ._ps, .mova, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 47839 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 47840 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 47841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 47842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34242 | 47843 | } }, |
| 34243 | 47844 | } }) catch |err| switch (err) { |
| 34244 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 47845 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {} {}", .{ |
| 34245 | 47846 | @tagName(air_tag), |
| 34246 | | ty_op.ty.toType().fmt(pt), |
| 34247 | | cg.typeOf(ty_op.operand).fmt(pt), |
| 47847 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 34248 | 47848 | ops[0].tracking(cg), |
| 47849 | ops[1].tracking(cg), |
| 47850 | ops[2].tracking(cg), |
| 34249 | 47851 | }), |
| 34250 | 47852 | else => |e| return e, |
| 34251 | 47853 | }; |
| 34252 | | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34253 | | }, |
| 34254 | | .optional_payload_ptr => if (use_old) try cg.airOptionalPayloadPtr(inst) else { |
| 34255 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34256 | | const ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34257 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34258 | | }, |
| 34259 | | .optional_payload_ptr_set => if (use_old) try cg.airOptionalPayloadPtrSet(inst) else { |
| 34260 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34261 | | const opt_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 34262 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34263 | | if (!opt_ty.optionalReprIsPayload(zcu)) { |
| 34264 | | const opt_child_ty = opt_ty.optionalChild(zcu); |
| 34265 | | const opt_child_abi_size: i32 = @intCast(opt_child_ty.abiSize(zcu)); |
| 34266 | | try ops[0].toOffset(opt_child_abi_size, cg); |
| 34267 | | var has_value = try cg.tempInit(.bool, .{ .immediate = 1 }); |
| 34268 | | try ops[0].store(&has_value, .{}, cg); |
| 34269 | | try has_value.die(cg); |
| 34270 | | try ops[0].toOffset(-opt_child_abi_size, cg); |
| 34271 | | } |
| 34272 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34273 | | }, |
| 34274 | | .unwrap_errunion_payload_ptr => if (use_old) try cg.airUnwrapErrUnionPayloadPtr(inst) else { |
| 34275 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34276 | | const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 34277 | | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 34278 | | const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); |
| 34279 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34280 | | try ops[0].toOffset(eu_pl_off, cg); |
| 34281 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34282 | | }, |
| 34283 | | .unwrap_errunion_err_ptr => if (use_old) try cg.airUnwrapErrUnionErrPtr(inst) else { |
| 34284 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34285 | | const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 34286 | | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 34287 | | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 34288 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34289 | | try ops[0].toOffset(eu_err_off, cg); |
| 34290 | | const err = try ops[0].load(eu_ty.errorUnionSet(zcu), .{}, cg); |
| 34291 | | try err.finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34292 | | }, |
| 34293 | | .errunion_payload_ptr_set => if (use_old) try cg.airErrUnionPayloadPtrSet(inst) else { |
| 34294 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34295 | | const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); |
| 34296 | | const eu_err_ty = eu_ty.errorUnionSet(zcu); |
| 34297 | | const eu_pl_ty = eu_ty.errorUnionPayload(zcu); |
| 34298 | | const eu_err_off: i32 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); |
| 34299 | | const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); |
| 34300 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34301 | | try ops[0].toOffset(eu_err_off, cg); |
| 34302 | | var no_err = try cg.tempInit(eu_err_ty, .{ .immediate = 0 }); |
| 34303 | | try ops[0].store(&no_err, .{}, cg); |
| 34304 | | try no_err.die(cg); |
| 34305 | | try ops[0].toOffset(eu_pl_off - eu_err_off, cg); |
| 34306 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34307 | | }, |
| 34308 | | .struct_field_ptr => if (use_old) try cg.airStructFieldPtr(inst) else { |
| 34309 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 34310 | | const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; |
| 34311 | | var ops = try cg.tempsFromOperands(inst, .{extra.struct_operand}); |
| 34312 | | try ops[0].toOffset(cg.fieldOffset( |
| 34313 | | cg.typeOf(extra.struct_operand), |
| 34314 | | ty_pl.ty.toType(), |
| 34315 | | extra.field_index, |
| 34316 | | ), cg); |
| 34317 | | try ops[0].finish(inst, &.{extra.struct_operand}, &ops, cg); |
| 34318 | | }, |
| 34319 | | .struct_field_ptr_index_0, |
| 34320 | | .struct_field_ptr_index_1, |
| 34321 | | .struct_field_ptr_index_2, |
| 34322 | | .struct_field_ptr_index_3, |
| 34323 | | => |air_tag| if (use_old) try cg.airStructFieldPtrIndex(inst, switch (air_tag) { |
| 34324 | | else => unreachable, |
| 34325 | | .struct_field_ptr_index_0 => 0, |
| 34326 | | .struct_field_ptr_index_1 => 1, |
| 34327 | | .struct_field_ptr_index_2 => 2, |
| 34328 | | .struct_field_ptr_index_3 => 3, |
| 34329 | | }) else { |
| 34330 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34331 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34332 | | try ops[0].toOffset(cg.fieldOffset( |
| 34333 | | cg.typeOf(ty_op.operand), |
| 34334 | | ty_op.ty.toType(), |
| 34335 | | switch (air_tag) { |
| 34336 | | else => unreachable, |
| 34337 | | .struct_field_ptr_index_0 => 0, |
| 34338 | | .struct_field_ptr_index_1 => 1, |
| 34339 | | .struct_field_ptr_index_2 => 2, |
| 34340 | | .struct_field_ptr_index_3 => 3, |
| 34341 | | }, |
| 34342 | | ), cg); |
| 34343 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34344 | | }, |
| 34345 | | .struct_field_val => if (use_old) try cg.airStructFieldVal(inst) else fallback: { |
| 34346 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 34347 | | const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; |
| 34348 | | const agg_ty = cg.typeOf(extra.struct_operand); |
| 34349 | | const field_ty = ty_pl.ty.toType(); |
| 34350 | | const field_off: u31 = switch (agg_ty.containerLayout(zcu)) { |
| 34351 | | .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(extra.field_index, zcu)), |
| 34352 | | .@"packed" => break :fallback try cg.airStructFieldVal(inst), |
| 34353 | | }; |
| 34354 | | var ops = try cg.tempsFromOperands(inst, .{extra.struct_operand}); |
| 34355 | | // hack around Sema OPV bugs |
| 34356 | | var res = if (field_ty.hasRuntimeBitsIgnoreComptime(zcu)) |
| 34357 | | try ops[0].read(field_ty, .{ .disp = field_off }, cg) |
| 34358 | | else |
| 34359 | | try cg.tempInit(field_ty, .none); |
| 34360 | | try res.finish(inst, &.{extra.struct_operand}, &ops, cg); |
| 34361 | | }, |
| 34362 | | .set_union_tag => if (use_old) try cg.airSetUnionTag(inst) else { |
| 34363 | | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 34364 | | const union_ty = cg.typeOf(bin_op.lhs).childType(zcu); |
| 34365 | | const union_layout = union_ty.unionGetLayout(zcu); |
| 34366 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 34367 | | // hack around Sema OPV bugs |
| 34368 | | if (union_layout.tag_size > 0) try ops[0].store(&ops[1], .{ |
| 34369 | | .disp = @intCast(union_layout.tagOffset()), |
| 34370 | | }, cg); |
| 34371 | | const res = try cg.tempInit(.void, .none); |
| 34372 | | try res.finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 34373 | | }, |
| 34374 | | .get_union_tag => if (use_old) try cg.airGetUnionTag(inst) else { |
| 34375 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34376 | | const union_ty = cg.typeOf(ty_op.operand); |
| 34377 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34378 | | const union_layout = union_ty.unionGetLayout(zcu); |
| 34379 | | assert(union_layout.tag_size > 0); |
| 34380 | | const res = try ops[0].read(ty_op.ty.toType(), .{ |
| 34381 | | .disp = @intCast(union_layout.tagOffset()), |
| 34382 | | }, cg); |
| 34383 | | try res.finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34384 | | }, |
| 34385 | | .slice => if (use_old) try cg.airSlice(inst) else { |
| 34386 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 34387 | | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 34388 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 34389 | | try ops[0].toPair(&ops[1], cg); |
| 34390 | | try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 34391 | | }, |
| 34392 | | .slice_len => if (use_old) try cg.airSliceLen(inst) else { |
| 34393 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34394 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34395 | | try ops[0].toSliceLen(cg); |
| 34396 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34397 | | }, |
| 34398 | | .slice_ptr => if (use_old) try cg.airSlicePtr(inst) else { |
| 34399 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34400 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34401 | | try ops[0].toSlicePtr(cg); |
| 34402 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34403 | | }, |
| 34404 | | .ptr_slice_len_ptr => if (use_old) try cg.airPtrSliceLenPtr(inst) else { |
| 34405 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34406 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34407 | | try ops[0].toOffset(8, cg); |
| 34408 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34409 | | }, |
| 34410 | | .ptr_slice_ptr_ptr => if (use_old) try cg.airPtrSlicePtrPtr(inst) else { |
| 34411 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34412 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34413 | | try ops[0].toOffset(0, cg); |
| 34414 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34415 | | }, |
| 34416 | | .slice_elem_val, .ptr_elem_val => |air_tag| if (use_old) switch (air_tag) { |
| 34417 | | else => unreachable, |
| 34418 | | .slice_elem_val => try cg.airSliceElemVal(inst), |
| 34419 | | .ptr_elem_val => try cg.airPtrElemVal(inst), |
| 34420 | | } else { |
| 34421 | | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 34422 | | const res_ty = cg.typeOf(bin_op.lhs).elemType2(zcu); |
| 34423 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 34424 | | try ops[0].toSlicePtr(cg); |
| 34425 | | var res: [1]Temp = undefined; |
| 34426 | | if (res_ty.hasRuntimeBitsIgnoreComptime(zcu)) cg.select(&res, &.{res_ty}, &ops, comptime &.{ .{ |
| 34427 | | .dst_constraints = .{.{ .int = .byte }}, |
| 34428 | | .patterns = &.{ |
| 34429 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 34430 | | }, |
| 34431 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34432 | | .each = .{ .once = &.{ |
| 34433 | | .{ ._, ._, .movzx, .dst0d, .leaa(.src0b, .add_src0_elem_size_times_src1), ._, ._ }, |
| 34434 | | } }, |
| 34435 | | }, .{ |
| 34436 | | .dst_constraints = .{.{ .int = .byte }}, |
| 34437 | | .patterns = &.{ |
| 34438 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 34439 | | }, |
| 34440 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34441 | | .each = .{ .once = &.{ |
| 34442 | | .{ ._, ._, .movzx, .dst0d, .leai(.src0b, .src1), ._, ._ }, |
| 34443 | | } }, |
| 34444 | | }, .{ |
| 34445 | | .dst_constraints = .{.{ .int = .word }}, |
| 34446 | | .patterns = &.{ |
| 34447 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 34448 | | }, |
| 34449 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34450 | | .each = .{ .once = &.{ |
| 34451 | | .{ ._, ._, .movzx, .dst0d, .leaa(.src0w, .add_src0_elem_size_times_src1), ._, ._ }, |
| 34452 | | } }, |
| 34453 | | }, .{ |
| 34454 | | .dst_constraints = .{.{ .int = .word }}, |
| 34455 | | .patterns = &.{ |
| 34456 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 34457 | | }, |
| 34458 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34459 | | .each = .{ .once = &.{ |
| 34460 | | .{ ._, ._, .movzx, .dst0d, .leasi(.src0w, .@"2", .src1), ._, ._ }, |
| 34461 | | } }, |
| 34462 | | }, .{ |
| 34463 | | .dst_constraints = .{.{ .int = .dword }}, |
| 34464 | | .patterns = &.{ |
| 34465 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 34466 | | }, |
| 34467 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34468 | | .each = .{ .once = &.{ |
| 34469 | | .{ ._, ._, .mov, .dst0d, .leaa(.src0d, .add_src0_elem_size_times_src1), ._, ._ }, |
| 34470 | | } }, |
| 34471 | | }, .{ |
| 34472 | | .dst_constraints = .{.{ .int = .dword }}, |
| 34473 | | .patterns = &.{ |
| 34474 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 34475 | | }, |
| 34476 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34477 | | .each = .{ .once = &.{ |
| 34478 | | .{ ._, ._, .mov, .dst0d, .leasi(.src0d, .@"4", .src1), ._, ._ }, |
| 34479 | | } }, |
| 34480 | | }, .{ |
| 34481 | | .dst_constraints = .{.{ .int = .qword }}, |
| 34482 | | .patterns = &.{ |
| 34483 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 34484 | | }, |
| 34485 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34486 | | .each = .{ .once = &.{ |
| 34487 | | .{ ._, ._, .mov, .dst0q, .leaa(.src0q, .add_src0_elem_size_times_src1), ._, ._ }, |
| 34488 | | } }, |
| 34489 | | }, .{ |
| 34490 | | .required_features = .{ .@"64bit", null, null, null }, |
| 34491 | | .dst_constraints = .{.{ .int = .qword }}, |
| 34492 | | .patterns = &.{ |
| 34493 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 34494 | | }, |
| 34495 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 34496 | | .each = .{ .once = &.{ |
| 34497 | | .{ ._, ._, .mov, .dst0q, .leasi(.src0q, .@"8", .src1), ._, ._ }, |
| 34498 | | } }, |
| 34499 | | } }) catch |err| switch (err) { |
| 34500 | | error.SelectFailed => { |
| 34501 | | const elem_size = res_ty.abiSize(zcu); |
| 34502 | | while (true) for (&ops) |*op| { |
| 34503 | | if (try op.toRegClass(true, .general_purpose, cg)) break; |
| 34504 | | } else break; |
| 34505 | | const lhs_reg = ops[0].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 34506 | | const rhs_reg = ops[1].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 34507 | | if (!std.math.isPowerOfTwo(elem_size)) { |
| 34508 | | try cg.spillEflagsIfOccupied(); |
| 34509 | | try cg.asmRegisterRegisterImmediate( |
| 34510 | | .{ .i_, .mul }, |
| 34511 | | rhs_reg, |
| 34512 | | rhs_reg, |
| 34513 | | .u(elem_size), |
| 34514 | | ); |
| 34515 | | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 34516 | | .base = .{ .reg = lhs_reg }, |
| 34517 | | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 34518 | | }); |
| 34519 | | } else if (elem_size > 8) { |
| 34520 | | try cg.spillEflagsIfOccupied(); |
| 34521 | | try cg.asmRegisterImmediate( |
| 34522 | | .{ ._l, .sh }, |
| 34523 | | rhs_reg, |
| 34524 | | .u(std.math.log2_int(u64, elem_size)), |
| 34525 | | ); |
| 34526 | | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 34527 | | .base = .{ .reg = lhs_reg }, |
| 34528 | | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 34529 | | }); |
| 34530 | | } else try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 34531 | | .base = .{ .reg = lhs_reg }, |
| 34532 | | .mod = .{ .rm = .{ |
| 34533 | | .size = .qword, |
| 34534 | | .index = rhs_reg, |
| 34535 | | .scale = .fromFactor(@intCast(elem_size)), |
| 34536 | | } }, |
| 34537 | | }); |
| 34538 | | res[0] = try ops[0].load(res_ty, .{}, cg); |
| 34539 | | }, |
| 34540 | | else => |e| return e, |
| 34541 | | } else { |
| 34542 | | // hack around Sema OPV bugs |
| 34543 | | res[0] = try cg.tempInit(res_ty, .none); |
| 34544 | | } |
| 34545 | | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 34546 | | }, |
| 34547 | | .slice_elem_ptr, .ptr_elem_ptr => |air_tag| if (use_old) switch (air_tag) { |
| 34548 | | else => unreachable, |
| 34549 | | .slice_elem_ptr => try cg.airSliceElemPtr(inst), |
| 34550 | | .ptr_elem_ptr => try cg.airPtrElemPtr(inst), |
| 34551 | | } else { |
| 34552 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 34553 | | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| 34554 | | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 34555 | | try ops[0].toSlicePtr(cg); |
| 34556 | | const dst_ty = ty_pl.ty.toType(); |
| 34557 | | if (dst_ty.ptrInfo(zcu).flags.vector_index == .none) zero_offset: { |
| 34558 | | const elem_size = dst_ty.childType(zcu).abiSize(zcu); |
| 34559 | | // hack around Sema OPV bugs |
| 34560 | | if (elem_size == 0) break :zero_offset; |
| 34561 | | while (true) for (&ops) |*op| { |
| 34562 | | if (try op.toRegClass(true, .general_purpose, cg)) break; |
| 34563 | | } else break; |
| 34564 | | const lhs_reg = ops[0].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 34565 | | const rhs_reg = ops[1].unwrap(cg).temp.tracking(cg).short.register.to64(); |
| 34566 | | if (!std.math.isPowerOfTwo(elem_size)) { |
| 34567 | | try cg.spillEflagsIfOccupied(); |
| 34568 | | try cg.asmRegisterRegisterImmediate( |
| 34569 | | .{ .i_, .mul }, |
| 34570 | | rhs_reg, |
| 34571 | | rhs_reg, |
| 34572 | | .u(elem_size), |
| 34573 | | ); |
| 34574 | | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 34575 | | .base = .{ .reg = lhs_reg }, |
| 34576 | | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 34577 | | }); |
| 34578 | | } else if (elem_size > 8) { |
| 34579 | | try cg.spillEflagsIfOccupied(); |
| 34580 | | try cg.asmRegisterImmediate( |
| 34581 | | .{ ._l, .sh }, |
| 34582 | | rhs_reg, |
| 34583 | | .u(std.math.log2_int(u64, elem_size)), |
| 34584 | | ); |
| 34585 | | try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 34586 | | .base = .{ .reg = lhs_reg }, |
| 34587 | | .mod = .{ .rm = .{ .size = .qword, .index = rhs_reg } }, |
| 34588 | | }); |
| 34589 | | } else try cg.asmRegisterMemory(.{ ._, .lea }, lhs_reg, .{ |
| 34590 | | .base = .{ .reg = lhs_reg }, |
| 34591 | | .mod = .{ .rm = .{ |
| 34592 | | .size = .qword, |
| 34593 | | .index = rhs_reg, |
| 34594 | | .scale = .fromFactor(@intCast(elem_size)), |
| 34595 | | } }, |
| 34596 | | }); |
| 34597 | | } |
| 34598 | | try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 34599 | | }, |
| 34600 | | .array_to_slice => if (use_old) try cg.airArrayToSlice(inst) else { |
| 34601 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 34602 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 34603 | | var len = try cg.tempInit(.usize, .{ |
| 34604 | | .immediate = cg.typeOf(ty_op.operand).childType(zcu).arrayLen(zcu), |
| 34605 | | }); |
| 34606 | | try ops[0].toPair(&len, cg); |
| 34607 | | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 34608 | | }, |
| 34609 | | .error_set_has_value => return cg.fail("TODO implement error_set_has_value", .{}), |
| 34610 | | .union_init => if (use_old) try cg.airUnionInit(inst) else { |
| 34611 | | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 34612 | | const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; |
| 34613 | | const union_ty = ty_pl.ty.toType(); |
| 34614 | | var ops = try cg.tempsFromOperands(inst, .{extra.init}); |
| 34615 | | var res = try cg.tempAllocMem(union_ty); |
| 34616 | | const union_layout = union_ty.unionGetLayout(zcu); |
| 34617 | | if (union_layout.tag_size > 0) { |
| 34618 | | var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex( |
| 34619 | | union_ty.unionTagTypeSafety(zcu).?, |
| 34620 | | extra.field_index, |
| 34621 | | )); |
| 34622 | | try res.write(&tag_temp, .{ |
| 34623 | | .disp = @intCast(union_layout.tagOffset()), |
| 34624 | | }, cg); |
| 34625 | | try tag_temp.die(cg); |
| 34626 | | } |
| 34627 | | try res.write(&ops[0], .{ |
| 34628 | | .disp = @intCast(union_layout.payloadOffset()), |
| 34629 | | }, cg); |
| 34630 | | try res.finish(inst, &.{extra.init}, &ops, cg); |
| 47854 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs, pl_op.operand }, &ops, cg); |
| 34631 | 47855 | }, |
| 34632 | 47856 | .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else { |
| 34633 | 47857 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| ... | ... | @@ -39565,7 +52789,7 @@ fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: bits.RoundM |
| 39565 | 52789 | .param_types = &.{ty.toIntern()}, |
| 39566 | 52790 | .callee = std.fmt.bufPrint(&callee_buf, "{s}{s}{s}", .{ |
| 39567 | 52791 | floatLibcAbiPrefix(ty), |
| 39568 | | switch (mode.mode) { |
| 52792 | switch (mode.direction) { |
| 39569 | 52793 | .down => "floor", |
| 39570 | 52794 | .up => "ceil", |
| 39571 | 52795 | .zero => "trunc", |
| ... | ... | @@ -42209,7 +55433,7 @@ fn genBinOp( |
| 42209 | 55433 | } }, &.{ lhs_ty, rhs_ty }, &.{ adjusted, .{ .air_ref = rhs_air } }, .{}); |
| 42210 | 55434 | }, |
| 42211 | 55435 | .div_trunc, .div_floor => try self.genRoundLibcall(lhs_ty, result, .{ |
| 42212 | | .mode = switch (air_tag) { |
| 55436 | .direction = switch (air_tag) { |
| 42213 | 55437 | .div_trunc => .zero, |
| 42214 | 55438 | .div_floor => .down, |
| 42215 | 55439 | else => unreachable, |
| ... | ... | @@ -42667,7 +55891,7 @@ fn genBinOp( |
| 42667 | 55891 | dst_reg, |
| 42668 | 55892 | dst_reg, |
| 42669 | 55893 | bits.RoundMode.imm(.{ |
| 42670 | | .mode = switch (air_tag) { |
| 55894 | .direction = switch (air_tag) { |
| 42671 | 55895 | .div_trunc => .zero, |
| 42672 | 55896 | .div_floor => .down, |
| 42673 | 55897 | else => unreachable, |
| ... | ... | @@ -43469,7 +56693,7 @@ fn genBinOp( |
| 43469 | 56693 | switch (air_tag) { |
| 43470 | 56694 | .add, .add_wrap, .sub, .sub_wrap, .mul, .mul_wrap, .div_float, .div_exact => {}, |
| 43471 | 56695 | .div_trunc, .div_floor => try self.genRound(lhs_ty, dst_reg, .{ .register = dst_reg }, .{ |
| 43472 | | .mode = switch (air_tag) { |
| 56696 | .direction = switch (air_tag) { |
| 43473 | 56697 | .div_trunc => .zero, |
| 43474 | 56698 | .div_floor => .down, |
| 43475 | 56699 | else => unreachable, |
| ... | ... | @@ -51237,10 +64461,17 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 51237 | 64461 | const acc_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 51238 | 64462 | const acc_lock = self.register_manager.lockRegAssumeUnused(acc_reg); |
| 51239 | 64463 | defer self.register_manager.unlockReg(acc_lock); |
| 51240 | | var limb_offset: i31 = 0; |
| 51241 | | while (limb_offset < abi_size) : (limb_offset += 8) { |
| 64464 | var limb_offset: i31 = @intCast((mask_len - 1) / 64 * 8); |
| 64465 | const need_mask = mask_len % 64 != 0; |
| 64466 | if (need_mask) try self.asmRegisterImmediate( |
| 64467 | .{ ._, .mov }, |
| 64468 | if (mask_len % 64 <= 32) acc_reg.to32() else acc_reg.to64(), |
| 64469 | .u((@as(u64, std.math.maxInt(u64)) >> @truncate(-%mask_len))), |
| 64470 | ); |
| 64471 | var first = true; |
| 64472 | while (true) : (limb_offset -= 8) { |
| 51242 | 64473 | try self.asmRegisterMemory( |
| 51243 | | .{ ._, if (limb_offset == 0) .mov else switch (reduce.operation) { |
| 64474 | .{ ._, if (first) if (need_mask) .@"and" else .mov else switch (reduce.operation) { |
| 51244 | 64475 | .Or => .@"or", |
| 51245 | 64476 | .And => .@"and", |
| 51246 | 64477 | else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), |
| ... | ... | @@ -51251,6 +64482,8 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 51251 | 64482 | .disp = limb_offset, |
| 51252 | 64483 | }), |
| 51253 | 64484 | ); |
| 64485 | if (limb_offset == 0) break; |
| 64486 | first = false; |
| 51254 | 64487 | } |
| 51255 | 64488 | switch (reduce.operation) { |
| 51256 | 64489 | .Or => { |
| ... | ... | @@ -53741,11 +66974,11 @@ const Temp = struct { |
| 53741 | 66974 | }; |
| 53742 | 66975 | if (commute) std.mem.swap(Temp, &ops[0], &ops[1]); |
| 53743 | 66976 | try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ |
| 53744 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, |
| 66977 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 53745 | 66978 | .patterns = &.{ |
| 53746 | | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, |
| 53747 | | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53748 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 66979 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 66980 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 66981 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53749 | 66982 | }, |
| 53750 | 66983 | .dst_temps = .{.{ .cc = .g }}, |
| 53751 | 66984 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53753,12 +66986,12 @@ const Temp = struct { |
| 53753 | 66986 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 53754 | 66987 | } }, |
| 53755 | 66988 | }, .{ |
| 53756 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, |
| 66989 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 53757 | 66990 | .patterns = &.{ |
| 53758 | | .{ .src = .{ .mem, .imm8 } }, |
| 53759 | | .{ .src = .{ .to_gpr, .imm8 } }, |
| 53760 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53761 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 66991 | .{ .src = .{ .mem, .imm8, .none } }, |
| 66992 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 66993 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 66994 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53762 | 66995 | }, |
| 53763 | 66996 | .dst_temps = .{.{ .cc = .l }}, |
| 53764 | 66997 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53766,11 +66999,11 @@ const Temp = struct { |
| 53766 | 66999 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 53767 | 67000 | } }, |
| 53768 | 67001 | }, .{ |
| 53769 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, |
| 67002 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 53770 | 67003 | .patterns = &.{ |
| 53771 | | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, |
| 53772 | | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53773 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67004 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67005 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67006 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53774 | 67007 | }, |
| 53775 | 67008 | .dst_temps = .{.{ .cc = .a }}, |
| 53776 | 67009 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53778,12 +67011,12 @@ const Temp = struct { |
| 53778 | 67011 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 53779 | 67012 | } }, |
| 53780 | 67013 | }, .{ |
| 53781 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, |
| 67014 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 53782 | 67015 | .patterns = &.{ |
| 53783 | | .{ .src = .{ .mem, .imm8 } }, |
| 53784 | | .{ .src = .{ .to_gpr, .imm8 } }, |
| 53785 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53786 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67016 | .{ .src = .{ .mem, .imm8, .none } }, |
| 67017 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 67018 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67019 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53787 | 67020 | }, |
| 53788 | 67021 | .dst_temps = .{.{ .cc = .b }}, |
| 53789 | 67022 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53791,11 +67024,11 @@ const Temp = struct { |
| 53791 | 67024 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 53792 | 67025 | } }, |
| 53793 | 67026 | }, .{ |
| 53794 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, |
| 67027 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 53795 | 67028 | .patterns = &.{ |
| 53796 | | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, |
| 53797 | | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53798 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67029 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67030 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67031 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53799 | 67032 | }, |
| 53800 | 67033 | .dst_temps = .{.{ .cc = .g }}, |
| 53801 | 67034 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53803,12 +67036,12 @@ const Temp = struct { |
| 53803 | 67036 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 53804 | 67037 | } }, |
| 53805 | 67038 | }, .{ |
| 53806 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, |
| 67039 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 53807 | 67040 | .patterns = &.{ |
| 53808 | | .{ .src = .{ .mem, .imm16 } }, |
| 53809 | | .{ .src = .{ .to_gpr, .imm16 } }, |
| 53810 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53811 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67041 | .{ .src = .{ .mem, .imm16, .none } }, |
| 67042 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| 67043 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67044 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53812 | 67045 | }, |
| 53813 | 67046 | .dst_temps = .{.{ .cc = .l }}, |
| 53814 | 67047 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53816,11 +67049,11 @@ const Temp = struct { |
| 53816 | 67049 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 53817 | 67050 | } }, |
| 53818 | 67051 | }, .{ |
| 53819 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, |
| 67052 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 53820 | 67053 | .patterns = &.{ |
| 53821 | | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, |
| 53822 | | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53823 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67054 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67055 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67056 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53824 | 67057 | }, |
| 53825 | 67058 | .dst_temps = .{.{ .cc = .a }}, |
| 53826 | 67059 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53828,12 +67061,12 @@ const Temp = struct { |
| 53828 | 67061 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 53829 | 67062 | } }, |
| 53830 | 67063 | }, .{ |
| 53831 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, |
| 67064 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 53832 | 67065 | .patterns = &.{ |
| 53833 | | .{ .src = .{ .mem, .imm16 } }, |
| 53834 | | .{ .src = .{ .to_gpr, .imm16 } }, |
| 53835 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53836 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67066 | .{ .src = .{ .mem, .imm16, .none } }, |
| 67067 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| 67068 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67069 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53837 | 67070 | }, |
| 53838 | 67071 | .dst_temps = .{.{ .cc = .b }}, |
| 53839 | 67072 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53841,11 +67074,11 @@ const Temp = struct { |
| 53841 | 67074 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 53842 | 67075 | } }, |
| 53843 | 67076 | }, .{ |
| 53844 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, |
| 67077 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 53845 | 67078 | .patterns = &.{ |
| 53846 | | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, |
| 53847 | | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53848 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67079 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67080 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67081 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53849 | 67082 | }, |
| 53850 | 67083 | .dst_temps = .{.{ .cc = .g }}, |
| 53851 | 67084 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53853,12 +67086,12 @@ const Temp = struct { |
| 53853 | 67086 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 53854 | 67087 | } }, |
| 53855 | 67088 | }, .{ |
| 53856 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, |
| 67089 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 53857 | 67090 | .patterns = &.{ |
| 53858 | | .{ .src = .{ .mem, .imm32 } }, |
| 53859 | | .{ .src = .{ .to_gpr, .imm32 } }, |
| 53860 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53861 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67091 | .{ .src = .{ .mem, .imm32, .none } }, |
| 67092 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| 67093 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67094 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53862 | 67095 | }, |
| 53863 | 67096 | .dst_temps = .{.{ .cc = .l }}, |
| 53864 | 67097 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53866,11 +67099,11 @@ const Temp = struct { |
| 53866 | 67099 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 53867 | 67100 | } }, |
| 53868 | 67101 | }, .{ |
| 53869 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, |
| 67102 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 53870 | 67103 | .patterns = &.{ |
| 53871 | | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, |
| 53872 | | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53873 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67104 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67105 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67106 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53874 | 67107 | }, |
| 53875 | 67108 | .dst_temps = .{.{ .cc = .a }}, |
| 53876 | 67109 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53878,12 +67111,12 @@ const Temp = struct { |
| 53878 | 67111 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, |
| 53879 | 67112 | } }, |
| 53880 | 67113 | }, .{ |
| 53881 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, |
| 67114 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 53882 | 67115 | .patterns = &.{ |
| 53883 | | .{ .src = .{ .mem, .imm32 } }, |
| 53884 | | .{ .src = .{ .to_gpr, .imm32 } }, |
| 53885 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53886 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67116 | .{ .src = .{ .mem, .imm32, .none } }, |
| 67117 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| 67118 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67119 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53887 | 67120 | }, |
| 53888 | 67121 | .dst_temps = .{.{ .cc = .b }}, |
| 53889 | 67122 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53892,11 +67125,11 @@ const Temp = struct { |
| 53892 | 67125 | } }, |
| 53893 | 67126 | }, .{ |
| 53894 | 67127 | .required_features = .{ .@"64bit", null, null, null }, |
| 53895 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, |
| 67128 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 53896 | 67129 | .patterns = &.{ |
| 53897 | | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, |
| 53898 | | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53899 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67130 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67131 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67132 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53900 | 67133 | }, |
| 53901 | 67134 | .dst_temps = .{.{ .cc = .g }}, |
| 53902 | 67135 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53905,12 +67138,12 @@ const Temp = struct { |
| 53905 | 67138 | } }, |
| 53906 | 67139 | }, .{ |
| 53907 | 67140 | .required_features = .{ .@"64bit", null, null, null }, |
| 53908 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, |
| 67141 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 53909 | 67142 | .patterns = &.{ |
| 53910 | | .{ .src = .{ .mem, .simm32 } }, |
| 53911 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 53912 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53913 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67143 | .{ .src = .{ .mem, .simm32, .none } }, |
| 67144 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 67145 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67146 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53914 | 67147 | }, |
| 53915 | 67148 | .dst_temps = .{.{ .cc = .l }}, |
| 53916 | 67149 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53919,11 +67152,11 @@ const Temp = struct { |
| 53919 | 67152 | } }, |
| 53920 | 67153 | }, .{ |
| 53921 | 67154 | .required_features = .{ .@"64bit", null, null, null }, |
| 53922 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, |
| 67155 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 53923 | 67156 | .patterns = &.{ |
| 53924 | | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, |
| 53925 | | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 53926 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 67157 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67158 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67159 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53927 | 67160 | }, |
| 53928 | 67161 | .dst_temps = .{.{ .cc = .a }}, |
| 53929 | 67162 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53932,12 +67165,12 @@ const Temp = struct { |
| 53932 | 67165 | } }, |
| 53933 | 67166 | }, .{ |
| 53934 | 67167 | .required_features = .{ .@"64bit", null, null, null }, |
| 53935 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, |
| 67168 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 53936 | 67169 | .patterns = &.{ |
| 53937 | | .{ .src = .{ .mem, .simm32 } }, |
| 53938 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 53939 | | .{ .src = .{ .to_gpr, .mem } }, |
| 53940 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67170 | .{ .src = .{ .mem, .simm32, .none } }, |
| 67171 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 67172 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67173 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53941 | 67174 | }, |
| 53942 | 67175 | .dst_temps = .{.{ .cc = .b }}, |
| 53943 | 67176 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -53949,9 +67182,10 @@ const Temp = struct { |
| 53949 | 67182 | .src_constraints = .{ |
| 53950 | 67183 | .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, |
| 53951 | 67184 | .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, |
| 67185 | .any, |
| 53952 | 67186 | }, |
| 53953 | 67187 | .patterns = &.{ |
| 53954 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67188 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 53955 | 67189 | }, |
| 53956 | 67190 | .extra_temps = .{ |
| 53957 | 67191 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -53981,9 +67215,10 @@ const Temp = struct { |
| 53981 | 67215 | .src_constraints = .{ |
| 53982 | 67216 | .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 53983 | 67217 | .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 67218 | .any, |
| 53984 | 67219 | }, |
| 53985 | 67220 | .patterns = &.{ |
| 53986 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67221 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 53987 | 67222 | }, |
| 53988 | 67223 | .extra_temps = .{ |
| 53989 | 67224 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54010,9 +67245,10 @@ const Temp = struct { |
| 54010 | 67245 | .src_constraints = .{ |
| 54011 | 67246 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 54012 | 67247 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 67248 | .any, |
| 54013 | 67249 | }, |
| 54014 | 67250 | .patterns = &.{ |
| 54015 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67251 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54016 | 67252 | }, |
| 54017 | 67253 | .extra_temps = .{ |
| 54018 | 67254 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54041,9 +67277,10 @@ const Temp = struct { |
| 54041 | 67277 | .src_constraints = .{ |
| 54042 | 67278 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 54043 | 67279 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 67280 | .any, |
| 54044 | 67281 | }, |
| 54045 | 67282 | .patterns = &.{ |
| 54046 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67283 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54047 | 67284 | }, |
| 54048 | 67285 | .extra_temps = .{ |
| 54049 | 67286 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54071,15 +67308,15 @@ const Temp = struct { |
| 54071 | 67308 | }, |
| 54072 | 67309 | .eq, .neq => { |
| 54073 | 67310 | try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ |
| 54074 | | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, |
| 67311 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte }, .any }, |
| 54075 | 67312 | .patterns = &.{ |
| 54076 | | .{ .src = .{ .mem, .imm8 } }, |
| 54077 | | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, |
| 54078 | | .{ .src = .{ .to_gpr, .imm8 } }, |
| 54079 | | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54080 | | .{ .src = .{ .to_gpr, .mem } }, |
| 54081 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54082 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67313 | .{ .src = .{ .mem, .imm8, .none } }, |
| 67314 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67315 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 67316 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67317 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67318 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67319 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54083 | 67320 | }, |
| 54084 | 67321 | .dst_temps = .{.{ .cc = .e }}, |
| 54085 | 67322 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -54087,15 +67324,15 @@ const Temp = struct { |
| 54087 | 67324 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 54088 | 67325 | } }, |
| 54089 | 67326 | }, .{ |
| 54090 | | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, |
| 67327 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any }, |
| 54091 | 67328 | .patterns = &.{ |
| 54092 | | .{ .src = .{ .mem, .imm16 } }, |
| 54093 | | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, |
| 54094 | | .{ .src = .{ .to_gpr, .imm16 } }, |
| 54095 | | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54096 | | .{ .src = .{ .to_gpr, .mem } }, |
| 54097 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54098 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67329 | .{ .src = .{ .mem, .imm16, .none } }, |
| 67330 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67331 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| 67332 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67333 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67334 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67335 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54099 | 67336 | }, |
| 54100 | 67337 | .dst_temps = .{.{ .cc = .e }}, |
| 54101 | 67338 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -54103,15 +67340,15 @@ const Temp = struct { |
| 54103 | 67340 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 54104 | 67341 | } }, |
| 54105 | 67342 | }, .{ |
| 54106 | | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, |
| 67343 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any }, |
| 54107 | 67344 | .patterns = &.{ |
| 54108 | | .{ .src = .{ .mem, .imm32 } }, |
| 54109 | | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, |
| 54110 | | .{ .src = .{ .to_gpr, .imm32 } }, |
| 54111 | | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54112 | | .{ .src = .{ .to_gpr, .mem } }, |
| 54113 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54114 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67345 | .{ .src = .{ .mem, .imm32, .none } }, |
| 67346 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67347 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| 67348 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67349 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67350 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67351 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54115 | 67352 | }, |
| 54116 | 67353 | .dst_temps = .{.{ .cc = .e }}, |
| 54117 | 67354 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -54120,15 +67357,15 @@ const Temp = struct { |
| 54120 | 67357 | } }, |
| 54121 | 67358 | }, .{ |
| 54122 | 67359 | .required_features = .{ .@"64bit", null, null, null }, |
| 54123 | | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, |
| 67360 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any }, |
| 54124 | 67361 | .patterns = &.{ |
| 54125 | | .{ .src = .{ .mem, .simm32 } }, |
| 54126 | | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, |
| 54127 | | .{ .src = .{ .to_gpr, .simm32 } }, |
| 54128 | | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54129 | | .{ .src = .{ .to_gpr, .mem } }, |
| 54130 | | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, |
| 54131 | | .{ .src = .{ .to_gpr, .to_gpr } }, |
| 67362 | .{ .src = .{ .mem, .simm32, .none } }, |
| 67363 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 67364 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 67365 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67366 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 67367 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 67368 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54132 | 67369 | }, |
| 54133 | 67370 | .dst_temps = .{.{ .cc = .e }}, |
| 54134 | 67371 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -54137,11 +67374,11 @@ const Temp = struct { |
| 54137 | 67374 | } }, |
| 54138 | 67375 | }, .{ |
| 54139 | 67376 | .required_features = .{ .sse, .mmx, null, null }, |
| 54140 | | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, |
| 67377 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any }, |
| 54141 | 67378 | .patterns = &.{ |
| 54142 | | .{ .src = .{ .to_mut_mm, .mem } }, |
| 54143 | | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, |
| 54144 | | .{ .src = .{ .to_mut_mm, .to_mm } }, |
| 67379 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 67380 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 67381 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 54145 | 67382 | }, |
| 54146 | 67383 | .extra_temps = .{ |
| 54147 | 67384 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54165,11 +67402,11 @@ const Temp = struct { |
| 54165 | 67402 | } }, |
| 54166 | 67403 | }, .{ |
| 54167 | 67404 | .required_features = .{ .avx, null, null, null }, |
| 54168 | | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 67405 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54169 | 67406 | .patterns = &.{ |
| 54170 | | .{ .src = .{ .to_xmm, .mem } }, |
| 54171 | | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, |
| 54172 | | .{ .src = .{ .to_xmm, .to_xmm } }, |
| 67407 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 67408 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 67409 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 54173 | 67410 | }, |
| 54174 | 67411 | .extra_temps = .{ |
| 54175 | 67412 | .{ .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -54190,11 +67427,11 @@ const Temp = struct { |
| 54190 | 67427 | } }, |
| 54191 | 67428 | }, .{ |
| 54192 | 67429 | .required_features = .{ .sse4_1, null, null, null }, |
| 54193 | | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 67430 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54194 | 67431 | .patterns = &.{ |
| 54195 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 54196 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 54197 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 67432 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 67433 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 67434 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 54198 | 67435 | }, |
| 54199 | 67436 | .dst_temps = .{.{ .cc = .z }}, |
| 54200 | 67437 | .clobbers = .{ .eflags = true }, |
| ... | ... | @@ -54204,11 +67441,11 @@ const Temp = struct { |
| 54204 | 67441 | } }, |
| 54205 | 67442 | }, .{ |
| 54206 | 67443 | .required_features = .{ .sse2, .fast_imm16, null, null }, |
| 54207 | | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 67444 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54208 | 67445 | .patterns = &.{ |
| 54209 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 54210 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 54211 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 67446 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 67447 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 67448 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 54212 | 67449 | }, |
| 54213 | 67450 | .extra_temps = .{ |
| 54214 | 67451 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54232,11 +67469,11 @@ const Temp = struct { |
| 54232 | 67469 | } }, |
| 54233 | 67470 | }, .{ |
| 54234 | 67471 | .required_features = .{ .sse2, null, null, null }, |
| 54235 | | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, |
| 67472 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54236 | 67473 | .patterns = &.{ |
| 54237 | | .{ .src = .{ .to_mut_xmm, .mem } }, |
| 54238 | | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, |
| 54239 | | .{ .src = .{ .to_mut_xmm, .to_xmm } }, |
| 67474 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 67475 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 67476 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 54240 | 67477 | }, |
| 54241 | 67478 | .extra_temps = .{ |
| 54242 | 67479 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54260,11 +67497,11 @@ const Temp = struct { |
| 54260 | 67497 | } }, |
| 54261 | 67498 | }, .{ |
| 54262 | 67499 | .required_features = .{ .avx2, null, null, null }, |
| 54263 | | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword } }, |
| 67500 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword }, .any }, |
| 54264 | 67501 | .patterns = &.{ |
| 54265 | | .{ .src = .{ .to_ymm, .mem } }, |
| 54266 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 54267 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 67502 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 67503 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 67504 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 54268 | 67505 | }, |
| 54269 | 67506 | .extra_temps = .{ |
| 54270 | 67507 | .{ .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -54285,11 +67522,11 @@ const Temp = struct { |
| 54285 | 67522 | } }, |
| 54286 | 67523 | }, .{ |
| 54287 | 67524 | .required_features = .{ .avx, null, null, null }, |
| 54288 | | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword } }, |
| 67525 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword }, .any }, |
| 54289 | 67526 | .patterns = &.{ |
| 54290 | | .{ .src = .{ .to_ymm, .mem } }, |
| 54291 | | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, |
| 54292 | | .{ .src = .{ .to_ymm, .to_ymm } }, |
| 67527 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 67528 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 67529 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 54293 | 67530 | }, |
| 54294 | 67531 | .extra_temps = .{ |
| 54295 | 67532 | .{ .kind = .{ .rc = .sse } }, |
| ... | ... | @@ -54313,9 +67550,10 @@ const Temp = struct { |
| 54313 | 67550 | .src_constraints = .{ |
| 54314 | 67551 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| 54315 | 67552 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| 67553 | .any, |
| 54316 | 67554 | }, |
| 54317 | 67555 | .patterns = &.{ |
| 54318 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67556 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54319 | 67557 | }, |
| 54320 | 67558 | .extra_temps = .{ |
| 54321 | 67559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54347,9 +67585,10 @@ const Temp = struct { |
| 54347 | 67585 | .src_constraints = .{ |
| 54348 | 67586 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| 54349 | 67587 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| 67588 | .any, |
| 54350 | 67589 | }, |
| 54351 | 67590 | .patterns = &.{ |
| 54352 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67591 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54353 | 67592 | }, |
| 54354 | 67593 | .extra_temps = .{ |
| 54355 | 67594 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54381,9 +67620,10 @@ const Temp = struct { |
| 54381 | 67620 | .src_constraints = .{ |
| 54382 | 67621 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| 54383 | 67622 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| 67623 | .any, |
| 54384 | 67624 | }, |
| 54385 | 67625 | .patterns = &.{ |
| 54386 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67626 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54387 | 67627 | }, |
| 54388 | 67628 | .extra_temps = .{ |
| 54389 | 67629 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54412,9 +67652,10 @@ const Temp = struct { |
| 54412 | 67652 | .src_constraints = .{ |
| 54413 | 67653 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| 54414 | 67654 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| 67655 | .any, |
| 54415 | 67656 | }, |
| 54416 | 67657 | .patterns = &.{ |
| 54417 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67658 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54418 | 67659 | }, |
| 54419 | 67660 | .extra_temps = .{ |
| 54420 | 67661 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54443,9 +67684,10 @@ const Temp = struct { |
| 54443 | 67684 | .src_constraints = .{ |
| 54444 | 67685 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54445 | 67686 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 67687 | .any, |
| 54446 | 67688 | }, |
| 54447 | 67689 | .patterns = &.{ |
| 54448 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67690 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54449 | 67691 | }, |
| 54450 | 67692 | .extra_temps = .{ |
| 54451 | 67693 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54474,9 +67716,10 @@ const Temp = struct { |
| 54474 | 67716 | .src_constraints = .{ |
| 54475 | 67717 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54476 | 67718 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 67719 | .any, |
| 54477 | 67720 | }, |
| 54478 | 67721 | .patterns = &.{ |
| 54479 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67722 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54480 | 67723 | }, |
| 54481 | 67724 | .extra_temps = .{ |
| 54482 | 67725 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54505,9 +67748,10 @@ const Temp = struct { |
| 54505 | 67748 | .src_constraints = .{ |
| 54506 | 67749 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54507 | 67750 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 67751 | .any, |
| 54508 | 67752 | }, |
| 54509 | 67753 | .patterns = &.{ |
| 54510 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67754 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54511 | 67755 | }, |
| 54512 | 67756 | .extra_temps = .{ |
| 54513 | 67757 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54537,9 +67781,10 @@ const Temp = struct { |
| 54537 | 67781 | .src_constraints = .{ |
| 54538 | 67782 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54539 | 67783 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 67784 | .any, |
| 54540 | 67785 | }, |
| 54541 | 67786 | .patterns = &.{ |
| 54542 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67787 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54543 | 67788 | }, |
| 54544 | 67789 | .extra_temps = .{ |
| 54545 | 67790 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54569,9 +67814,10 @@ const Temp = struct { |
| 54569 | 67814 | .src_constraints = .{ |
| 54570 | 67815 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| 54571 | 67816 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| 67817 | .any, |
| 54572 | 67818 | }, |
| 54573 | 67819 | .patterns = &.{ |
| 54574 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67820 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54575 | 67821 | }, |
| 54576 | 67822 | .extra_temps = .{ |
| 54577 | 67823 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54601,9 +67847,10 @@ const Temp = struct { |
| 54601 | 67847 | .src_constraints = .{ |
| 54602 | 67848 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| 54603 | 67849 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| 67850 | .any, |
| 54604 | 67851 | }, |
| 54605 | 67852 | .patterns = &.{ |
| 54606 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67853 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54607 | 67854 | }, |
| 54608 | 67855 | .extra_temps = .{ |
| 54609 | 67856 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -54630,9 +67877,10 @@ const Temp = struct { |
| 54630 | 67877 | .src_constraints = .{ |
| 54631 | 67878 | .{ .remainder_int = .{ .of = .dword, .is = .dword } }, |
| 54632 | 67879 | .{ .remainder_int = .{ .of = .dword, .is = .dword } }, |
| 67880 | .any, |
| 54633 | 67881 | }, |
| 54634 | 67882 | .patterns = &.{ |
| 54635 | | .{ .src = .{ .to_mem, .to_mem } }, |
| 67883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54636 | 67884 | }, |
| 54637 | 67885 | .extra_temps = .{ |
| 54638 | 67886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | ... | @@ -55344,7 +68592,7 @@ const Select = struct { |
| 55344 | 68592 | }; |
| 55345 | 68593 | |
| 55346 | 68594 | const Pattern = struct { |
| 55347 | | src: [2]Src, |
| 68595 | src: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Src, |
| 55348 | 68596 | commute: struct { u8, u8 } = .{ 0, 0 }, |
| 55349 | 68597 | |
| 55350 | 68598 | const Src = union(enum) { |
| ... | ... | @@ -55781,6 +69029,7 @@ const Select = struct { |
| 55781 | 69029 | dst0, |
| 55782 | 69030 | src0, |
| 55783 | 69031 | src1, |
| 69032 | src2, |
| 55784 | 69033 | none, |
| 55785 | 69034 | |
| 55786 | 69035 | const Sized = packed struct(u8) { |
| ... | ... | @@ -55920,6 +69169,17 @@ const Select = struct { |
| 55920 | 69169 | const src1t: Sized = .{ .ref = .src1, .size = .tbyte }; |
| 55921 | 69170 | const src1x: Sized = .{ .ref = .src1, .size = .xword }; |
| 55922 | 69171 | const src1y: Sized = .{ .ref = .src1, .size = .yword }; |
| 69172 | |
| 69173 | const src2: Sized = .{ .ref = .src2, .size = .none }; |
| 69174 | const src2b: Sized = .{ .ref = .src2, .size = .byte }; |
| 69175 | const src2w: Sized = .{ .ref = .src2, .size = .word }; |
| 69176 | const src2d: Sized = .{ .ref = .src2, .size = .dword }; |
| 69177 | const src2p: Sized = .{ .ref = .src2, .size = .ptr }; |
| 69178 | const src2g: Sized = .{ .ref = .src2, .size = .gpr }; |
| 69179 | const src2q: Sized = .{ .ref = .src2, .size = .qword }; |
| 69180 | const src2t: Sized = .{ .ref = .src2, .size = .tbyte }; |
| 69181 | const src2x: Sized = .{ .ref = .src2, .size = .xword }; |
| 69182 | const src2y: Sized = .{ .ref = .src2, .size = .yword }; |
| 55923 | 69183 | }; |
| 55924 | 69184 | |
| 55925 | 69185 | fn typeOf(ref: Ref, s: *const Select) Type { |
| ... | ... | @@ -56064,6 +69324,16 @@ const Select = struct { |
| 56064 | 69324 | const src1x: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src1x }; |
| 56065 | 69325 | const src1y: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src1y }; |
| 56066 | 69326 | |
| 69327 | const src2b: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2b }; |
| 69328 | const src2w: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2w }; |
| 69329 | const src2d: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2d }; |
| 69330 | const src2p: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2p }; |
| 69331 | const src2g: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2g }; |
| 69332 | const src2q: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2q }; |
| 69333 | const src2t: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2t }; |
| 69334 | const src2x: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2x }; |
| 69335 | const src2y: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src2y }; |
| 69336 | |
| 56067 | 69337 | fn si(imm: i32) Select.Operand { |
| 56068 | 69338 | return .{ .flags = .{ .tag = .simm }, .imm = imm }; |
| 56069 | 69339 | } |
Jacob Young <jacobly@ziglang.org> 2025-02-04 06:33:36-05:00
src