| ... | @@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2414 | } | 2414 | } |
| 2415 | | 2415 | |
| 2416 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2416 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2417 | @setEvalBranchQuota(5_500); | 2417 | @setEvalBranchQuota(9_200); |
| 2418 | const pt = cg.pt; | 2418 | const pt = cg.pt; |
| 2419 | const zcu = pt.zcu; | 2419 | const zcu = pt.zcu; |
| 2420 | const ip = &zcu.intern_pool; | 2420 | const ip = &zcu.intern_pool; |
| ... | @@ -2450,23 +2450,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2450,23 +2450,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2450 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); | 2450 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); |
| 2451 | switch (air_tags[@intFromEnum(inst)]) { | 2451 | switch (air_tags[@intFromEnum(inst)]) { |
| 2452 | // zig fmt: off | 2452 | // zig fmt: off |
| 2453 | .add, | | |
| 2454 | .add_wrap, | 2453 | .add_wrap, |
| 2455 | .sub, | | |
| 2456 | .sub_wrap, | 2454 | .sub_wrap, |
| 2457 | => |air_tag| try cg.airBinOp(inst, air_tag), | 2455 | => |air_tag| try cg.airBinOp(inst, air_tag), |
| 2458 | | 2456 | |
| 2459 | .shr, .shr_exact => try cg.airShlShrBinOp(inst), | 2457 | .shr, .shr_exact => try cg.airShlShrBinOp(inst), |
| 2460 | .shl, .shl_exact => try cg.airShlShrBinOp(inst), | 2458 | .shl, .shl_exact => try cg.airShlShrBinOp(inst), |
| 2461 | | 2459 | |
| 2462 | .mul, | | |
| 2463 | .mul_wrap, | 2460 | .mul_wrap, |
| 2464 | .rem, | | |
| 2465 | .mod, | 2461 | .mod, |
| 2466 | .div_float, | | |
| 2467 | .div_trunc, | | |
| 2468 | .div_floor, | | |
| 2469 | .div_exact, | | |
| 2470 | => |air_tag| try cg.airMulDivBinOp(inst, air_tag), | 2462 | => |air_tag| try cg.airMulDivBinOp(inst, air_tag), |
| 2471 | | 2463 | |
| 2472 | .add_sat => try cg.airAddSat(inst), | 2464 | .add_sat => try cg.airAddSat(inst), |
| ... | @@ -2474,23 +2466,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2474,23 +2466,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2474 | .mul_sat => try cg.airMulSat(inst), | 2466 | .mul_sat => try cg.airMulSat(inst), |
| 2475 | .shl_sat => try cg.airShlSat(inst), | 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 | .add_with_overflow => try cg.airAddSubWithOverflow(inst), | 2469 | .add_with_overflow => try cg.airAddSubWithOverflow(inst), |
| 2495 | .sub_with_overflow => try cg.airAddSubWithOverflow(inst), | 2470 | .sub_with_overflow => try cg.airAddSubWithOverflow(inst), |
| 2496 | .mul_with_overflow => try cg.airMulWithOverflow(inst), | 2471 | .mul_with_overflow => try cg.airMulWithOverflow(inst), |
| ... | @@ -2524,7 +2499,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2524,7 +2499,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2524 | .reduce => try cg.airReduce(inst), | 2499 | .reduce => try cg.airReduce(inst), |
| 2525 | .aggregate_init => try cg.airAggregateInit(inst), | 2500 | .aggregate_init => try cg.airAggregateInit(inst), |
| 2526 | .prefetch => try cg.airPrefetch(inst), | 2501 | .prefetch => try cg.airPrefetch(inst), |
| 2527 | .mul_add => try cg.airMulAdd(inst), | | |
| 2528 | | 2502 | |
| 2529 | .atomic_store_unordered => try cg.airAtomicStore(inst, .unordered), | 2503 | .atomic_store_unordered => try cg.airAtomicStore(inst, .unordered), |
| 2530 | .atomic_store_monotonic => try cg.airAtomicStore(inst, .monotonic), | 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,16 +2522,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2548 | .intcast_safe, | 2522 | .intcast_safe, |
| 2549 | => return cg.fail("TODO implement safety_checked_instructions", .{}), | 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 | .mod_optimized => try cg.airMulDivBinOp(inst, .mod), | 2525 | .mod_optimized => try cg.airMulDivBinOp(inst, .mod), |
| 2560 | .neg_optimized => try cg.airFloatSign(inst, .neg), | | |
| 2561 | .reduce_optimized => try cg.airReduce(inst), | 2526 | .reduce_optimized => try cg.airReduce(inst), |
| 2562 | .int_from_float_optimized => try cg.airIntFromFloat(inst), | 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,490 +2540,661 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2575 | if (arg != .none) break; | 2540 | if (arg != .none) break; |
| 2576 | } else try cg.airDbgVarArgs(); | 2541 | } else try cg.airDbgVarArgs(); |
| 2577 | }, | 2542 | }, |
| 2578 | .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { | 2543 | .add, .add_optimized => |air_tag| if (use_old) try cg.airBinOp(inst, .add) else fallback: { |
| 2579 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 2544 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 2580 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; | 2545 | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airBinOp(inst, air_tag); |
| 2581 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 2546 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 2582 | try ops[0].toSlicePtr(cg); | | |
| 2583 | var res: [1]Temp = undefined; | 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 &.{ .{ | 2548 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 2585 | .patterns = &.{ | 2549 | .required_features = .{ .f16c, null, null, null }, |
| 2586 | .{ .src = .{ .to_gpr, .simm32 } }, | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 2628 | .each = .{ .once = &.{ |
| 2617 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ }, | 2629 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 2618 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 2688 | .each = .{ .once = &.{ |
| 2636 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, | 2689 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2637 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, | 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 }, | 2698 | .required_features = .{ .avx, null, null, null }, |
| 2641 | .dst_constraints = .{.{ .elem_size_is = 8 }}, | 2699 | .src_constraints = .{ |
| | 2700 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 2701 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 2702 | .any, |
| | 2703 | }, |
| 2642 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 }, | 2732 | .required_features = .{ .sse4_1, null, null, null }, |
| 2651 | .dst_constraints = .{.{ .elem_size_is = 8 + 1 }}, | 2733 | .src_constraints = .{ |
| | 2734 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 2735 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 2736 | .any, |
| | 2737 | }, |
| 2652 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 2755 | .each = .{ .once = &.{ |
| 2657 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, | 2756 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2658 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, | 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 | .patterns = &.{ | 2773 | .patterns = &.{ |
| 2663 | .{ .src = .{ .to_gpr, .to_mut_gpr } }, | 2774 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2664 | }, | 2775 | }, |
| 2665 | .dst_temps = .{.{ .ref = .src1 }}, | 2776 | .call_frame = .{ .alignment = .@"16" }, |
| 2666 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 2790 | .each = .{ .once = &.{ |
| 2668 | .{ ._, ._l, .sh, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ }, | 2791 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2669 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, | 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 = &.{ | 2803 | .required_features = .{ .sse, null, null, null }, |
| 2673 | .{ .src = .{ .to_gpr, .to_gpr } }, | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .patterns = &.{ | 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 }}, | 2853 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2714 | .clobbers = .{ .eflags = true }, | | |
| 2715 | .each = .{ .once = &.{ | 2854 | .each = .{ .once = &.{ |
| 2716 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, | 2855 | .{ ._, .v_ss, .add, .dst0x, .src0x, .src1d, ._ }, |
| 2717 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, | | |
| 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 | .patterns = &.{ | 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 }}, | 2869 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2725 | .clobbers = .{ .eflags = true }, | | |
| 2726 | .each = .{ .once = &.{ | 2870 | .each = .{ .once = &.{ |
| 2727 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, | 2871 | .{ ._, ._ss, .add, .dst0x, .src1d, ._, ._ }, |
| 2728 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"2", .src1), ._, ._ }, | | |
| 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 | .patterns = &.{ | 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 }}, | 2885 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2736 | .clobbers = .{ .eflags = true }, | | |
| 2737 | .each = .{ .once = &.{ | 2886 | .each = .{ .once = &.{ |
| 2738 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"2", .src1), ._, ._ }, | 2887 | .{ ._, .v_ps, .add, .dst0x, .src0x, .src1x, ._ }, |
| 2739 | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, | | |
| 2740 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, | | |
| 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 | .patterns = &.{ | 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 }}, | 2901 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2748 | .clobbers = .{ .eflags = true }, | | |
| 2749 | .each = .{ .once = &.{ | 2902 | .each = .{ .once = &.{ |
| 2750 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, | 2903 | .{ ._, ._ps, .add, .dst0x, .src1x, ._, ._ }, |
| 2751 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"4", .src1), ._, ._ }, | | |
| 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 | .patterns = &.{ | 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 }}, | 2917 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2759 | .clobbers = .{ .eflags = true }, | | |
| 2760 | .each = .{ .once = &.{ | 2918 | .each = .{ .once = &.{ |
| 2761 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"4", .src1), ._, ._ }, | 2919 | .{ ._, .v_ps, .add, .dst0y, .src0y, .src1y, ._ }, |
| 2762 | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, | | |
| 2763 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, | | |
| 2764 | } }, | 2920 | } }, |
| 2765 | }, .{ | 2921 | }, .{ |
| 2766 | .required_features = .{ .@"64bit", null, null, null }, | 2922 | .required_features = .{ .avx, null, null, null }, |
| 2767 | .dst_constraints = .{.{ .elem_size_is = 8 }}, | 2923 | .src_constraints = .{ |
| | 2924 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 2925 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 2926 | .any, |
| | 2927 | }, |
| 2768 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 2943 | .clobbers = .{ .eflags = true }, |
| 2773 | .each = .{ .once = &.{ | 2944 | .each = .{ .once = &.{ |
| 2774 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, | 2945 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2775 | .{ ._, ._, .lea, .dst0p, .leasi(.src0, .@"8", .src1), ._, ._ }, | 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 }, | 2953 | .required_features = .{ .sse, null, null, null }, |
| 2779 | .dst_constraints = .{.{ .elem_size_is = 8 + 1 }}, | 2954 | .src_constraints = .{ |
| | 2955 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 2956 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 2957 | .any, |
| | 2958 | }, |
| 2780 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 2974 | .clobbers = .{ .eflags = true }, |
| 2785 | .each = .{ .once = &.{ | 2975 | .each = .{ .once = &.{ |
| 2786 | .{ ._, ._, .lea, .dst0p, .leasi(.src1, .@"8", .src1), ._, ._ }, | 2976 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2787 | .{ ._, ._, .neg, .dst0p, ._, ._, ._ }, | 2977 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2788 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .dst0), ._, ._ }, | 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 | .patterns = &.{ | 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 }}, | 2995 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2796 | .clobbers = .{ .eflags = true }, | | |
| 2797 | .each = .{ .once = &.{ | 2996 | .each = .{ .once = &.{ |
| 2798 | .{ ._, ._l, .sa, .src1p, .sa(.none, .add_log2_src0_elem_size), ._, ._ }, | 2997 | .{ ._, .v_sd, .add, .dst0x, .src0x, .src1q, ._ }, |
| 2799 | .{ ._, ._, .neg, .src1p, ._, ._, ._ }, | | |
| 2800 | .{ ._, ._, .lea, .dst0p, .leai(.src0, .src1), ._, ._ }, | | |
| 2801 | } }, | 2998 | } }, |
| 2802 | }, .{ | 2999 | }, .{ |
| 2803 | .patterns = &.{ | 3000 | .required_features = .{ .sse2, null, null, null }, |
| 2804 | .{ .src = .{ .to_gpr, .to_gpr } }, | 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 | .patterns = &.{ | 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 | .dst_temps = .{.{ .ref = .src0 }}, | 3011 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2837 | .clobbers = .{ .eflags = true }, | | |
| 2838 | .each = .{ .once = &.{ | 3012 | .each = .{ .once = &.{ |
| 2839 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 3013 | .{ ._, ._sd, .add, .dst0x, .src1q, ._, ._ }, |
| 2840 | .{ ._, ._l, .cmov, .dst0d, .src1d, ._, ._ }, | | |
| 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 | .patterns = &.{ | 3022 | .patterns = &.{ |
| 2845 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3023 | .{ .src = .{ .mem, .mem, .none } }, |
| 2846 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 2847 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 2848 | }, | 3024 | }, |
| 2849 | .dst_temps = .{.{ .ref = .src0 }}, | 3025 | .extra_temps = .{ |
| 2850 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 3037 | .each = .{ .once = &.{ |
| 2852 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 3038 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 2853 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, | 3039 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 2854 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, | 3040 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| | 3041 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 2855 | } }, | 3042 | } }, |
| 2856 | }, .{ | 3043 | }, .{ |
| 2857 | .required_features = .{ .cmov, null, null, null }, | 3044 | .required_features = .{ .avx, null, null, null }, |
| 2858 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, | 3045 | .src_constraints = .{ |
| | 3046 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 3047 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 3048 | .any, |
| | 3049 | }, |
| 2859 | .patterns = &.{ | 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 }}, | 3055 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2863 | .clobbers = .{ .eflags = true }, | | |
| 2864 | .each = .{ .once = &.{ | 3056 | .each = .{ .once = &.{ |
| 2865 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 3057 | .{ ._, .v_pd, .add, .dst0x, .src0x, .src1x, ._ }, |
| 2866 | .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ }, | | |
| 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 | .patterns = &.{ | 3066 | .patterns = &.{ |
| 2871 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3067 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 2872 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 3068 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 2873 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 3069 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 2874 | }, | 3070 | }, |
| 2875 | .dst_temps = .{.{ .ref = .src0 }}, | 3071 | .dst_temps = .{.{ .ref = .src0 }}, |
| 2876 | .clobbers = .{ .eflags = true }, | | |
| 2877 | .each = .{ .once = &.{ | 3072 | .each = .{ .once = &.{ |
| 2878 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 3073 | .{ ._, ._pd, .add, .dst0x, .src1x, ._, ._ }, |
| 2879 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, | | |
| 2880 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, | | |
| 2881 | } }, | 3074 | } }, |
| 2882 | }, .{ | 3075 | }, .{ |
| 2883 | .required_features = .{ .cmov, null, null, null }, | 3076 | .required_features = .{ .avx, null, null, null }, |
| 2884 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, | 3077 | .src_constraints = .{ |
| | 3078 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 3079 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 3080 | .any, |
| | 3081 | }, |
| 2885 | .patterns = &.{ | 3082 | .patterns = &.{ |
| 2886 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3083 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 2887 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 3084 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 2888 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 3085 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 2889 | }, | 3086 | }, |
| 2890 | .dst_temps = .{.{ .ref = .src0 }}, | 3087 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 2891 | .clobbers = .{ .eflags = true }, | | |
| 2892 | .each = .{ .once = &.{ | 3088 | .each = .{ .once = &.{ |
| 2893 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 3089 | .{ ._, .v_pd, .add, .dst0y, .src0y, .src1y, ._ }, |
| 2894 | .{ ._, ._l, .cmov, .dst0w, .src1w, ._, ._ }, | | |
| 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 | .patterns = &.{ | 3098 | .patterns = &.{ |
| 2899 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3099 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2900 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 2901 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 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 | .clobbers = .{ .eflags = true }, | 3113 | .clobbers = .{ .eflags = true }, |
| 2905 | .each = .{ .once = &.{ | 3114 | .each = .{ .once = &.{ |
| 2906 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 3115 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2907 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, | 3116 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2908 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, | 3117 | .{ ._, .v_pd, .add, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 2909 | } }, | 3118 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 2910 | }, .{ | 3119 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 2911 | .required_features = .{ .cmov, null, null, null }, | 3120 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._ }, | | |
| 2951 | } }, | 3121 | } }, |
| 2952 | }, .{ | 3122 | }, .{ |
| 2953 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, | 3123 | .required_features = .{ .sse2, null, null, null }, |
| 2954 | .patterns = &.{ | 3124 | .src_constraints = .{ |
| 2955 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3125 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 2956 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 3126 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 2957 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 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 | .patterns = &.{ | 3129 | .patterns = &.{ |
| 2970 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3130 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 2971 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 2972 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 2973 | }, | 3131 | }, |
| 2974 | .dst_temps = .{.{ .ref = .src0 }}, | 3132 | .extra_temps = .{ |
| 2975 | .clobbers = .{ .eflags = true }, | 3133 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 2976 | .each = .{ .once = &.{ | 3134 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 2977 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 3135 | .unused, |
| 2978 | .{ ._, ._b, .cmov, .dst0d, .src1d, ._, ._ }, | 3136 | .unused, |
| 2979 | } }, | 3137 | .unused, |
| 2980 | }, .{ | 3138 | .unused, |
| 2981 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, | 3139 | .unused, |
| 2982 | .patterns = &.{ | 3140 | .unused, |
| 2983 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3141 | .unused, |
| 2984 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 2985 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 2986 | }, | 3142 | }, |
| 2987 | .dst_temps = .{.{ .ref = .src0 }}, | 3143 | .dst_temps = .{.mem}, |
| 2988 | .clobbers = .{ .eflags = true }, | 3144 | .clobbers = .{ .eflags = true }, |
| 2989 | .each = .{ .once = &.{ | 3145 | .each = .{ .once = &.{ |
| 2990 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 3146 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2991 | .{ ._, ._nb, .j, .@"0f", ._, ._, ._ }, | 3147 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 2992 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, | 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 }, | 3154 | .required_features = .{ .x87, null, null, null }, |
| 2996 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, | 3155 | .src_constraints = .{ |
| 2997 | .patterns = &.{ | 3156 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 2998 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3157 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 2999 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 3158 | .any, |
| 3000 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 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 | .patterns = &.{ | 3160 | .patterns = &.{ |
| 3012 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3161 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3013 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3014 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 3015 | }, | 3162 | }, |
| 3016 | .dst_temps = .{.{ .ref = .src0 }}, | 3163 | .extra_temps = .{ |
| 3017 | .clobbers = .{ .eflags = true }, | 3164 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3018 | .each = .{ .once = &.{ | 3165 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 3019 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 3166 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3020 | .{ ._, ._nl, .j, .@"0f", ._, ._, ._ }, | 3167 | .unused, |
| 3021 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, | 3168 | .unused, |
| 3022 | } }, | 3169 | .unused, |
| 3023 | }, .{ | 3170 | .unused, |
| 3024 | .required_features = .{ .@"64bit", .cmov, null, null }, | 3171 | .unused, |
| 3025 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, | 3172 | .unused, |
| 3026 | .patterns = &.{ | | |
| 3027 | .{ .src = .{ .to_mut_gpr, .mem } }, | | |
| 3028 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | | |
| 3029 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 3030 | }, | 3173 | }, |
| 3031 | .dst_temps = .{.{ .ref = .src0 }}, | 3174 | .dst_temps = .{.mem}, |
| 3032 | .clobbers = .{ .eflags = true }, | | |
| 3033 | .each = .{ .once = &.{ | 3175 | .each = .{ .once = &.{ |
| 3034 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 3176 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3035 | .{ ._, ._b, .cmov, .dst0q, .src1q, ._, ._ }, | 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 }, | 3185 | .required_features = .{ .x87, null, null, null }, |
| 3039 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, | 3186 | .src_constraints = .{ |
| 3040 | .patterns = &.{ | 3187 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3041 | .{ .src = .{ .to_mut_gpr, .mem } }, | 3188 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3042 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 3189 | .any, |
| 3043 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | | |
| 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 | .patterns = &.{ | 3191 | .patterns = &.{ |
| 3056 | .{ .src = .{ .to_mem, .to_mem } }, | 3192 | .{ .src = .{ .mem, .mem, .none } }, |
| 3057 | }, | 3193 | }, |
| 3058 | .extra_temps = .{ | 3194 | .extra_temps = .{ |
| 3059 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 3195 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 3060 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 3196 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3061 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 3197 | .unused, |
| 3062 | .unused, | 3198 | .unused, |
| 3063 | .unused, | 3199 | .unused, |
| 3064 | .unused, | 3200 | .unused, |
| ... | @@ -3066,34 +3202,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3066,34 +3202,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3066 | .unused, | 3202 | .unused, |
| 3067 | .unused, | 3203 | .unused, |
| 3068 | }, | 3204 | }, |
| 3069 | .dst_temps = .{.mem}, | 3205 | .dst_temps = .{.{ .rc = .x87 }}, |
| 3070 | .clobbers = .{ .eflags = true }, | | |
| 3071 | .each = .{ .once = &.{ | 3206 | .each = .{ .once = &.{ |
| 3072 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 3207 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 3073 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 3208 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 3074 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 3209 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| 3075 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 3210 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 3086 | } }, | 3211 | } }, |
| 3087 | }, .{ | 3212 | }, .{ |
| 3088 | .required_features = .{ .@"64bit", null, null, null }, | 3213 | .required_features = .{ .x87, null, null, null }, |
| 3089 | .src_constraints = .{ .any_signed_int, .any_signed_int }, | 3214 | .src_constraints = .{ |
| | 3215 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 3216 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 3217 | .any, |
| | 3218 | }, |
| 3090 | .patterns = &.{ | 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 | .extra_temps = .{ | 3224 | .extra_temps = .{ |
| 3094 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 3225 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3095 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 3226 | .unused, |
| 3096 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 3227 | .unused, |
| 3097 | .unused, | 3228 | .unused, |
| 3098 | .unused, | 3229 | .unused, |
| 3099 | .unused, | 3230 | .unused, |
| ... | @@ -3101,34 +3232,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3101,34 +3232,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3101 | .unused, | 3232 | .unused, |
| 3102 | .unused, | 3233 | .unused, |
| 3103 | }, | 3234 | }, |
| 3104 | .dst_temps = .{.mem}, | 3235 | .dst_temps = .{.{ .rc = .x87 }}, |
| 3105 | .clobbers = .{ .eflags = true }, | | |
| 3106 | .each = .{ .once = &.{ | 3236 | .each = .{ .once = &.{ |
| 3107 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 3237 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 3108 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 3238 | .{ ._, .f_, .add, .tmp0t, .src1t, ._, ._ }, |
| 3109 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 3239 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 3121 | } }, | 3240 | } }, |
| 3122 | }, .{ | 3241 | }, .{ |
| 3123 | .required_features = .{ .@"64bit", .cmov, null, null }, | 3242 | .required_features = .{ .x87, null, null, null }, |
| 3124 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, | 3243 | .src_constraints = .{ |
| | 3244 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 3245 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 3246 | .any, |
| | 3247 | }, |
| 3125 | .patterns = &.{ | 3248 | .patterns = &.{ |
| 3126 | .{ .src = .{ .to_mem, .to_mem } }, | 3249 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3127 | }, | 3250 | }, |
| 3128 | .extra_temps = .{ | 3251 | .extra_temps = .{ |
| 3129 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 3252 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3130 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 3253 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 3131 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 3254 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3132 | .unused, | 3255 | .unused, |
| 3133 | .unused, | 3256 | .unused, |
| 3134 | .unused, | 3257 | .unused, |
| ... | @@ -3137,31 +3260,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3137,31 +3260,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3137 | .unused, | 3260 | .unused, |
| 3138 | }, | 3261 | }, |
| 3139 | .dst_temps = .{.mem}, | 3262 | .dst_temps = .{.mem}, |
| 3140 | .clobbers = .{ .eflags = true }, | | |
| 3141 | .each = .{ .once = &.{ | 3263 | .each = .{ .once = &.{ |
| 3142 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 3264 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3143 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 3265 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3144 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, | 3266 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3145 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, | 3267 | .{ ._, .f_p, .add, ._, ._, ._, ._ }, |
| 3146 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 3268 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3147 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 3269 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3148 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 3270 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 3154 | } }, | 3271 | } }, |
| 3155 | }, .{ | 3272 | }, .{ |
| 3156 | .required_features = .{ .@"64bit", null, null, null }, | 3273 | .required_features = .{ .sse, null, null, null }, |
| 3157 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, | 3274 | .src_constraints = .{ |
| | 3275 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 3276 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 3277 | .any, |
| | 3278 | }, |
| 3158 | .patterns = &.{ | 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 | .extra_temps = .{ | 3283 | .extra_temps = .{ |
| 3162 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 3284 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } }, |
| 3163 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 3285 | .unused, |
| 3164 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 3286 | .unused, |
| 3165 | .unused, | 3287 | .unused, |
| 3166 | .unused, | 3288 | .unused, |
| 3167 | .unused, | 3289 | .unused, |
| ... | @@ -3169,100 +3291,93 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3169,100 +3291,93 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3169 | .unused, | 3291 | .unused, |
| 3170 | .unused, | 3292 | .unused, |
| 3171 | }, | 3293 | }, |
| 3172 | .dst_temps = .{.mem}, | 3294 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3173 | .clobbers = .{ .eflags = true }, | 3295 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3174 | .each = .{ .once = &.{ | 3296 | .each = .{ .once = &.{ |
| 3175 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 3297 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 3187 | } }, | 3298 | } }, |
| 3188 | }, .{ | 3299 | }, .{ |
| 3189 | .required_features = .{ .avx, null, null, null }, | 3300 | .required_features = .{ .avx, null, null, null }, |
| 3190 | .src_constraints = .{ | 3301 | .src_constraints = .{ |
| 3191 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3302 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3192 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3303 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 3304 | .any, |
| 3193 | }, | 3305 | }, |
| 3194 | .patterns = &.{ | 3306 | .patterns = &.{ |
| 3195 | .{ .src = .{ .to_sse, .mem } }, | 3307 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 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 } }, | | |
| 3208 | }, | 3308 | }, |
| 3209 | .patterns = &.{ | 3309 | .call_frame = .{ .alignment = .@"16" }, |
| 3210 | .{ .src = .{ .to_mut_sse, .mem } }, | 3310 | .extra_temps = .{ |
| 3211 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 3311 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3212 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 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 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse2, null, null, null }, | 3333 | .required_features = .{ .sse2, null, null, null }, |
| 3220 | .src_constraints = .{ | 3334 | .src_constraints = .{ |
| 3221 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3335 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3222 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3336 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 3337 | .any, |
| 3223 | }, | 3338 | }, |
| 3224 | .patterns = &.{ | 3339 | .patterns = &.{ |
| 3225 | .{ .src = .{ .to_mut_sse, .mem } }, | 3340 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 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 } }, | | |
| 3242 | }, | 3341 | }, |
| 3243 | .patterns = &.{ | 3342 | .call_frame = .{ .alignment = .@"16" }, |
| 3244 | .{ .src = .{ .to_sse, .mem } }, | 3343 | .extra_temps = .{ |
| 3245 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 3344 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3246 | .{ .src = .{ .to_sse, .to_sse } }, | 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 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 3367 | .src_constraints = .{ |
| 3255 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, | 3368 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 3256 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, | 3369 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 3370 | .any, |
| 3257 | }, | 3371 | }, |
| 3258 | .patterns = &.{ | 3372 | .patterns = &.{ |
| 3259 | .{ .src = .{ .to_mem, .to_mem } }, | 3373 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3260 | }, | 3374 | }, |
| | 3375 | .call_frame = .{ .alignment = .@"16" }, |
| 3261 | .extra_temps = .{ | 3376 | .extra_temps = .{ |
| 3262 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3377 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3263 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, | 3378 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 3264 | .unused, | 3379 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 3265 | .unused, | 3380 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__addtf3" } } }, |
| 3266 | .unused, | 3381 | .unused, |
| 3267 | .unused, | 3382 | .unused, |
| 3268 | .unused, | 3383 | .unused, |
| ... | @@ -3270,27 +3385,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3270,27 +3385,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3270 | .unused, | 3385 | .unused, |
| 3271 | }, | 3386 | }, |
| 3272 | .dst_temps = .{.mem}, | 3387 | .dst_temps = .{.mem}, |
| 3273 | .clobbers = .{ .eflags = true }, | 3388 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3274 | .each = .{ .once = &.{ | 3389 | .each = .{ .once = &.{ |
| 3275 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3390 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3276 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 3391 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3277 | .{ ._, .vp_b, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 3392 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3278 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 3393 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3279 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 3394 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 3395 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3280 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 3396 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3281 | } }, | 3397 | } }, |
| 3282 | }, .{ | 3398 | } }) catch |err| switch (err) { |
| 3283 | .required_features = .{ .avx, null, null, null }, | 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 | .src_constraints = .{ | 3416 | .src_constraints = .{ |
| 3285 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3417 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 3286 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3418 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 3419 | .any, |
| 3287 | }, | 3420 | }, |
| 3288 | .patterns = &.{ | 3421 | .patterns = &.{ |
| 3289 | .{ .src = .{ .to_mem, .to_mem } }, | 3422 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3290 | }, | 3423 | }, |
| 3291 | .extra_temps = .{ | 3424 | .extra_temps = .{ |
| 3292 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3425 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 3293 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 3426 | .unused, |
| 3294 | .unused, | 3427 | .unused, |
| 3295 | .unused, | 3428 | .unused, |
| 3296 | .unused, | 3429 | .unused, |
| ... | @@ -3299,28 +3432,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3299,28 +3432,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3299 | .unused, | 3432 | .unused, |
| 3300 | .unused, | 3433 | .unused, |
| 3301 | }, | 3434 | }, |
| 3302 | .dst_temps = .{.mem}, | 3435 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3303 | .clobbers = .{ .eflags = true }, | | |
| 3304 | .each = .{ .once = &.{ | 3436 | .each = .{ .once = &.{ |
| 3305 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3437 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 3306 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 3438 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 3307 | .{ ._, .vp_b, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, | 3439 | .{ ._, .v_ss, .sub, .dst0x, .dst0x, .tmp0d, ._ }, |
| 3308 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 3440 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 3309 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | | |
| 3310 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3311 | } }, | 3441 | } }, |
| 3312 | }, .{ | 3442 | }, .{ |
| 3313 | .required_features = .{ .sse4_1, null, null, null }, | 3443 | .required_features = .{ .sse, null, null, null }, |
| 3314 | .src_constraints = .{ | 3444 | .src_constraints = .{ |
| 3315 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3445 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 3316 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3446 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 3447 | .any, |
| 3317 | }, | 3448 | }, |
| 3318 | .patterns = &.{ | 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 | .extra_temps = .{ | 3453 | .extra_temps = .{ |
| 3322 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3454 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3323 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 3455 | .unused, |
| 3324 | .unused, | 3456 | .unused, |
| 3325 | .unused, | 3457 | .unused, |
| 3326 | .unused, | 3458 | .unused, |
| ... | @@ -3329,29 +3461,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3329,29 +3461,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3329 | .unused, | 3461 | .unused, |
| 3330 | .unused, | 3462 | .unused, |
| 3331 | }, | 3463 | }, |
| 3332 | .dst_temps = .{.mem}, | 3464 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3333 | .clobbers = .{ .eflags = true }, | 3465 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3334 | .each = .{ .once = &.{ | 3466 | .each = .{ .once = &.{ |
| 3335 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3467 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 3341 | } }, | 3468 | } }, |
| 3342 | }, .{ | 3469 | }, .{ |
| 3343 | .required_features = .{ .sse2, null, null, null }, | 3470 | .required_features = .{ .f16c, null, null, null }, |
| 3344 | .src_constraints = .{ | 3471 | .src_constraints = .{ |
| 3345 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3472 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 3346 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 3473 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 3474 | .any, |
| 3347 | }, | 3475 | }, |
| 3348 | .patterns = &.{ | 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 | .extra_temps = .{ | 3482 | .extra_temps = .{ |
| 3352 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3483 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 3353 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 3484 | .unused, |
| 3354 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 3485 | .unused, |
| 3355 | .unused, | 3486 | .unused, |
| 3356 | .unused, | 3487 | .unused, |
| 3357 | .unused, | 3488 | .unused, |
| ... | @@ -3359,33 +3490,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3359,33 +3490,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3359 | .unused, | 3490 | .unused, |
| 3360 | .unused, | 3491 | .unused, |
| 3361 | }, | 3492 | }, |
| 3362 | .dst_temps = .{.mem}, | 3493 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3363 | .clobbers = .{ .eflags = true }, | | |
| 3364 | .each = .{ .once = &.{ | 3494 | .each = .{ .once = &.{ |
| 3365 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3495 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 3366 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 3496 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 3367 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, | 3497 | .{ ._, .v_ps, .sub, .dst0x, .dst0x, .tmp0x, ._ }, |
| 3368 | .{ ._, .p_b, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 3498 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 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", ._, ._, ._ }, | | |
| 3375 | } }, | 3499 | } }, |
| 3376 | }, .{ | 3500 | }, .{ |
| 3377 | .required_features = .{ .cmov, .slow_incdec, null, null }, | 3501 | .required_features = .{ .f16c, null, null, null }, |
| 3378 | .src_constraints = .{ | 3502 | .src_constraints = .{ |
| 3379 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3503 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 3380 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3504 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 3505 | .any, |
| 3381 | }, | 3506 | }, |
| 3382 | .patterns = &.{ | 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 | .extra_temps = .{ | 3513 | .extra_temps = .{ |
| 3386 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3514 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 3387 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 3515 | .unused, |
| 3388 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 3516 | .unused, |
| 3389 | .unused, | 3517 | .unused, |
| 3390 | .unused, | 3518 | .unused, |
| 3391 | .unused, | 3519 | .unused, |
| ... | @@ -3393,31 +3521,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3393,31 +3521,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3393 | .unused, | 3521 | .unused, |
| 3394 | .unused, | 3522 | .unused, |
| 3395 | }, | 3523 | }, |
| 3396 | .dst_temps = .{.mem}, | 3524 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3397 | .clobbers = .{ .eflags = true }, | | |
| 3398 | .each = .{ .once = &.{ | 3525 | .each = .{ .once = &.{ |
| 3399 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3526 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 3400 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 3527 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 3401 | .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3528 | .{ ._, .v_ps, .sub, .dst0y, .dst0y, .tmp0y, ._ }, |
| 3402 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, | 3529 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 3403 | .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ }, | | |
| 3404 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, | | |
| 3405 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 3406 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3407 | } }, | 3530 | } }, |
| 3408 | }, .{ | 3531 | }, .{ |
| 3409 | .required_features = .{ .cmov, null, null, null }, | 3532 | .required_features = .{ .f16c, null, null, null }, |
| 3410 | .src_constraints = .{ | 3533 | .src_constraints = .{ |
| 3411 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3534 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 3412 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3535 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| | 3536 | .any, |
| 3413 | }, | 3537 | }, |
| 3414 | .patterns = &.{ | 3538 | .patterns = &.{ |
| 3415 | .{ .src = .{ .to_mem, .to_mem } }, | 3539 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3416 | }, | 3540 | }, |
| 3417 | .extra_temps = .{ | 3541 | .extra_temps = .{ |
| 3418 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3542 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3419 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 3543 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 3420 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 3544 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 3421 | .unused, | 3545 | .unused, |
| 3422 | .unused, | 3546 | .unused, |
| 3423 | .unused, | 3547 | .unused, |
| ... | @@ -3428,29 +3552,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3428,29 +3552,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3428 | .dst_temps = .{.mem}, | 3552 | .dst_temps = .{.mem}, |
| 3429 | .clobbers = .{ .eflags = true }, | 3553 | .clobbers = .{ .eflags = true }, |
| 3430 | .each = .{ .once = &.{ | 3554 | .each = .{ .once = &.{ |
| 3431 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3555 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3432 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 3556 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3433 | .{ ._, ._, .movsx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3557 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3434 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, | 3558 | .{ ._, .v_ps, .sub, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 3435 | .{ ._, ._l, .cmov, .tmp1d, .tmp2d, ._, ._ }, | 3559 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 3436 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, | 3560 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3437 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 3561 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3438 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 3439 | } }, | 3562 | } }, |
| 3440 | }, .{ | 3563 | }, .{ |
| 3441 | .required_features = .{ .slow_incdec, null, null, null }, | 3564 | .required_features = .{ .avx, null, null, null }, |
| 3442 | .src_constraints = .{ | 3565 | .src_constraints = .{ |
| 3443 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3566 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3444 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3567 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 3568 | .any, |
| 3445 | }, | 3569 | }, |
| 3446 | .patterns = &.{ | 3570 | .patterns = &.{ |
| 3447 | .{ .src = .{ .to_mem, .to_mem } }, | 3571 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3448 | }, | 3572 | }, |
| | 3573 | .call_frame = .{ .alignment = .@"16" }, |
| 3449 | .extra_temps = .{ | 3574 | .extra_temps = .{ |
| 3450 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3451 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 3576 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 3452 | .unused, | 3577 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 3453 | .unused, | 3578 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subhf3" } } }, |
| 3454 | .unused, | 3579 | .unused, |
| 3455 | .unused, | 3580 | .unused, |
| 3456 | .unused, | 3581 | .unused, |
| ... | @@ -3458,180 +3583,215 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3458,180 +3583,215 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3458 | .unused, | 3583 | .unused, |
| 3459 | }, | 3584 | }, |
| 3460 | .dst_temps = .{.mem}, | 3585 | .dst_temps = .{.mem}, |
| 3461 | .clobbers = .{ .eflags = true }, | 3586 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3462 | .each = .{ .once = &.{ | 3587 | .each = .{ .once = &.{ |
| 3463 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3588 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3464 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 3589 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 3465 | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3590 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 3466 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, | 3591 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 3467 | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3592 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3468 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, | 3593 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 3469 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 3594 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 3470 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 3595 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3471 | } }, | 3596 | } }, |
| 3472 | }, .{ | 3597 | }, .{ |
| | 3598 | .required_features = .{ .sse4_1, null, null, null }, |
| 3473 | .src_constraints = .{ | 3599 | .src_constraints = .{ |
| 3474 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3600 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3475 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 3601 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 3602 | .any, |
| 3476 | }, | 3603 | }, |
| 3477 | .patterns = &.{ | 3604 | .patterns = &.{ |
| 3478 | .{ .src = .{ .to_mem, .to_mem } }, | 3605 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3479 | }, | 3606 | }, |
| | 3607 | .call_frame = .{ .alignment = .@"16" }, |
| 3480 | .extra_temps = .{ | 3608 | .extra_temps = .{ |
| 3481 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 3613 | .unused, |
| 3484 | .unused, | 3614 | .unused, |
| 3485 | .unused, | 3615 | .unused, |
| 3486 | .unused, | 3616 | .unused, |
| 3487 | .unused, | 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 | .unused, | 3651 | .unused, |
| 3489 | .unused, | 3652 | .unused, |
| 3490 | }, | 3653 | }, |
| 3491 | .dst_temps = .{.mem}, | 3654 | .dst_temps = .{.mem}, |
| 3492 | .clobbers = .{ .eflags = true }, | 3655 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 3493 | .each = .{ .once = &.{ | 3656 | .each = .{ .once = &.{ |
| 3494 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3657 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3495 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 3658 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 3496 | .{ ._, ._, .cmp, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3659 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 3497 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, | 3660 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 3498 | .{ ._, ._, .mov, .tmp1b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3661 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 3499 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, | 3662 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 3500 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 3663 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| 3501 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 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 | .src_constraints = .{ | 3670 | .src_constraints = .{ |
| 3506 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, | 3671 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 3507 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, | 3672 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 3673 | .any, |
| 3508 | }, | 3674 | }, |
| 3509 | .patterns = &.{ | 3675 | .patterns = &.{ |
| 3510 | .{ .src = .{ .to_mut_mmx, .mem } }, | 3676 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3511 | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, | | |
| 3512 | .{ .src = .{ .to_mut_mmx, .to_mmx } }, | | |
| 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 | .each = .{ .once = &.{ | 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 | .required_features = .{ .avx, null, null, null }, | 3708 | .required_features = .{ .avx, null, null, null }, |
| 3520 | .src_constraints = .{ | 3709 | .src_constraints = .{ |
| 3521 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3710 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 3522 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3711 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 3712 | .any, |
| 3523 | }, | 3713 | }, |
| 3524 | .patterns = &.{ | 3714 | .patterns = &.{ |
| 3525 | .{ .src = .{ .to_sse, .mem } }, | 3715 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3526 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 3716 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3527 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 3528 | }, | 3717 | }, |
| 3529 | .dst_temps = .{.{ .rc = .sse }}, | 3718 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3530 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 3724 | .src_constraints = .{ |
| 3536 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3725 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 3537 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3726 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 3727 | .any, |
| 3538 | }, | 3728 | }, |
| 3539 | .patterns = &.{ | 3729 | .patterns = &.{ |
| 3540 | .{ .src = .{ .to_mut_sse, .mem } }, | 3730 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3541 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 3731 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 3542 | .{ .src = .{ .to_mut_sse, .to_sse } }, | | |
| 3543 | }, | 3732 | }, |
| 3544 | .dst_temps = .{.{ .ref = .src0 }}, | 3733 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3545 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 3739 | .src_constraints = .{ |
| 3551 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 3740 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3552 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 3741 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 3742 | .any, |
| 3553 | }, | 3743 | }, |
| 3554 | .patterns = &.{ | 3744 | .patterns = &.{ |
| 3555 | .{ .src = .{ .to_sse, .mem } }, | 3745 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3556 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 3746 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3557 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 3558 | }, | 3747 | }, |
| 3559 | .dst_temps = .{.{ .rc = .sse }}, | 3748 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3560 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 3754 | .src_constraints = .{ |
| 3566 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 3755 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3567 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 3756 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 3757 | .any, |
| 3568 | }, | 3758 | }, |
| 3569 | .patterns = &.{ | 3759 | .patterns = &.{ |
| 3570 | .{ .src = .{ .to_mem, .to_mem } }, | 3760 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3571 | }, | 3761 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 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, | | |
| 3582 | }, | 3762 | }, |
| 3583 | .dst_temps = .{.mem}, | 3763 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3584 | .clobbers = .{ .eflags = true }, | | |
| 3585 | .each = .{ .once = &.{ | 3764 | .each = .{ .once = &.{ |
| 3586 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3765 | .{ ._, ._ps, .sub, .dst0x, .src1x, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 3592 | } }, | 3766 | } }, |
| 3593 | }, .{ | 3767 | }, .{ |
| 3594 | .required_features = .{ .avx, null, null, null }, | 3768 | .required_features = .{ .avx, null, null, null }, |
| 3595 | .src_constraints = .{ | 3769 | .src_constraints = .{ |
| 3596 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3770 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 3597 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3771 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 3772 | .any, |
| 3598 | }, | 3773 | }, |
| 3599 | .patterns = &.{ | 3774 | .patterns = &.{ |
| 3600 | .{ .src = .{ .to_mem, .to_mem } }, | 3775 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3601 | }, | 3776 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 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, | | |
| 3612 | }, | 3777 | }, |
| 3613 | .dst_temps = .{.mem}, | 3778 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3614 | .clobbers = .{ .eflags = true }, | | |
| 3615 | .each = .{ .once = &.{ | 3779 | .each = .{ .once = &.{ |
| 3616 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3780 | .{ ._, .v_ps, .sub, .dst0y, .src0y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 3622 | } }, | 3781 | } }, |
| 3623 | }, .{ | 3782 | }, .{ |
| 3624 | .required_features = .{ .sse2, null, null, null }, | 3783 | .required_features = .{ .avx, null, null, null }, |
| 3625 | .src_constraints = .{ | 3784 | .src_constraints = .{ |
| 3626 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3785 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 3627 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 3786 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 3787 | .any, |
| 3628 | }, | 3788 | }, |
| 3629 | .patterns = &.{ | 3789 | .patterns = &.{ |
| 3630 | .{ .src = .{ .to_mem, .to_mem } }, | 3790 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3631 | }, | 3791 | }, |
| 3632 | .extra_temps = .{ | 3792 | .extra_temps = .{ |
| 3633 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3793 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3634 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 3794 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 3635 | .unused, | 3795 | .unused, |
| 3636 | .unused, | 3796 | .unused, |
| 3637 | .unused, | 3797 | .unused, |
| ... | @@ -3643,26 +3803,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3643,26 +3803,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3643 | .dst_temps = .{.mem}, | 3803 | .dst_temps = .{.mem}, |
| 3644 | .clobbers = .{ .eflags = true }, | 3804 | .clobbers = .{ .eflags = true }, |
| 3645 | .each = .{ .once = &.{ | 3805 | .each = .{ .once = &.{ |
| 3646 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3806 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3647 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 3807 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3648 | .{ ._, .p_b, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 3808 | .{ ._, .v_ps, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 3649 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 3809 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 3650 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 3810 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3651 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 3811 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3652 | } }, | 3812 | } }, |
| 3653 | }, .{ | 3813 | }, .{ |
| 3654 | .required_features = .{ .cmov, .slow_incdec, null, null }, | 3814 | .required_features = .{ .sse, null, null, null }, |
| 3655 | .src_constraints = .{ | 3815 | .src_constraints = .{ |
| 3656 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3816 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 3657 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3817 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 3818 | .any, |
| 3658 | }, | 3819 | }, |
| 3659 | .patterns = &.{ | 3820 | .patterns = &.{ |
| 3660 | .{ .src = .{ .to_mem, .to_mem } }, | 3821 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3661 | }, | 3822 | }, |
| 3662 | .extra_temps = .{ | 3823 | .extra_temps = .{ |
| 3663 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3664 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 3825 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 3665 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 3826 | .unused, |
| 3666 | .unused, | 3827 | .unused, |
| 3667 | .unused, | 3828 | .unused, |
| 3668 | .unused, | 3829 | .unused, |
| ... | @@ -3673,90 +3834,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3673,90 +3834,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3673 | .dst_temps = .{.mem}, | 3834 | .dst_temps = .{.mem}, |
| 3674 | .clobbers = .{ .eflags = true }, | 3835 | .clobbers = .{ .eflags = true }, |
| 3675 | .each = .{ .once = &.{ | 3836 | .each = .{ .once = &.{ |
| 3676 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3837 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3677 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 3838 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3678 | .{ ._, ._, .movzx, .tmp2d, .memia(.src1b, .tmp0, .add_size), ._, ._ }, | 3839 | .{ ._, ._ps, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3679 | .{ ._, ._, .cmp, .tmp1b, .tmp2b, ._, ._ }, | 3840 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3680 | .{ ._, ._b, .cmov, .tmp1d, .tmp2d, ._, ._ }, | 3841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3681 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, | | |
| 3682 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 3683 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 3842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3684 | } }, | 3843 | } }, |
| 3685 | }, .{ | 3844 | }, .{ |
| 3686 | .required_features = .{ .cmov, null, null, null }, | 3845 | .required_features = .{ .avx, null, null, null }, |
| 3687 | .src_constraints = .{ | 3846 | .src_constraints = .{ |
| 3688 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3847 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3689 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3848 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 3849 | .any, |
| 3690 | }, | 3850 | }, |
| 3691 | .patterns = &.{ | 3851 | .patterns = &.{ |
| 3692 | .{ .src = .{ .to_mem, .to_mem } }, | 3852 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3693 | }, | 3853 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 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, | | |
| 3704 | }, | 3854 | }, |
| 3705 | .dst_temps = .{.mem}, | 3855 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3706 | .clobbers = .{ .eflags = true }, | | |
| 3707 | .each = .{ .once = &.{ | 3856 | .each = .{ .once = &.{ |
| 3708 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3857 | .{ ._, .v_sd, .sub, .dst0x, .src0x, .src1q, ._ }, |
| 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", ._, ._, ._ }, | | |
| 3716 | } }, | 3858 | } }, |
| 3717 | }, .{ | 3859 | }, .{ |
| 3718 | .required_features = .{ .slow_incdec, null, null, null }, | 3860 | .required_features = .{ .sse2, null, null, null }, |
| 3719 | .src_constraints = .{ | 3861 | .src_constraints = .{ |
| 3720 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3862 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3721 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3863 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 3864 | .any, |
| 3722 | }, | 3865 | }, |
| 3723 | .patterns = &.{ | 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 = .{ | 3870 | .dst_temps = .{.{ .ref = .src0 }}, |
| 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 }, | | |
| 3739 | .each = .{ .once = &.{ | 3871 | .each = .{ .once = &.{ |
| 3740 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3872 | .{ ._, ._sd, .sub, .dst0x, .src1q, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 3748 | } }, | 3873 | } }, |
| 3749 | }, .{ | 3874 | }, .{ |
| | 3875 | .required_features = .{ .x87, null, null, null }, |
| 3750 | .src_constraints = .{ | 3876 | .src_constraints = .{ |
| 3751 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3877 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3752 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 3878 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 3879 | .any, |
| 3753 | }, | 3880 | }, |
| 3754 | .patterns = &.{ | 3881 | .patterns = &.{ |
| 3755 | .{ .src = .{ .to_mem, .to_mem } }, | 3882 | .{ .src = .{ .mem, .mem, .none } }, |
| 3756 | }, | 3883 | }, |
| 3757 | .extra_temps = .{ | 3884 | .extra_temps = .{ |
| 3758 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3885 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 3759 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 3886 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3760 | .unused, | 3887 | .unused, |
| 3761 | .unused, | 3888 | .unused, |
| 3762 | .unused, | 3889 | .unused, |
| ... | @@ -3766,89 +3893,70 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3766,89 +3893,70 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3766 | .unused, | 3893 | .unused, |
| 3767 | }, | 3894 | }, |
| 3768 | .dst_temps = .{.mem}, | 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 | .each = .{ .once = &.{ | 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 | .required_features = .{ .avx, null, null, null }, | 3903 | .required_features = .{ .avx, null, null, null }, |
| 3797 | .src_constraints = .{ | 3904 | .src_constraints = .{ |
| 3798 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 3905 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3799 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 3906 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 3907 | .any, |
| 3800 | }, | 3908 | }, |
| 3801 | .patterns = &.{ | 3909 | .patterns = &.{ |
| 3802 | .{ .src = .{ .to_sse, .mem } }, | 3910 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3803 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 3911 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3804 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 3805 | }, | 3912 | }, |
| 3806 | .dst_temps = .{.{ .rc = .sse }}, | 3913 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3807 | .each = .{ .once = &.{ | 3914 | .each = .{ .once = &.{ |
| 3808 | .{ ._, .vp_w, .maxs, .dst0x, .src0x, .src1x, ._ }, | 3915 | .{ ._, .v_pd, .sub, .dst0x, .src0x, .src1x, ._ }, |
| 3809 | } }, | 3916 | } }, |
| 3810 | }, .{ | 3917 | }, .{ |
| 3811 | .required_features = .{ .sse2, null, null, null }, | 3918 | .required_features = .{ .sse2, null, null, null }, |
| 3812 | .src_constraints = .{ | 3919 | .src_constraints = .{ |
| 3813 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 3920 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3814 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 3921 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 3922 | .any, |
| 3815 | }, | 3923 | }, |
| 3816 | .patterns = &.{ | 3924 | .patterns = &.{ |
| 3817 | .{ .src = .{ .to_mut_sse, .mem } }, | 3925 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 3818 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 3926 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 3819 | .{ .src = .{ .to_mut_sse, .to_sse } }, | | |
| 3820 | }, | 3927 | }, |
| 3821 | .dst_temps = .{.{ .ref = .src0 }}, | 3928 | .dst_temps = .{.{ .ref = .src0 }}, |
| 3822 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 3934 | .src_constraints = .{ |
| 3828 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, | 3935 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3829 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, | 3936 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 3937 | .any, |
| 3830 | }, | 3938 | }, |
| 3831 | .patterns = &.{ | 3939 | .patterns = &.{ |
| 3832 | .{ .src = .{ .to_sse, .mem } }, | 3940 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 3833 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 3941 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 3834 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 3835 | }, | 3942 | }, |
| 3836 | .dst_temps = .{.{ .rc = .sse }}, | 3943 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 3837 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 3949 | .src_constraints = .{ |
| 3843 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, | 3950 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 3844 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, | 3951 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 3952 | .any, |
| 3845 | }, | 3953 | }, |
| 3846 | .patterns = &.{ | 3954 | .patterns = &.{ |
| 3847 | .{ .src = .{ .to_mem, .to_mem } }, | 3955 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3848 | }, | 3956 | }, |
| 3849 | .extra_temps = .{ | 3957 | .extra_temps = .{ |
| 3850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3851 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, | 3959 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 3852 | .unused, | 3960 | .unused, |
| 3853 | .unused, | 3961 | .unused, |
| 3854 | .unused, | 3962 | .unused, |
| ... | @@ -3860,25 +3968,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3860,25 +3968,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3860 | .dst_temps = .{.mem}, | 3968 | .dst_temps = .{.mem}, |
| 3861 | .clobbers = .{ .eflags = true }, | 3969 | .clobbers = .{ .eflags = true }, |
| 3862 | .each = .{ .once = &.{ | 3970 | .each = .{ .once = &.{ |
| 3863 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 3971 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3864 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 3972 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3865 | .{ ._, .vp_w, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 3973 | .{ ._, .v_pd, .sub, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 3866 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 3974 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 3867 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 3975 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 3868 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 3976 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3869 | } }, | 3977 | } }, |
| 3870 | }, .{ | 3978 | }, .{ |
| 3871 | .required_features = .{ .avx, null, null, null }, | 3979 | .required_features = .{ .sse2, null, null, null }, |
| 3872 | .src_constraints = .{ | 3980 | .src_constraints = .{ |
| 3873 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 3981 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 3874 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 3982 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 3983 | .any, |
| 3875 | }, | 3984 | }, |
| 3876 | .patterns = &.{ | 3985 | .patterns = &.{ |
| 3877 | .{ .src = .{ .to_mem, .to_mem } }, | 3986 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3878 | }, | 3987 | }, |
| 3879 | .extra_temps = .{ | 3988 | .extra_temps = .{ |
| 3880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 3989 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3881 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, | 3990 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 3882 | .unused, | 3991 | .unused, |
| 3883 | .unused, | 3992 | .unused, |
| 3884 | .unused, | 3993 | .unused, |
| ... | @@ -3890,26 +3999,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3890,26 +3999,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3890 | .dst_temps = .{.mem}, | 3999 | .dst_temps = .{.mem}, |
| 3891 | .clobbers = .{ .eflags = true }, | 4000 | .clobbers = .{ .eflags = true }, |
| 3892 | .each = .{ .once = &.{ | 4001 | .each = .{ .once = &.{ |
| 3893 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4002 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3894 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4003 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3895 | .{ ._, .vp_w, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, | 4004 | .{ ._, ._pd, .sub, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 3896 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4005 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 3897 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4006 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 3898 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4007 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3899 | } }, | 4008 | } }, |
| 3900 | }, .{ | 4009 | }, .{ |
| 3901 | .required_features = .{ .sse2, null, null, null }, | 4010 | .required_features = .{ .x87, null, null, null }, |
| 3902 | .src_constraints = .{ | 4011 | .src_constraints = .{ |
| 3903 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 4012 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 3904 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 4013 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 4014 | .any, |
| 3905 | }, | 4015 | }, |
| 3906 | .patterns = &.{ | 4016 | .patterns = &.{ |
| 3907 | .{ .src = .{ .to_mem, .to_mem } }, | 4017 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 3908 | }, | 4018 | }, |
| 3909 | .extra_temps = .{ | 4019 | .extra_temps = .{ |
| 3910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4020 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 3911 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, | 4021 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 3912 | .unused, | 4022 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 3913 | .unused, | 4023 | .unused, |
| 3914 | .unused, | 4024 | .unused, |
| 3915 | .unused, | 4025 | .unused, |
| ... | @@ -3918,27 +4028,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3918,27 +4028,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3918 | .unused, | 4028 | .unused, |
| 3919 | }, | 4029 | }, |
| 3920 | .dst_temps = .{.mem}, | 4030 | .dst_temps = .{.mem}, |
| 3921 | .clobbers = .{ .eflags = true }, | | |
| 3922 | .each = .{ .once = &.{ | 4031 | .each = .{ .once = &.{ |
| 3923 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3924 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4033 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3925 | .{ ._, .p_w, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4034 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 3926 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4035 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 3927 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4036 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| | 4037 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 3928 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4038 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 3929 | } }, | 4039 | } }, |
| 3930 | }, .{ | 4040 | }, .{ |
| 3931 | .required_features = .{ .cmov, null, null, null }, | 4041 | .required_features = .{ .x87, null, null, null }, |
| 3932 | .src_constraints = .{ | 4042 | .src_constraints = .{ |
| 3933 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 4043 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3934 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 4044 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4045 | .any, |
| 3935 | }, | 4046 | }, |
| 3936 | .patterns = &.{ | 4047 | .patterns = &.{ |
| 3937 | .{ .src = .{ .to_mem, .to_mem } }, | 4048 | .{ .src = .{ .mem, .mem, .none } }, |
| 3938 | }, | 4049 | }, |
| 3939 | .extra_temps = .{ | 4050 | .extra_temps = .{ |
| 3940 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4051 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 3941 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 4052 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3942 | .unused, | 4053 | .unused, |
| 3943 | .unused, | 4054 | .unused, |
| 3944 | .unused, | 4055 | .unused, |
| ... | @@ -3947,28 +4058,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3947,28 +4058,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3947 | .unused, | 4058 | .unused, |
| 3948 | .unused, | 4059 | .unused, |
| 3949 | }, | 4060 | }, |
| 3950 | .dst_temps = .{.mem}, | 4061 | .dst_temps = .{.{ .rc = .x87 }}, |
| 3951 | .clobbers = .{ .eflags = true }, | | |
| 3952 | .each = .{ .once = &.{ | 4062 | .each = .{ .once = &.{ |
| 3953 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4063 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 3954 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 4064 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 3955 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 4065 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 3956 | .{ ._, ._l, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 4066 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 3957 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, | | |
| 3958 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 3959 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 3960 | } }, | 4067 | } }, |
| 3961 | }, .{ | 4068 | }, .{ |
| | 4069 | .required_features = .{ .x87, null, null, null }, |
| 3962 | .src_constraints = .{ | 4070 | .src_constraints = .{ |
| 3963 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 4071 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 3964 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 4072 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4073 | .any, |
| 3965 | }, | 4074 | }, |
| 3966 | .patterns = &.{ | 4075 | .patterns = &.{ |
| 3967 | .{ .src = .{ .to_mem, .to_mem } }, | 4076 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 3968 | }, | 4077 | }, |
| 3969 | .extra_temps = .{ | 4078 | .extra_temps = .{ |
| 3970 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4079 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 3971 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 4080 | .unused, |
| 3972 | .unused, | 4081 | .unused, |
| 3973 | .unused, | 4082 | .unused, |
| 3974 | .unused, | 4083 | .unused, |
| ... | @@ -3977,92 +4086,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3977,92 +4086,54 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3977 | .unused, | 4086 | .unused, |
| 3978 | .unused, | 4087 | .unused, |
| 3979 | }, | 4088 | }, |
| 3980 | .dst_temps = .{.mem}, | 4089 | .dst_temps = .{.{ .rc = .x87 }}, |
| 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 }}, | | |
| 4019 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4097 | .src_constraints = .{ |
| 4025 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4098 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4026 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4099 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4100 | .any, |
| 4027 | }, | 4101 | }, |
| 4028 | .patterns = &.{ | 4102 | .patterns = &.{ |
| 4029 | .{ .src = .{ .to_mut_sse, .mem } }, | 4103 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 4030 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 4104 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 4031 | .{ .src = .{ .to_mut_sse, .to_sse } }, | | |
| 4032 | }, | 4105 | }, |
| 4033 | .dst_temps = .{.{ .ref = .src0 }}, | 4106 | .extra_temps = .{ |
| 4034 | .each = .{ .once = &.{ | 4107 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4035 | .{ ._, .p_w, .subus, .dst0x, .src1x, ._, ._ }, | 4108 | .unused, |
| 4036 | .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ }, | 4109 | .unused, |
| 4037 | } }, | 4110 | .unused, |
| 4038 | }, .{ | 4111 | .unused, |
| 4039 | .required_features = .{ .avx2, null, null, null }, | 4112 | .unused, |
| 4040 | .src_constraints = .{ | 4113 | .unused, |
| 4041 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 4114 | .unused, |
| 4042 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 4115 | .unused, |
| 4043 | }, | | |
| 4044 | .patterns = &.{ | | |
| 4045 | .{ .src = .{ .to_sse, .mem } }, | | |
| 4046 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | | |
| 4047 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 4048 | }, | 4116 | }, |
| 4049 | .dst_temps = .{.{ .rc = .sse }}, | 4117 | .dst_temps = .{.{ .rc = .x87 }}, |
| 4050 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4125 | .src_constraints = .{ |
| 4056 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 4126 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4057 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 4127 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4128 | .any, |
| 4058 | }, | 4129 | }, |
| 4059 | .patterns = &.{ | 4130 | .patterns = &.{ |
| 4060 | .{ .src = .{ .to_mem, .to_mem } }, | 4131 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4061 | }, | 4132 | }, |
| 4062 | .extra_temps = .{ | 4133 | .extra_temps = .{ |
| 4063 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4134 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4064 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, | 4135 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 4065 | .unused, | 4136 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4066 | .unused, | 4137 | .unused, |
| 4067 | .unused, | 4138 | .unused, |
| 4068 | .unused, | 4139 | .unused, |
| ... | @@ -4071,27 +4142,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4071,27 +4142,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4071 | .unused, | 4142 | .unused, |
| 4072 | }, | 4143 | }, |
| 4073 | .dst_temps = .{.mem}, | 4144 | .dst_temps = .{.mem}, |
| 4074 | .clobbers = .{ .eflags = true }, | | |
| 4075 | .each = .{ .once = &.{ | 4145 | .each = .{ .once = &.{ |
| 4076 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4146 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4077 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 4147 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4078 | .{ ._, .vp_w, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 4148 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4079 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 4149 | .{ ._, .f_p, .sub, ._, ._, ._, ._ }, |
| 4080 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 4150 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| | 4151 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4081 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4152 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4082 | } }, | 4153 | } }, |
| 4083 | }, .{ | 4154 | }, .{ |
| 4084 | .required_features = .{ .avx, null, null, null }, | 4155 | .required_features = .{ .sse, null, null, null }, |
| 4085 | .src_constraints = .{ | 4156 | .src_constraints = .{ |
| 4086 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4157 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4087 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4158 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 4159 | .any, |
| 4088 | }, | 4160 | }, |
| 4089 | .patterns = &.{ | 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 | .extra_temps = .{ | 4165 | .extra_temps = .{ |
| 4093 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4166 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4094 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 4167 | .unused, |
| 4095 | .unused, | 4168 | .unused, |
| 4096 | .unused, | 4169 | .unused, |
| 4097 | .unused, | 4170 | .unused, |
| ... | @@ -4100,30 +4173,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4100,30 +4173,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4100 | .unused, | 4173 | .unused, |
| 4101 | .unused, | 4174 | .unused, |
| 4102 | }, | 4175 | }, |
| 4103 | .dst_temps = .{.mem}, | 4176 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4104 | .clobbers = .{ .eflags = true }, | 4177 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4105 | .each = .{ .once = &.{ | 4178 | .each = .{ .once = &.{ |
| 4106 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4179 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 4112 | } }, | 4180 | } }, |
| 4113 | }, .{ | 4181 | }, .{ |
| 4114 | .required_features = .{ .sse4_1, null, null, null }, | 4182 | .required_features = .{ .avx, null, null, null }, |
| 4115 | .src_constraints = .{ | 4183 | .src_constraints = .{ |
| 4116 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4184 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4117 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4185 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 4186 | .any, |
| 4118 | }, | 4187 | }, |
| 4119 | .patterns = &.{ | 4188 | .patterns = &.{ |
| 4120 | .{ .src = .{ .to_mem, .to_mem } }, | 4189 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4121 | }, | 4190 | }, |
| | 4191 | .call_frame = .{ .alignment = .@"16" }, |
| 4122 | .extra_temps = .{ | 4192 | .extra_temps = .{ |
| 4123 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4193 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4124 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 4194 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4125 | .unused, | 4195 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4126 | .unused, | 4196 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4127 | .unused, | 4197 | .unused, |
| 4128 | .unused, | 4198 | .unused, |
| 4129 | .unused, | 4199 | .unused, |
| ... | @@ -4131,29 +4201,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4131,29 +4201,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4131 | .unused, | 4201 | .unused, |
| 4132 | }, | 4202 | }, |
| 4133 | .dst_temps = .{.mem}, | 4203 | .dst_temps = .{.mem}, |
| 4134 | .clobbers = .{ .eflags = true }, | 4204 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4135 | .each = .{ .once = &.{ | 4205 | .each = .{ .once = &.{ |
| 4136 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4206 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4137 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4207 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4138 | .{ ._, .p_w, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4208 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4139 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4209 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| | 4210 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4140 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4211 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4141 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4212 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4142 | } }, | 4213 | } }, |
| 4143 | }, .{ | 4214 | }, .{ |
| 4144 | .required_features = .{ .sse2, null, null, null }, | 4215 | .required_features = .{ .sse2, null, null, null }, |
| 4145 | .src_constraints = .{ | 4216 | .src_constraints = .{ |
| 4146 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4217 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4147 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 4218 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 4219 | .any, |
| 4148 | }, | 4220 | }, |
| 4149 | .patterns = &.{ | 4221 | .patterns = &.{ |
| 4150 | .{ .src = .{ .to_mem, .to_mem } }, | 4222 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4151 | }, | 4223 | }, |
| | 4224 | .call_frame = .{ .alignment = .@"16" }, |
| 4152 | .extra_temps = .{ | 4225 | .extra_temps = .{ |
| 4153 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4226 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4154 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 4227 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4155 | .unused, | 4228 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4156 | .unused, | 4229 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4157 | .unused, | 4230 | .unused, |
| 4158 | .unused, | 4231 | .unused, |
| 4159 | .unused, | 4232 | .unused, |
| ... | @@ -4161,30 +4234,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4161,30 +4234,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4161 | .unused, | 4234 | .unused, |
| 4162 | }, | 4235 | }, |
| 4163 | .dst_temps = .{.mem}, | 4236 | .dst_temps = .{.mem}, |
| 4164 | .clobbers = .{ .eflags = true }, | 4237 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4165 | .each = .{ .once = &.{ | 4238 | .each = .{ .once = &.{ |
| 4166 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4239 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4167 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4240 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4168 | .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4241 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4169 | .{ ._, .p_w, .add, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4242 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4170 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4243 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4171 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4244 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4172 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4245 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4173 | } }, | 4246 | } }, |
| 4174 | }, .{ | 4247 | }, .{ |
| 4175 | .required_features = .{ .cmov, null, null, null }, | 4248 | .required_features = .{ .sse, null, null, null }, |
| 4176 | .src_constraints = .{ | 4249 | .src_constraints = .{ |
| 4177 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 4250 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4178 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 4251 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 4252 | .any, |
| 4179 | }, | 4253 | }, |
| 4180 | .patterns = &.{ | 4254 | .patterns = &.{ |
| 4181 | .{ .src = .{ .to_mem, .to_mem } }, | 4255 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4182 | }, | 4256 | }, |
| | 4257 | .call_frame = .{ .alignment = .@"16" }, |
| 4183 | .extra_temps = .{ | 4258 | .extra_temps = .{ |
| 4184 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4259 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4185 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 4260 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4186 | .unused, | 4261 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4187 | .unused, | 4262 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__subtf3" } } }, |
| 4188 | .unused, | 4263 | .unused, |
| 4189 | .unused, | 4264 | .unused, |
| 4190 | .unused, | 4265 | .unused, |
| ... | @@ -4192,27 +4267,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4192,27 +4267,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4192 | .unused, | 4267 | .unused, |
| 4193 | }, | 4268 | }, |
| 4194 | .dst_temps = .{.mem}, | 4269 | .dst_temps = .{.mem}, |
| 4195 | .clobbers = .{ .eflags = true }, | 4270 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4196 | .each = .{ .once = &.{ | 4271 | .each = .{ .once = &.{ |
| 4197 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4272 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4198 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 4273 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4199 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 4274 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4200 | .{ ._, ._b, .cmov, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 4275 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4201 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, | 4276 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4202 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 4277 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4203 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .src_constraints = .{ | 4298 | .src_constraints = .{ |
| 4207 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 4299 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4208 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 4300 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 4301 | .any, |
| 4209 | }, | 4302 | }, |
| 4210 | .patterns = &.{ | 4303 | .patterns = &.{ |
| 4211 | .{ .src = .{ .to_mem, .to_mem } }, | 4304 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4212 | }, | 4305 | }, |
| 4213 | .extra_temps = .{ | 4306 | .extra_temps = .{ |
| 4214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4307 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4215 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 4308 | .unused, |
| 4216 | .unused, | 4309 | .unused, |
| 4217 | .unused, | 4310 | .unused, |
| 4218 | .unused, | 4311 | .unused, |
| ... | @@ -4221,94 +4314,87 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4221,94 +4314,87 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4221 | .unused, | 4314 | .unused, |
| 4222 | .unused, | 4315 | .unused, |
| 4223 | }, | 4316 | }, |
| 4224 | .dst_temps = .{.mem}, | 4317 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4225 | .clobbers = .{ .eflags = true }, | | |
| 4226 | .each = .{ .once = &.{ | 4318 | .each = .{ .once = &.{ |
| 4227 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4319 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 4228 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 4320 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 4229 | .{ ._, ._, .cmp, .tmp1w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 4321 | .{ ._, .v_ss, .mul, .dst0x, .dst0x, .tmp0d, ._ }, |
| 4230 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, | 4322 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 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", ._, ._, ._ }, | | |
| 4235 | } }, | 4323 | } }, |
| 4236 | }, .{ | 4324 | }, .{ |
| 4237 | .required_features = .{ .avx, null, null, null }, | 4325 | .required_features = .{ .sse, null, null, null }, |
| 4238 | .src_constraints = .{ | 4326 | .src_constraints = .{ |
| 4239 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4327 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4240 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4328 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 4329 | .any, |
| 4241 | }, | 4330 | }, |
| 4242 | .patterns = &.{ | 4331 | .patterns = &.{ |
| 4243 | .{ .src = .{ .to_sse, .mem } }, | 4332 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 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 } }, | | |
| 4256 | }, | 4333 | }, |
| 4257 | .patterns = &.{ | 4334 | .call_frame = .{ .alignment = .@"16" }, |
| 4258 | .{ .src = .{ .to_mut_sse, .mem } }, | 4335 | .extra_temps = .{ |
| 4259 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 4336 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4260 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 4337 | .unused, |
| | 4338 | .unused, |
| | 4339 | .unused, |
| | 4340 | .unused, |
| | 4341 | .unused, |
| | 4342 | .unused, |
| | 4343 | .unused, |
| | 4344 | .unused, |
| 4261 | }, | 4345 | }, |
| 4262 | .dst_temps = .{.{ .ref = .src0 }}, | 4346 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 4347 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4263 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4353 | .src_constraints = .{ |
| 4269 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4354 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 4270 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4355 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 4356 | .any, |
| 4271 | }, | 4357 | }, |
| 4272 | .patterns = &.{ | 4358 | .patterns = &.{ |
| 4273 | .{ .src = .{ .to_mut_sse, .mem } }, | 4359 | .{ .src = .{ .mem, .mem, .none } }, |
| 4274 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 4360 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4275 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 4361 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 4276 | }, | 4362 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 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 } }, | | |
| 4290 | }, | 4363 | }, |
| 4291 | .patterns = &.{ | 4364 | .extra_temps = .{ |
| 4292 | .{ .src = .{ .to_sse, .mem } }, | 4365 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4293 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 4366 | .unused, |
| 4294 | .{ .src = .{ .to_sse, .to_sse } }, | 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 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4384 | .src_constraints = .{ |
| 4303 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, | 4385 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 4304 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, | 4386 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 4387 | .any, |
| 4305 | }, | 4388 | }, |
| 4306 | .patterns = &.{ | 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 | .extra_temps = .{ | 4395 | .extra_temps = .{ |
| 4310 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4396 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4311 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, | 4397 | .unused, |
| 4312 | .unused, | 4398 | .unused, |
| 4313 | .unused, | 4399 | .unused, |
| 4314 | .unused, | 4400 | .unused, |
| ... | @@ -4317,29 +4403,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4317,29 +4403,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4317 | .unused, | 4403 | .unused, |
| 4318 | .unused, | 4404 | .unused, |
| 4319 | }, | 4405 | }, |
| 4320 | .dst_temps = .{.mem}, | 4406 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4321 | .clobbers = .{ .eflags = true }, | | |
| 4322 | .each = .{ .once = &.{ | 4407 | .each = .{ .once = &.{ |
| 4323 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4408 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 4324 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 4409 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 4325 | .{ ._, .vp_d, .maxs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 4410 | .{ ._, .v_ps, .mul, .dst0y, .dst0y, .tmp0y, ._ }, |
| 4326 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 4411 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 4327 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | | |
| 4328 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 4329 | } }, | 4412 | } }, |
| 4330 | }, .{ | 4413 | }, .{ |
| 4331 | .required_features = .{ .avx, null, null, null }, | 4414 | .required_features = .{ .f16c, null, null, null }, |
| 4332 | .src_constraints = .{ | 4415 | .src_constraints = .{ |
| 4333 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4416 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 4334 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4417 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| | 4418 | .any, |
| 4335 | }, | 4419 | }, |
| 4336 | .patterns = &.{ | 4420 | .patterns = &.{ |
| 4337 | .{ .src = .{ .to_mem, .to_mem } }, | 4421 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4338 | }, | 4422 | }, |
| 4339 | .extra_temps = .{ | 4423 | .extra_temps = .{ |
| 4340 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4424 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4341 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 4425 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 4342 | .unused, | 4426 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 4343 | .unused, | 4427 | .unused, |
| 4344 | .unused, | 4428 | .unused, |
| 4345 | .unused, | 4429 | .unused, |
| ... | @@ -4350,27 +4434,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4350,27 +4434,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4350 | .dst_temps = .{.mem}, | 4434 | .dst_temps = .{.mem}, |
| 4351 | .clobbers = .{ .eflags = true }, | 4435 | .clobbers = .{ .eflags = true }, |
| 4352 | .each = .{ .once = &.{ | 4436 | .each = .{ .once = &.{ |
| 4353 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4437 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4354 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4438 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4355 | .{ ._, .vp_d, .maxs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, | 4439 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4356 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4440 | .{ ._, .v_ps, .mul, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| | 4441 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 4357 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4442 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4358 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4443 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4359 | } }, | 4444 | } }, |
| 4360 | }, .{ | 4445 | }, .{ |
| 4361 | .required_features = .{ .sse4_1, null, null, null }, | 4446 | .required_features = .{ .avx, null, null, null }, |
| 4362 | .src_constraints = .{ | 4447 | .src_constraints = .{ |
| 4363 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4448 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4364 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4449 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 4450 | .any, |
| 4365 | }, | 4451 | }, |
| 4366 | .patterns = &.{ | 4452 | .patterns = &.{ |
| 4367 | .{ .src = .{ .to_mem, .to_mem } }, | 4453 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4368 | }, | 4454 | }, |
| | 4455 | .call_frame = .{ .alignment = .@"16" }, |
| 4369 | .extra_temps = .{ | 4456 | .extra_temps = .{ |
| 4370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4457 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4371 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 4458 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4372 | .unused, | 4459 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4373 | .unused, | 4460 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4374 | .unused, | 4461 | .unused, |
| 4375 | .unused, | 4462 | .unused, |
| 4376 | .unused, | 4463 | .unused, |
| ... | @@ -4378,29 +4465,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4378,29 +4465,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4378 | .unused, | 4465 | .unused, |
| 4379 | }, | 4466 | }, |
| 4380 | .dst_temps = .{.mem}, | 4467 | .dst_temps = .{.mem}, |
| 4381 | .clobbers = .{ .eflags = true }, | 4468 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4382 | .each = .{ .once = &.{ | 4469 | .each = .{ .once = &.{ |
| 4383 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4470 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4384 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4471 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 4385 | .{ ._, .p_d, .maxs, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4472 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 4386 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4473 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 4387 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4474 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| | 4475 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| | 4476 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4388 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4477 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4389 | } }, | 4478 | } }, |
| 4390 | }, .{ | 4479 | }, .{ |
| 4391 | .required_features = .{ .sse2, null, null, null }, | 4480 | .required_features = .{ .sse4_1, null, null, null }, |
| 4392 | .src_constraints = .{ | 4481 | .src_constraints = .{ |
| 4393 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4482 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4394 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 4483 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 4484 | .any, |
| 4395 | }, | 4485 | }, |
| 4396 | .patterns = &.{ | 4486 | .patterns = &.{ |
| 4397 | .{ .src = .{ .to_mem, .to_mem } }, | 4487 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4398 | }, | 4488 | }, |
| | 4489 | .call_frame = .{ .alignment = .@"16" }, |
| 4399 | .extra_temps = .{ | 4490 | .extra_temps = .{ |
| 4400 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4491 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4401 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 4492 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4402 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 4493 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4403 | .unused, | 4494 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4404 | .unused, | 4495 | .unused, |
| 4405 | .unused, | 4496 | .unused, |
| 4406 | .unused, | 4497 | .unused, |
| ... | @@ -4408,172 +4499,186 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4408,172 +4499,186 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4408 | .unused, | 4499 | .unused, |
| 4409 | }, | 4500 | }, |
| 4410 | .dst_temps = .{.mem}, | 4501 | .dst_temps = .{.mem}, |
| 4411 | .clobbers = .{ .eflags = true }, | 4502 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4412 | .each = .{ .once = &.{ | 4503 | .each = .{ .once = &.{ |
| 4413 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4504 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4414 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4505 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 4415 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, | 4506 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 4416 | .{ ._, .p_d, .cmpgt, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4507 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4417 | .{ ._, .p_, .@"and", .tmp2x, .tmp1x, ._, ._ }, | 4508 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4418 | .{ ._, .p_, .andn, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4509 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4419 | .{ ._, .p_, .@"or", .tmp1x, .tmp2x, ._, ._ }, | 4510 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 4420 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4511 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 4421 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | | |
| 4422 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4512 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4423 | } }, | 4513 | } }, |
| 4424 | }, .{ | 4514 | }, .{ |
| 4425 | .required_features = .{ .cmov, null, null, null }, | 4515 | .required_features = .{ .sse2, null, null, null }, |
| 4426 | .src_constraints = .{ | 4516 | .src_constraints = .{ |
| 4427 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 4517 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4428 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 4518 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 4519 | .any, |
| 4429 | }, | 4520 | }, |
| 4430 | .patterns = &.{ | 4521 | .patterns = &.{ |
| 4431 | .{ .src = .{ .to_mem, .to_mem } }, | 4522 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4432 | }, | 4523 | }, |
| | 4524 | .call_frame = .{ .alignment = .@"16" }, |
| 4433 | .extra_temps = .{ | 4525 | .extra_temps = .{ |
| 4434 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4526 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4435 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 4527 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4436 | .unused, | 4528 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4437 | .unused, | 4529 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4438 | .unused, | 4530 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 4439 | .unused, | 4531 | .unused, |
| 4440 | .unused, | 4532 | .unused, |
| 4441 | .unused, | 4533 | .unused, |
| 4442 | .unused, | 4534 | .unused, |
| 4443 | }, | 4535 | }, |
| 4444 | .dst_temps = .{.mem}, | 4536 | .dst_temps = .{.mem}, |
| 4445 | .clobbers = .{ .eflags = true }, | 4537 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4446 | .each = .{ .once = &.{ | 4538 | .each = .{ .once = &.{ |
| 4447 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4539 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4448 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 4540 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 4449 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4541 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 4450 | .{ ._, ._l, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4542 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4451 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, | 4543 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 4452 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4454 | } }, | 4549 | } }, |
| 4455 | }, .{ | 4550 | }, .{ |
| | 4551 | .required_features = .{ .sse, null, null, null }, |
| 4456 | .src_constraints = .{ | 4552 | .src_constraints = .{ |
| 4457 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 4553 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 4458 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 4554 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 4555 | .any, |
| 4459 | }, | 4556 | }, |
| 4460 | .patterns = &.{ | 4557 | .patterns = &.{ |
| 4461 | .{ .src = .{ .to_mem, .to_mem } }, | 4558 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4462 | }, | 4559 | }, |
| | 4560 | .call_frame = .{ .alignment = .@"16" }, |
| 4463 | .extra_temps = .{ | 4561 | .extra_temps = .{ |
| 4464 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4562 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4465 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 4563 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 4466 | .unused, | 4564 | .{ .type = .f32, .kind = .mem }, |
| 4467 | .unused, | 4565 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 4468 | .unused, | 4566 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 4469 | .unused, | 4567 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__mulhf3" } } }, |
| 4470 | .unused, | 4568 | .unused, |
| 4471 | .unused, | 4569 | .unused, |
| 4472 | .unused, | 4570 | .unused, |
| 4473 | }, | 4571 | }, |
| 4474 | .dst_temps = .{.mem}, | 4572 | .dst_temps = .{.mem}, |
| 4475 | .clobbers = .{ .eflags = true }, | 4573 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4476 | .each = .{ .once = &.{ | 4574 | .each = .{ .once = &.{ |
| 4477 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4575 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4478 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 4576 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4479 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4577 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 4480 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, | 4578 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 4481 | .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4579 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4482 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, | 4580 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 4483 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4587 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4485 | } }, | 4588 | } }, |
| 4486 | }, .{ | 4589 | }, .{ |
| 4487 | .required_features = .{ .avx, null, null, null }, | 4590 | .required_features = .{ .avx, null, null, null }, |
| 4488 | .src_constraints = .{ | 4591 | .src_constraints = .{ |
| 4489 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4592 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 4490 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4593 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 4594 | .any, |
| 4491 | }, | 4595 | }, |
| 4492 | .patterns = &.{ | 4596 | .patterns = &.{ |
| 4493 | .{ .src = .{ .to_sse, .mem } }, | 4597 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4494 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 4598 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4495 | .{ .src = .{ .to_sse, .to_sse } }, | 4599 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4496 | }, | 4600 | }, |
| 4497 | .dst_temps = .{.{ .rc = .sse }}, | 4601 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4498 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4607 | .src_constraints = .{ |
| 4504 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4608 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 4505 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4609 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 4610 | .any, |
| 4506 | }, | 4611 | }, |
| 4507 | .patterns = &.{ | 4612 | .patterns = &.{ |
| 4508 | .{ .src = .{ .to_mut_sse, .mem } }, | 4613 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 4509 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 4614 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 4510 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 4615 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 4511 | }, | 4616 | }, |
| 4512 | .dst_temps = .{.{ .ref = .src0 }}, | 4617 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4513 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4623 | .src_constraints = .{ |
| 4519 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4624 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4520 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4625 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 4626 | .any, |
| 4521 | }, | 4627 | }, |
| 4522 | .patterns = &.{ | 4628 | .patterns = &.{ |
| 4523 | .{ .src = .{ .to_mut_sse, .mem } }, | 4629 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4524 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 4630 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4525 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 4631 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4526 | }, | 4632 | }, |
| 4527 | .extra_temps = .{ | 4633 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4528 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 4634 | .each = .{ .once = &.{ |
| 4529 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, | 4635 | .{ ._, .v_ps, .mul, .dst0x, .src0x, .src1x, ._ }, |
| 4530 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4636 | } }, |
| 4531 | .unused, | 4637 | }, .{ |
| 4532 | .unused, | 4638 | .required_features = .{ .sse, null, null, null }, |
| 4533 | .unused, | 4639 | .src_constraints = .{ |
| 4534 | .unused, | 4640 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4535 | .unused, | 4641 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4536 | .unused, | 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 | .each = .{ .once = &.{ | 4650 | .each = .{ .once = &.{ |
| 4540 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 4651 | .{ ._, ._ps, .mul, .dst0x, .src1x, ._, ._ }, |
| 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, ._, ._ }, | | |
| 4549 | } }, | 4652 | } }, |
| 4550 | }, .{ | 4653 | }, .{ |
| 4551 | .required_features = .{ .avx2, null, null, null }, | 4654 | .required_features = .{ .avx, null, null, null }, |
| 4552 | .src_constraints = .{ | 4655 | .src_constraints = .{ |
| 4553 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 4656 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 4554 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 4657 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 4658 | .any, |
| 4555 | }, | 4659 | }, |
| 4556 | .patterns = &.{ | 4660 | .patterns = &.{ |
| 4557 | .{ .src = .{ .to_sse, .mem } }, | 4661 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 4558 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 4662 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 4559 | .{ .src = .{ .to_sse, .to_sse } }, | 4663 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4560 | }, | 4664 | }, |
| 4561 | .dst_temps = .{.{ .rc = .sse }}, | 4665 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4562 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 4671 | .src_constraints = .{ |
| 4568 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 4672 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 4569 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 4673 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 4674 | .any, |
| 4570 | }, | 4675 | }, |
| 4571 | .patterns = &.{ | 4676 | .patterns = &.{ |
| 4572 | .{ .src = .{ .to_mem, .to_mem } }, | 4677 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4573 | }, | 4678 | }, |
| 4574 | .extra_temps = .{ | 4679 | .extra_temps = .{ |
| 4575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4576 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, | 4681 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 4577 | .unused, | 4682 | .unused, |
| 4578 | .unused, | 4683 | .unused, |
| 4579 | .unused, | 4684 | .unused, |
| ... | @@ -4585,25 +4690,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4585,25 +4690,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4585 | .dst_temps = .{.mem}, | 4690 | .dst_temps = .{.mem}, |
| 4586 | .clobbers = .{ .eflags = true }, | 4691 | .clobbers = .{ .eflags = true }, |
| 4587 | .each = .{ .once = &.{ | 4692 | .each = .{ .once = &.{ |
| 4588 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4693 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4589 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 4694 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4590 | .{ ._, .vp_d, .maxu, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 4695 | .{ ._, .v_ps, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 4591 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 4696 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 4592 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 4697 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 4593 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4698 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4594 | } }, | 4699 | } }, |
| 4595 | }, .{ | 4700 | }, .{ |
| 4596 | .required_features = .{ .avx, null, null, null }, | 4701 | .required_features = .{ .sse, null, null, null }, |
| 4597 | .src_constraints = .{ | 4702 | .src_constraints = .{ |
| 4598 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4703 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 4599 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4704 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 4705 | .any, |
| 4600 | }, | 4706 | }, |
| 4601 | .patterns = &.{ | 4707 | .patterns = &.{ |
| 4602 | .{ .src = .{ .to_mem, .to_mem } }, | 4708 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4603 | }, | 4709 | }, |
| 4604 | .extra_temps = .{ | 4710 | .extra_temps = .{ |
| 4605 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4711 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4606 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4712 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 4607 | .unused, | 4713 | .unused, |
| 4608 | .unused, | 4714 | .unused, |
| 4609 | .unused, | 4715 | .unused, |
| ... | @@ -4615,25 +4721,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4615,25 +4721,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4615 | .dst_temps = .{.mem}, | 4721 | .dst_temps = .{.mem}, |
| 4616 | .clobbers = .{ .eflags = true }, | 4722 | .clobbers = .{ .eflags = true }, |
| 4617 | .each = .{ .once = &.{ | 4723 | .each = .{ .once = &.{ |
| 4618 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4724 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4619 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4725 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4620 | .{ ._, .vp_d, .maxu, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._ }, | 4726 | .{ ._, ._ps, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4621 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4727 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4622 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4728 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4623 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4729 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4624 | } }, | 4730 | } }, |
| 4625 | }, .{ | 4731 | }, .{ |
| 4626 | .required_features = .{ .sse4_1, null, null, null }, | 4732 | .required_features = .{ .avx, null, null, null }, |
| 4627 | .src_constraints = .{ | 4733 | .src_constraints = .{ |
| 4628 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4734 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4629 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 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 | .patterns = &.{ | 4770 | .patterns = &.{ |
| 4632 | .{ .src = .{ .to_mem, .to_mem } }, | 4771 | .{ .src = .{ .mem, .mem, .none } }, |
| 4633 | }, | 4772 | }, |
| 4634 | .extra_temps = .{ | 4773 | .extra_temps = .{ |
| 4635 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4774 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 4636 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4775 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 4637 | .unused, | 4776 | .unused, |
| 4638 | .unused, | 4777 | .unused, |
| 4639 | .unused, | 4778 | .unused, |
| ... | @@ -4643,67 +4782,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4643,67 +4782,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4643 | .unused, | 4782 | .unused, |
| 4644 | }, | 4783 | }, |
| 4645 | .dst_temps = .{.mem}, | 4784 | .dst_temps = .{.mem}, |
| 4646 | .clobbers = .{ .eflags = true }, | | |
| 4647 | .each = .{ .once = &.{ | 4785 | .each = .{ .once = &.{ |
| 4648 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4786 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 4649 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 4787 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 4650 | .{ ._, .p_d, .maxu, .tmp1x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 4788 | .{ ._, .f_p, .mul, ._, ._, ._, ._ }, |
| 4651 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | 4789 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 4652 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 4790 | } }, |
| 4653 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 4808 | .required_features = .{ .sse2, null, null, null }, |
| 4657 | .src_constraints = .{ | 4809 | .src_constraints = .{ |
| 4658 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4810 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4659 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 4811 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 4812 | .any, |
| 4660 | }, | 4813 | }, |
| 4661 | .patterns = &.{ | 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 = .{ | 4819 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4665 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4820 | .each = .{ .once = &.{ |
| 4666 | .{ .type = .vector_4_u32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, | 4821 | .{ ._, ._pd, .mul, .dst0x, .src1x, ._, ._ }, |
| 4667 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4822 | } }, |
| 4668 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4823 | }, .{ |
| 4669 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4824 | .required_features = .{ .avx, null, null, null }, |
| 4670 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4825 | .src_constraints = .{ |
| 4671 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 4826 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4672 | .unused, | 4827 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4673 | .unused, | 4828 | .any, |
| 4674 | }, | 4829 | }, |
| 4675 | .dst_temps = .{.mem}, | 4830 | .patterns = &.{ |
| 4676 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 4836 | .each = .{ .once = &.{ |
| 4678 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 4837 | .{ ._, .v_pd, .mul, .dst0y, .src0y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 4694 | } }, | 4838 | } }, |
| 4695 | }, .{ | 4839 | }, .{ |
| 4696 | .required_features = .{ .cmov, null, null, null }, | 4840 | .required_features = .{ .avx, null, null, null }, |
| 4697 | .src_constraints = .{ | 4841 | .src_constraints = .{ |
| 4698 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 4842 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 4699 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 4843 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 4844 | .any, |
| 4700 | }, | 4845 | }, |
| 4701 | .patterns = &.{ | 4846 | .patterns = &.{ |
| 4702 | .{ .src = .{ .to_mem, .to_mem } }, | 4847 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4703 | }, | 4848 | }, |
| 4704 | .extra_temps = .{ | 4849 | .extra_temps = .{ |
| 4705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4706 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 4851 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 4707 | .unused, | 4852 | .unused, |
| 4708 | .unused, | 4853 | .unused, |
| 4709 | .unused, | 4854 | .unused, |
| ... | @@ -4715,25 +4860,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4715,25 +4860,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4715 | .dst_temps = .{.mem}, | 4860 | .dst_temps = .{.mem}, |
| 4716 | .clobbers = .{ .eflags = true }, | 4861 | .clobbers = .{ .eflags = true }, |
| 4717 | .each = .{ .once = &.{ | 4862 | .each = .{ .once = &.{ |
| 4718 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4863 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4719 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 4864 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4720 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4865 | .{ ._, .v_pd, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 4721 | .{ ._, ._b, .cmov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4866 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 4722 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, | 4867 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 4723 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | | |
| 4724 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4868 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4725 | } }, | 4869 | } }, |
| 4726 | }, .{ | 4870 | }, .{ |
| | 4871 | .required_features = .{ .sse2, null, null, null }, |
| 4727 | .src_constraints = .{ | 4872 | .src_constraints = .{ |
| 4728 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 4873 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 4729 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 4874 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 4875 | .any, |
| 4730 | }, | 4876 | }, |
| 4731 | .patterns = &.{ | 4877 | .patterns = &.{ |
| 4732 | .{ .src = .{ .to_mem, .to_mem } }, | 4878 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4733 | }, | 4879 | }, |
| 4734 | .extra_temps = .{ | 4880 | .extra_temps = .{ |
| 4735 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 4881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4736 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 4882 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 4737 | .unused, | 4883 | .unused, |
| 4738 | .unused, | 4884 | .unused, |
| 4739 | .unused, | 4885 | .unused, |
| ... | @@ -4745,43 +4891,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4745,43 +4891,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4745 | .dst_temps = .{.mem}, | 4891 | .dst_temps = .{.mem}, |
| 4746 | .clobbers = .{ .eflags = true }, | 4892 | .clobbers = .{ .eflags = true }, |
| 4747 | .each = .{ .once = &.{ | 4893 | .each = .{ .once = &.{ |
| 4748 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 4894 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4749 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 4895 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4750 | .{ ._, ._, .cmp, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4896 | .{ ._, ._pd, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4751 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, | 4897 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4752 | .{ ._, ._, .mov, .tmp1d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, | 4898 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4753 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, | | |
| 4754 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | | |
| 4755 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 4899 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4756 | } }, | 4900 | } }, |
| 4757 | }, .{ | 4901 | }, .{ |
| 4758 | .required_features = .{ .avx, null, null, null }, | 4902 | .required_features = .{ .x87, null, null, null }, |
| 4759 | .src_constraints = .{ | 4903 | .src_constraints = .{ |
| 4760 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 4904 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 4761 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 4905 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 4906 | .any, |
| 4762 | }, | 4907 | }, |
| 4763 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 4923 | .each = .{ .once = &.{ |
| 4768 | .{ ._, .vp_q, .cmpgt, .dst0x, .src1x, .src0x, ._ }, | 4924 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4769 | .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x }, | 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 | .src_constraints = .{ | 4934 | .src_constraints = .{ |
| 4774 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 4935 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4775 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 4936 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4937 | .any, |
| 4776 | }, | 4938 | }, |
| 4777 | .patterns = &.{ | 4939 | .patterns = &.{ |
| 4778 | .{ .src = .{ .to_mut_sse, .mem } }, | 4940 | .{ .src = .{ .mem, .mem, .none } }, |
| 4779 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | | |
| 4780 | .{ .src = .{ .to_mut_sse, .to_sse } }, | | |
| 4781 | }, | 4941 | }, |
| 4782 | .extra_temps = .{ | 4942 | .extra_temps = .{ |
| 4783 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, | 4943 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 4784 | .unused, | 4944 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4785 | .unused, | 4945 | .unused, |
| 4786 | .unused, | 4946 | .unused, |
| 4787 | .unused, | 4947 | .unused, |
| ... | @@ -4790,40 +4950,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4790,40 +4950,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4790 | .unused, | 4950 | .unused, |
| 4791 | .unused, | 4951 | .unused, |
| 4792 | }, | 4952 | }, |
| 4793 | .dst_temps = .{.{ .ref = .src0 }}, | 4953 | .dst_temps = .{.{ .rc = .x87 }}, |
| 4794 | .each = .{ .once = &.{ | 4954 | .each = .{ .once = &.{ |
| 4795 | .{ ._, ._dqa, .mov, .tmp0x, .src1x, ._, ._ }, | 4955 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4796 | .{ ._, .p_q, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 4956 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 4797 | .{ ._, .p_b, .blendv, .dst0x, .src1x, .tmp0x, ._ }, | 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 | .src_constraints = .{ | 4962 | .src_constraints = .{ |
| 4802 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 4963 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4803 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 4964 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4965 | .any, |
| 4804 | }, | 4966 | }, |
| 4805 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 4984 | .each = .{ .once = &.{ |
| 4810 | .{ ._, .vp_q, .cmpgt, .dst0y, .src1y, .src0y, ._ }, | 4985 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 4811 | .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y }, | 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 | .src_constraints = .{ | 4991 | .src_constraints = .{ |
| 4816 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 4992 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 4817 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 4993 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 4994 | .any, |
| 4818 | }, | 4995 | }, |
| 4819 | .patterns = &.{ | 4996 | .patterns = &.{ |
| 4820 | .{ .src = .{ .to_mem, .to_mem } }, | 4997 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4821 | }, | 4998 | }, |
| 4822 | .extra_temps = .{ | 4999 | .extra_temps = .{ |
| 4823 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5000 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4824 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 5001 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 4825 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 5002 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 4826 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 5003 | .unused, |
| 4827 | .unused, | 5004 | .unused, |
| 4828 | .unused, | 5005 | .unused, |
| 4829 | .unused, | 5006 | .unused, |
| ... | @@ -4831,63 +5008,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4831,63 +5008,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4831 | .unused, | 5008 | .unused, |
| 4832 | }, | 5009 | }, |
| 4833 | .dst_temps = .{.mem}, | 5010 | .dst_temps = .{.mem}, |
| 4834 | .clobbers = .{ .eflags = true }, | | |
| 4835 | .each = .{ .once = &.{ | 5011 | .each = .{ .once = &.{ |
| 4836 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5012 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4837 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 5013 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4838 | .{ ._, .v_dqa, .mov, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, | 5014 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4839 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .tmp1y, ._ }, | 5015 | .{ ._, .f_p, .mul, ._, ._, ._, ._ }, |
| 4840 | .{ ._, .vp_b, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, | 5016 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 4841 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | 5017 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4842 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | | |
| 4843 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5018 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4844 | } }, | 5019 | } }, |
| 4845 | }, .{ | 5020 | }, .{ |
| 4846 | .required_features = .{ .avx, null, null, null }, | 5021 | .required_features = .{ .sse, null, null, null }, |
| 4847 | .src_constraints = .{ | 5022 | .src_constraints = .{ |
| 4848 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 5023 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4849 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 5024 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5025 | .any, |
| 4850 | }, | 5026 | }, |
| 4851 | .patterns = &.{ | 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 | .extra_temps = .{ | 5031 | .extra_temps = .{ |
| 4855 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5032 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4856 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 5033 | .unused, |
| 4857 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 5034 | .unused, |
| 4858 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 5035 | .unused, |
| 4859 | .unused, | 5036 | .unused, |
| 4860 | .unused, | 5037 | .unused, |
| 4861 | .unused, | 5038 | .unused, |
| 4862 | .unused, | 5039 | .unused, |
| 4863 | .unused, | 5040 | .unused, |
| 4864 | }, | 5041 | }, |
| 4865 | .dst_temps = .{.mem}, | 5042 | .dst_temps = .{.{ .ref = .src0 }}, |
| 4866 | .clobbers = .{ .eflags = true }, | 5043 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4867 | .each = .{ .once = &.{ | 5044 | .each = .{ .once = &.{ |
| 4868 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5045 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 4876 | } }, | 5046 | } }, |
| 4877 | }, .{ | 5047 | }, .{ |
| 4878 | .required_features = .{ .sse4_2, null, null, null }, | 5048 | .required_features = .{ .avx, null, null, null }, |
| 4879 | .src_constraints = .{ | 5049 | .src_constraints = .{ |
| 4880 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 5050 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4881 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 5051 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5052 | .any, |
| 4882 | }, | 5053 | }, |
| 4883 | .patterns = &.{ | 5054 | .patterns = &.{ |
| 4884 | .{ .src = .{ .to_mem, .to_mem } }, | 5055 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4885 | }, | 5056 | }, |
| | 5057 | .call_frame = .{ .alignment = .@"16" }, |
| 4886 | .extra_temps = .{ | 5058 | .extra_temps = .{ |
| 4887 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5059 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4888 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 5060 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4889 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 5061 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4890 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, | 5062 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4891 | .unused, | 5063 | .unused, |
| 4892 | .unused, | 5064 | .unused, |
| 4893 | .unused, | 5065 | .unused, |
| ... | @@ -4895,32 +5067,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4895,32 +5067,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4895 | .unused, | 5067 | .unused, |
| 4896 | }, | 5068 | }, |
| 4897 | .dst_temps = .{.mem}, | 5069 | .dst_temps = .{.mem}, |
| 4898 | .clobbers = .{ .eflags = true }, | 5070 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4899 | .each = .{ .once = &.{ | 5071 | .each = .{ .once = &.{ |
| 4900 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5072 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4901 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 5073 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4902 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 5074 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4903 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, | 5075 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4904 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp1x, ._, ._ }, | 5076 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4905 | .{ ._, .p_b, .blendv, .tmp1x, .tmp2x, .tmp3x, ._ }, | | |
| 4906 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp1x, ._, ._ }, | | |
| 4907 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 5077 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4908 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5078 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4909 | } }, | 5079 | } }, |
| 4910 | }, .{ | 5080 | }, .{ |
| 4911 | .required_features = .{ .@"64bit", .cmov, null, null }, | 5081 | .required_features = .{ .sse2, null, null, null }, |
| 4912 | .src_constraints = .{ | 5082 | .src_constraints = .{ |
| 4913 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 5083 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4914 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 5084 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5085 | .any, |
| 4915 | }, | 5086 | }, |
| 4916 | .patterns = &.{ | 5087 | .patterns = &.{ |
| 4917 | .{ .src = .{ .to_mem, .to_mem } }, | 5088 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4918 | }, | 5089 | }, |
| | 5090 | .call_frame = .{ .alignment = .@"16" }, |
| 4919 | .extra_temps = .{ | 5091 | .extra_temps = .{ |
| 4920 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5092 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4921 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 5093 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4922 | .unused, | 5094 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4923 | .unused, | 5095 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4924 | .unused, | 5096 | .unused, |
| 4925 | .unused, | 5097 | .unused, |
| 4926 | .unused, | 5098 | .unused, |
| ... | @@ -4928,30 +5100,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4928,30 +5100,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4928 | .unused, | 5100 | .unused, |
| 4929 | }, | 5101 | }, |
| 4930 | .dst_temps = .{.mem}, | 5102 | .dst_temps = .{.mem}, |
| 4931 | .clobbers = .{ .eflags = true }, | 5103 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4932 | .each = .{ .once = &.{ | 5104 | .each = .{ .once = &.{ |
| 4933 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5105 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4934 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 5106 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4935 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5107 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4936 | .{ ._, ._l, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5108 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4937 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 5109 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4938 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 5110 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4939 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5111 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4940 | } }, | 5112 | } }, |
| 4941 | }, .{ | 5113 | }, .{ |
| 4942 | .required_features = .{ .@"64bit", null, null, null }, | 5114 | .required_features = .{ .sse, null, null, null }, |
| 4943 | .src_constraints = .{ | 5115 | .src_constraints = .{ |
| 4944 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 5116 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 4945 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 5117 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5118 | .any, |
| 4946 | }, | 5119 | }, |
| 4947 | .patterns = &.{ | 5120 | .patterns = &.{ |
| 4948 | .{ .src = .{ .to_mem, .to_mem } }, | 5121 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 4949 | }, | 5122 | }, |
| | 5123 | .call_frame = .{ .alignment = .@"16" }, |
| 4950 | .extra_temps = .{ | 5124 | .extra_temps = .{ |
| 4951 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 4952 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 5126 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 4953 | .unused, | 5127 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 4954 | .unused, | 5128 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__multf3" } } }, |
| 4955 | .unused, | 5129 | .unused, |
| 4956 | .unused, | 5130 | .unused, |
| 4957 | .unused, | 5131 | .unused, |
| ... | @@ -4959,32 +5133,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4959,32 +5133,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4959 | .unused, | 5133 | .unused, |
| 4960 | }, | 5134 | }, |
| 4961 | .dst_temps = .{.mem}, | 5135 | .dst_temps = .{.mem}, |
| 4962 | .clobbers = .{ .eflags = true }, | 5136 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 4963 | .each = .{ .once = &.{ | 5137 | .each = .{ .once = &.{ |
| 4964 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4965 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 5139 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4966 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5140 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 4967 | .{ ._, ._nl, .j, .@"1f", ._, ._, ._ }, | 5141 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 4968 | .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5142 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 4969 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 5143 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 4970 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | | |
| 4971 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5144 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 4972 | } }, | 5145 | } }, |
| 4973 | }, .{ | 5146 | } }) catch |err| switch (err) { |
| 4974 | .required_features = .{ .avx, null, null, null }, | 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 | .src_constraints = .{ | 5168 | .src_constraints = .{ |
| 4976 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5169 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 4977 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5170 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 5171 | .any, |
| 4978 | }, | 5172 | }, |
| 4979 | .patterns = &.{ | 5173 | .patterns = &.{ |
| 4980 | .{ .src = .{ .to_sse, .mem } }, | 5174 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 4981 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | | |
| 4982 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 4983 | }, | 5175 | }, |
| 4984 | .extra_temps = .{ | 5176 | .extra_temps = .{ |
| 4985 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 5177 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 4986 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, | 5178 | .unused, |
| 4987 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5179 | .unused, |
| 4988 | .unused, | 5180 | .unused, |
| 4989 | .unused, | 5181 | .unused, |
| 4990 | .unused, | 5182 | .unused, |
| ... | @@ -4992,31 +5184,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4992,31 +5184,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4992 | .unused, | 5184 | .unused, |
| 4993 | .unused, | 5185 | .unused, |
| 4994 | }, | 5186 | }, |
| 4995 | .dst_temps = .{.{ .rc = .sse }}, | 5187 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 4996 | .each = .{ .once = &.{ | 5188 | .each = .{ .once = &.{ |
| 4997 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 5189 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 4998 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, | 5190 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 4999 | .{ ._, .vp_, .xor, .dst0x, .tmp2x, .src0x, ._ }, | 5191 | .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ }, |
| 5000 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .src1x, ._ }, | 5192 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5001 | .{ ._, .vp_q, .cmpgt, .dst0x, .tmp2x, .dst0x, ._ }, | | |
| 5002 | .{ ._, .vp_b, .blendv, .dst0x, .src0x, .src1x, .dst0x }, | | |
| 5003 | } }, | 5193 | } }, |
| 5004 | }, .{ | 5194 | }, .{ |
| 5005 | .required_features = .{ .sse4_2, null, null, null }, | 5195 | .required_features = .{ .sse, null, null, null }, |
| 5006 | .src_constraints = .{ | 5196 | .src_constraints = .{ |
| 5007 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5197 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 5008 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5198 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 5199 | .any, |
| 5009 | }, | 5200 | }, |
| 5010 | .patterns = &.{ | 5201 | .patterns = &.{ |
| 5011 | .{ .src = .{ .to_mut_sse, .mem } }, | 5202 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 5012 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | | |
| 5013 | .{ .src = .{ .to_mut_sse, .to_sse } }, | | |
| 5014 | }, | 5203 | }, |
| | 5204 | .call_frame = .{ .alignment = .@"16" }, |
| 5015 | .extra_temps = .{ | 5205 | .extra_temps = .{ |
| 5016 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 5206 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5017 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, | 5207 | .unused, |
| 5018 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5208 | .unused, |
| 5019 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, | 5209 | .unused, |
| 5020 | .unused, | 5210 | .unused, |
| 5021 | .unused, | 5211 | .unused, |
| 5022 | .unused, | 5212 | .unused, |
| ... | @@ -5024,30 +5214,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5024,30 +5214,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5024 | .unused, | 5214 | .unused, |
| 5025 | }, | 5215 | }, |
| 5026 | .dst_temps = .{.{ .ref = .src0 }}, | 5216 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 5217 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5027 | .each = .{ .once = &.{ | 5218 | .each = .{ .once = &.{ |
| 5028 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 5219 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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, ._ }, | | |
| 5035 | } }, | 5220 | } }, |
| 5036 | }, .{ | 5221 | }, .{ |
| 5037 | .required_features = .{ .avx2, null, null, null }, | 5222 | .required_features = .{ .f16c, null, null, null }, |
| 5038 | .src_constraints = .{ | 5223 | .src_constraints = .{ |
| 5039 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 5224 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 5040 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 5225 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 5226 | .any, |
| 5041 | }, | 5227 | }, |
| 5042 | .patterns = &.{ | 5228 | .patterns = &.{ |
| 5043 | .{ .src = .{ .to_sse, .mem } }, | 5229 | .{ .src = .{ .mem, .mem, .none } }, |
| 5044 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 5230 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5045 | .{ .src = .{ .to_sse, .to_sse } }, | 5231 | .{ .src = .{ .mem, .to_sse, .none } }, |
| | 5232 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5046 | }, | 5233 | }, |
| 5047 | .extra_temps = .{ | 5234 | .extra_temps = .{ |
| 5048 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 5235 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5049 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, | 5236 | .unused, |
| 5050 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5237 | .unused, |
| 5051 | .unused, | 5238 | .unused, |
| 5052 | .unused, | 5239 | .unused, |
| 5053 | .unused, | 5240 | .unused, |
| ... | @@ -5055,139 +5242,126 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5055,139 +5242,126 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5055 | .unused, | 5242 | .unused, |
| 5056 | .unused, | 5243 | .unused, |
| 5057 | }, | 5244 | }, |
| 5058 | .dst_temps = .{.{ .rc = .sse }}, | 5245 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5059 | .each = .{ .once = &.{ | 5246 | .each = .{ .once = &.{ |
| 5060 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 5247 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 5061 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, | 5248 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 5062 | .{ ._, .vp_, .xor, .dst0y, .tmp2y, .src0y, ._ }, | 5249 | .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ }, |
| 5063 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .src1y, ._ }, | 5250 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 5064 | .{ ._, .vp_q, .cmpgt, .dst0y, .tmp2y, .dst0y, ._ }, | | |
| 5065 | .{ ._, .vp_b, .blendv, .dst0y, .src0y, .src1y, .dst0y }, | | |
| 5066 | } }, | 5251 | } }, |
| 5067 | }, .{ | 5252 | }, .{ |
| 5068 | .required_features = .{ .avx2, null, null, null }, | 5253 | .required_features = .{ .f16c, null, null, null }, |
| 5069 | .src_constraints = .{ | 5254 | .src_constraints = .{ |
| 5070 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 5255 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 5071 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 5256 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 5257 | .any, |
| 5072 | }, | 5258 | }, |
| 5073 | .patterns = &.{ | 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 | .extra_temps = .{ | 5265 | .extra_temps = .{ |
| 5077 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5266 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 5078 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, | 5267 | .unused, |
| 5079 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5268 | .unused, |
| 5080 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5269 | .unused, |
| 5081 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5270 | .unused, |
| 5082 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5271 | .unused, |
| 5083 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 5272 | .unused, |
| 5084 | .unused, | 5273 | .unused, |
| 5085 | .unused, | 5274 | .unused, |
| 5086 | }, | 5275 | }, |
| 5087 | .dst_temps = .{.mem}, | 5276 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5088 | .clobbers = .{ .eflags = true }, | | |
| 5089 | .each = .{ .once = &.{ | 5277 | .each = .{ .once = &.{ |
| 5090 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 5278 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 5091 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, | 5279 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 5092 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5280 | .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ }, |
| 5093 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 5281 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 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", ._, ._, ._ }, | | |
| 5102 | } }, | 5282 | } }, |
| 5103 | }, .{ | 5283 | }, .{ |
| 5104 | .required_features = .{ .avx, null, null, null }, | 5284 | .required_features = .{ .f16c, null, null, null }, |
| 5105 | .src_constraints = .{ | 5285 | .src_constraints = .{ |
| 5106 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5286 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 5107 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5287 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| | 5288 | .any, |
| 5108 | }, | 5289 | }, |
| 5109 | .patterns = &.{ | 5290 | .patterns = &.{ |
| 5110 | .{ .src = .{ .to_mem, .to_mem } }, | 5291 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5111 | }, | 5292 | }, |
| 5112 | .extra_temps = .{ | 5293 | .extra_temps = .{ |
| 5113 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5294 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5114 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, | 5295 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5115 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5296 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5116 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5297 | .unused, |
| 5117 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5298 | .unused, |
| 5118 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5299 | .unused, |
| 5119 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5300 | .unused, |
| 5120 | .unused, | 5301 | .unused, |
| 5121 | .unused, | 5302 | .unused, |
| 5122 | }, | 5303 | }, |
| 5123 | .dst_temps = .{.mem}, | 5304 | .dst_temps = .{.mem}, |
| 5124 | .clobbers = .{ .eflags = true }, | 5305 | .clobbers = .{ .eflags = true }, |
| 5125 | .each = .{ .once = &.{ | 5306 | .each = .{ .once = &.{ |
| 5126 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 5307 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5127 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, | 5308 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5128 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5309 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5129 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 5310 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 5130 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 5311 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 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, ._, ._ }, | | |
| 5136 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 5312 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5137 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5313 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5138 | } }, | 5314 | } }, |
| 5139 | }, .{ | 5315 | }, .{ |
| 5140 | .required_features = .{ .sse4_2, null, null, null }, | 5316 | .required_features = .{ .avx, null, null, null }, |
| 5141 | .src_constraints = .{ | 5317 | .src_constraints = .{ |
| 5142 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5318 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5143 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 5319 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 5320 | .any, |
| 5144 | }, | 5321 | }, |
| 5145 | .patterns = &.{ | 5322 | .patterns = &.{ |
| 5146 | .{ .src = .{ .to_mem, .to_mem } }, | 5323 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5147 | }, | 5324 | }, |
| | 5325 | .call_frame = .{ .alignment = .@"16" }, |
| 5148 | .extra_temps = .{ | 5326 | .extra_temps = .{ |
| 5149 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5327 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5150 | .{ .type = .u64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, | 5328 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5151 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5329 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5152 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5330 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5153 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5331 | .unused, |
| 5154 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 5332 | .unused, |
| 5155 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, | 5333 | .unused, |
| 5156 | .unused, | 5334 | .unused, |
| 5157 | .unused, | 5335 | .unused, |
| 5158 | }, | 5336 | }, |
| 5159 | .dst_temps = .{.mem}, | 5337 | .dst_temps = .{.mem}, |
| 5160 | .clobbers = .{ .eflags = true }, | 5338 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5161 | .each = .{ .once = &.{ | 5339 | .each = .{ .once = &.{ |
| 5162 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 5340 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5163 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, | 5341 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 5164 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5342 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 5165 | .{ .@"0:", ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ }, | 5343 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 5166 | .{ ._, ._dqa, .mov, .tmp6x, .tmp2x, ._, ._ }, | 5344 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5167 | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 5345 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 5168 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 5346 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 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), ._, ._ }, | | |
| 5175 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5347 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5176 | } }, | 5348 | } }, |
| 5177 | }, .{ | 5349 | }, .{ |
| 5178 | .required_features = .{ .@"64bit", .cmov, null, null }, | 5350 | .required_features = .{ .sse4_1, null, null, null }, |
| 5179 | .src_constraints = .{ | 5351 | .src_constraints = .{ |
| 5180 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 5352 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5181 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 5353 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 5354 | .any, |
| 5182 | }, | 5355 | }, |
| 5183 | .patterns = &.{ | 5356 | .patterns = &.{ |
| 5184 | .{ .src = .{ .to_mem, .to_mem } }, | 5357 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5185 | }, | 5358 | }, |
| | 5359 | .call_frame = .{ .alignment = .@"16" }, |
| 5186 | .extra_temps = .{ | 5360 | .extra_temps = .{ |
| 5187 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5361 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5188 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 5362 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5189 | .unused, | 5363 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5190 | .unused, | 5364 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5191 | .unused, | 5365 | .unused, |
| 5192 | .unused, | 5366 | .unused, |
| 5193 | .unused, | 5367 | .unused, |
| ... | @@ -5195,212 +5369,181 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5195,212 +5369,181 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5195 | .unused, | 5369 | .unused, |
| 5196 | }, | 5370 | }, |
| 5197 | .dst_temps = .{.mem}, | 5371 | .dst_temps = .{.mem}, |
| 5198 | .clobbers = .{ .eflags = true }, | 5372 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5199 | .each = .{ .once = &.{ | 5373 | .each = .{ .once = &.{ |
| 5200 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5374 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5201 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 5375 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5202 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5376 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5203 | .{ ._, ._b, .cmov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5377 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5204 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 5378 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5205 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 5379 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| | 5380 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| | 5381 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5206 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5207 | } }, | 5383 | } }, |
| 5208 | }, .{ | 5384 | }, .{ |
| 5209 | .required_features = .{ .@"64bit", null, null, null }, | 5385 | .required_features = .{ .sse2, null, null, null }, |
| 5210 | .src_constraints = .{ | 5386 | .src_constraints = .{ |
| 5211 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 5387 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 5212 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 5388 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 5389 | .any, |
| 5213 | }, | 5390 | }, |
| 5214 | .patterns = &.{ | 5391 | .patterns = &.{ |
| 5215 | .{ .src = .{ .to_mem, .to_mem } }, | 5392 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5216 | }, | 5393 | }, |
| | 5394 | .call_frame = .{ .alignment = .@"16" }, |
| 5217 | .extra_temps = .{ | 5395 | .extra_temps = .{ |
| 5218 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5219 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 5397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5220 | .unused, | 5398 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5221 | .unused, | 5399 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5222 | .unused, | 5400 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5223 | .unused, | 5401 | .unused, |
| 5224 | .unused, | 5402 | .unused, |
| 5225 | .unused, | 5403 | .unused, |
| 5226 | .unused, | 5404 | .unused, |
| 5227 | }, | 5405 | }, |
| 5228 | .dst_temps = .{.mem}, | 5406 | .dst_temps = .{.mem}, |
| 5229 | .clobbers = .{ .eflags = true }, | 5407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5230 | .each = .{ .once = &.{ | 5408 | .each = .{ .once = &.{ |
| 5231 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5409 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5232 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 5410 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 5233 | .{ ._, ._, .cmp, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5411 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 5234 | .{ ._, ._nb, .j, .@"1f", ._, ._, ._ }, | 5412 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5235 | .{ ._, ._, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5413 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 5236 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 5414 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5237 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 5415 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, |
| | 5416 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, |
| | 5417 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 5238 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5418 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5239 | } }, | 5419 | } }, |
| 5240 | }, .{ | 5420 | }, .{ |
| 5241 | .required_features = .{ .@"64bit", .cmov, null, null }, | 5421 | .required_features = .{ .sse, null, null, null }, |
| 5242 | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int }, | 5422 | .src_constraints = .{ |
| | 5423 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 5424 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 5425 | .any, |
| | 5426 | }, |
| 5243 | .patterns = &.{ | 5427 | .patterns = &.{ |
| 5244 | .{ .src = .{ .to_mem, .to_mem } }, | 5428 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5245 | }, | 5429 | }, |
| | 5430 | .call_frame = .{ .alignment = .@"16" }, |
| 5246 | .extra_temps = .{ | 5431 | .extra_temps = .{ |
| 5247 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5432 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5248 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 5433 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 5249 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 5434 | .{ .type = .f32, .kind = .mem }, |
| 5250 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 5435 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 5251 | .unused, | 5436 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 5252 | .unused, | 5437 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 5253 | .unused, | 5438 | .unused, |
| 5254 | .unused, | 5439 | .unused, |
| 5255 | .unused, | 5440 | .unused, |
| 5256 | }, | 5441 | }, |
| 5257 | .dst_temps = .{.mem}, | 5442 | .dst_temps = .{.mem}, |
| 5258 | .clobbers = .{ .eflags = true }, | 5443 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5259 | .each = .{ .once = &.{ | 5444 | .each = .{ .once = &.{ |
| 5260 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5445 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5261 | .{ .@"0:", ._, .mov, .tmp1d, .sia(-1, .none, .add_src0_elem_size_div_8), ._, ._ }, | 5446 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5262 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 5447 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5263 | .{ .@"1:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 5448 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 5264 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5449 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5265 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 8), ._, ._ }, | 5450 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 5266 | .{ ._, ._c, .de, .tmp1d, ._, ._, ._ }, | 5451 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 5267 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, | 5452 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 5268 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 5453 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 5269 | .{ ._, ._, .sbb, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 5454 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 5270 | .{ ._, ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, | 5455 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 5271 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size_sub_elem_size, 8), ._, ._ }, | 5456 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 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), ._, ._ }, | | |
| 5277 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5457 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5278 | } }, | 5458 | } }, |
| 5279 | }, .{ | 5459 | }, .{ |
| 5280 | .required_features = .{ .@"64bit", null, null, null }, | 5460 | .required_features = .{ .avx, null, null, null }, |
| 5281 | .src_constraints = .{ .any_scalar_signed_int, .any_scalar_signed_int }, | 5461 | .src_constraints = .{ |
| 5282 | .patterns = &.{ | 5462 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 5283 | .{ .src = .{ .to_mem, .to_mem } }, | 5463 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5464 | .any, |
| 5284 | }, | 5465 | }, |
| 5285 | .extra_temps = .{ | 5466 | .patterns = &.{ |
| 5286 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5467 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5287 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 5468 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 5288 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | | |
| 5289 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | | |
| 5290 | .unused, | | |
| 5291 | .unused, | | |
| 5292 | .unused, | | |
| 5293 | .unused, | | |
| 5294 | .unused, | | |
| 5295 | }, | 5469 | }, |
| 5296 | .dst_temps = .{.mem}, | 5470 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5297 | .clobbers = .{ .eflags = true }, | | |
| 5298 | .each = .{ .once = &.{ | 5471 | .each = .{ .once = &.{ |
| 5299 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5472 | .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ }, |
| 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", ._, ._, ._ }, | | |
| 5317 | } }, | 5473 | } }, |
| 5318 | }, .{ | 5474 | }, .{ |
| 5319 | .required_features = .{ .@"64bit", .cmov, null, null }, | 5475 | .required_features = .{ .sse, null, null, null }, |
| 5320 | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int }, | 5476 | .src_constraints = .{ |
| | 5477 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5478 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 5479 | .any, |
| | 5480 | }, |
| 5321 | .patterns = &.{ | 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 = .{ | 5485 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5325 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5486 | .each = .{ .once = &.{ |
| 5326 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 5487 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 5327 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 5488 | } }, |
| 5328 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 5489 | }, .{ |
| 5329 | .unused, | 5490 | .required_features = .{ .avx, null, null, null }, |
| 5330 | .unused, | 5491 | .src_constraints = .{ |
| 5331 | .unused, | 5492 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5332 | .unused, | 5493 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5333 | .unused, | 5494 | .any, |
| 5334 | }, | 5495 | }, |
| 5335 | .dst_temps = .{.mem}, | 5496 | .patterns = &.{ |
| 5336 | .clobbers = .{ .eflags = true }, | 5497 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 5498 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 5499 | }, |
| | 5500 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5337 | .each = .{ .once = &.{ | 5501 | .each = .{ .once = &.{ |
| 5338 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5502 | .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ }, |
| 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", ._, ._, ._ }, | | |
| 5354 | } }, | 5503 | } }, |
| 5355 | }, .{ | 5504 | }, .{ |
| 5356 | .required_features = .{ .@"64bit", null, null, null }, | 5505 | .required_features = .{ .sse, null, null, null }, |
| 5357 | .src_constraints = .{ .any_scalar_unsigned_int, .any_scalar_unsigned_int }, | 5506 | .src_constraints = .{ |
| | 5507 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 5508 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 5509 | .any, |
| | 5510 | }, |
| 5358 | .patterns = &.{ | 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 = .{ | 5515 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5362 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5516 | .each = .{ .once = &.{ |
| 5363 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 5517 | .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ }, |
| 5364 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 5518 | } }, |
| 5365 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 5519 | }, .{ |
| 5366 | .unused, | 5520 | .required_features = .{ .avx, null, null, null }, |
| 5367 | .unused, | 5521 | .src_constraints = .{ |
| 5368 | .unused, | 5522 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5369 | .unused, | 5523 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5370 | .unused, | 5524 | .any, |
| 5371 | }, | 5525 | }, |
| 5372 | .dst_temps = .{.mem}, | 5526 | .patterns = &.{ |
| 5373 | .clobbers = .{ .eflags = true }, | 5527 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 5528 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 5529 | }, |
| | 5530 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5374 | .each = .{ .once = &.{ | 5531 | .each = .{ .once = &.{ |
| 5375 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5532 | .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 5391 | } }, | 5533 | } }, |
| 5392 | }, .{ | 5534 | }, .{ |
| 5393 | .required_features = .{ .f16c, null, null, null }, | 5535 | .required_features = .{ .avx, null, null, null }, |
| 5394 | .src_constraints = .{ | 5536 | .src_constraints = .{ |
| 5395 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 5537 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 5396 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 5538 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 5539 | .any, |
| 5397 | }, | 5540 | }, |
| 5398 | .patterns = &.{ | 5541 | .patterns = &.{ |
| 5399 | .{ .src = .{ .to_sse, .to_sse } }, | 5542 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5400 | }, | 5543 | }, |
| 5401 | .extra_temps = .{ | 5544 | .extra_temps = .{ |
| 5402 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 5545 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5403 | .{ .type = .f16, .kind = .{ .rc = .sse } }, | 5546 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 5404 | .unused, | 5547 | .unused, |
| 5405 | .unused, | 5548 | .unused, |
| 5406 | .unused, | 5549 | .unused, |
| ... | @@ -5409,28 +5552,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5409,28 +5552,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5409 | .unused, | 5552 | .unused, |
| 5410 | .unused, | 5553 | .unused, |
| 5411 | }, | 5554 | }, |
| 5412 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 5555 | .dst_temps = .{.mem}, |
| | 5556 | .clobbers = .{ .eflags = true }, |
| 5413 | .each = .{ .once = &.{ | 5557 | .each = .{ .once = &.{ |
| 5414 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 5558 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5415 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, | 5559 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5416 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, | 5560 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 5417 | .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, | 5561 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 5418 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, | 5562 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5419 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 5563 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5420 | } }, | 5564 | } }, |
| 5421 | }, .{ | 5565 | }, .{ |
| 5422 | .required_features = .{ .sse, null, null, null }, | 5566 | .required_features = .{ .sse, null, null, null }, |
| 5423 | .src_constraints = .{ | 5567 | .src_constraints = .{ |
| 5424 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 5568 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 5425 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 5569 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 5570 | .any, |
| 5426 | }, | 5571 | }, |
| 5427 | .patterns = &.{ | 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 | .extra_temps = .{ | 5575 | .extra_temps = .{ |
| 5432 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, | 5576 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5433 | .unused, | 5577 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 5434 | .unused, | 5578 | .unused, |
| 5435 | .unused, | 5579 | .unused, |
| 5436 | .unused, | 5580 | .unused, |
| ... | @@ -5439,58 +5583,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5439,58 +5583,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5439 | .unused, | 5583 | .unused, |
| 5440 | .unused, | 5584 | .unused, |
| 5441 | }, | 5585 | }, |
| 5442 | .dst_temps = .{.{ .ref = .src0 }}, | 5586 | .dst_temps = .{.mem}, |
| 5443 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 5587 | .clobbers = .{ .eflags = true }, |
| 5444 | .each = .{ .once = &.{ | 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 | .src_constraints = .{ | 5598 | .src_constraints = .{ |
| 5450 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, | 5599 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5451 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, | 5600 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5601 | .any, |
| 5452 | }, | 5602 | }, |
| 5453 | .patterns = &.{ | 5603 | .patterns = &.{ |
| 5454 | .{ .src = .{ .mem, .mem } }, | 5604 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5455 | .{ .src = .{ .to_sse, .mem } }, | 5605 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 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, | | |
| 5469 | }, | 5606 | }, |
| 5470 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 5607 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5471 | .each = .{ .once = &.{ | 5608 | .each = .{ .once = &.{ |
| 5472 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 5609 | .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ }, |
| 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(.{}), ._ }, | | |
| 5478 | } }, | 5610 | } }, |
| 5479 | }, .{ | 5611 | }, .{ |
| 5480 | .required_features = .{ .f16c, null, null, null }, | 5612 | .required_features = .{ .sse2, null, null, null }, |
| 5481 | .src_constraints = .{ | 5613 | .src_constraints = .{ |
| 5482 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, | 5614 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5483 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, | 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 | .patterns = &.{ | 5633 | .patterns = &.{ |
| 5486 | .{ .src = .{ .mem, .mem } }, | 5634 | .{ .src = .{ .mem, .mem, .none } }, |
| 5487 | .{ .src = .{ .to_sse, .mem } }, | | |
| 5488 | .{ .src = .{ .mem, .to_sse } }, | | |
| 5489 | .{ .src = .{ .to_sse, .to_sse } }, | | |
| 5490 | }, | 5635 | }, |
| 5491 | .extra_temps = .{ | 5636 | .extra_temps = .{ |
| 5492 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 5637 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 5493 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 5638 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 5494 | .unused, | 5639 | .unused, |
| 5495 | .unused, | 5640 | .unused, |
| 5496 | .unused, | 5641 | .unused, |
| ... | @@ -5499,96 +5644,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5499,96 +5644,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5499 | .unused, | 5644 | .unused, |
| 5500 | .unused, | 5645 | .unused, |
| 5501 | }, | 5646 | }, |
| 5502 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 5647 | .dst_temps = .{.mem}, |
| 5503 | .each = .{ .once = &.{ | 5648 | .each = .{ .once = &.{ |
| 5504 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, | 5649 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 5505 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, | 5650 | .{ ._, .f_, .ld, .src1q, ._, ._, ._ }, |
| 5506 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, | 5651 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5507 | .{ ._, .v_ps, .max, .dst0y, .tmp0y, .dst0y, ._ }, | 5652 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 5508 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, | | |
| 5509 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0y, .rm(.{}), ._ }, | | |
| 5510 | } }, | 5653 | } }, |
| 5511 | }, .{ | 5654 | }, .{ |
| 5512 | .required_features = .{ .f16c, null, null, null }, | 5655 | .required_features = .{ .avx, null, null, null }, |
| 5513 | .src_constraints = .{ | 5656 | .src_constraints = .{ |
| 5514 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 5657 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5515 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 5658 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 5659 | .any, |
| 5516 | }, | 5660 | }, |
| 5517 | .patterns = &.{ | 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 = .{ | 5665 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5521 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5666 | .each = .{ .once = &.{ |
| 5522 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 5667 | .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ }, |
| 5523 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 5668 | } }, |
| 5524 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 5669 | }, .{ |
| 5525 | .unused, | 5670 | .required_features = .{ .sse2, null, null, null }, |
| 5526 | .unused, | 5671 | .src_constraints = .{ |
| 5527 | .unused, | 5672 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5528 | .unused, | 5673 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5529 | .unused, | 5674 | .any, |
| 5530 | }, | 5675 | }, |
| 5531 | .dst_temps = .{.mem}, | 5676 | .patterns = &.{ |
| 5532 | .clobbers = .{ .eflags = true }, | 5677 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 5678 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 5679 | }, |
| | 5680 | .dst_temps = .{.{ .ref = .src0 }}, |
| 5533 | .each = .{ .once = &.{ | 5681 | .each = .{ .once = &.{ |
| 5534 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5682 | .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 5543 | } }, | 5683 | } }, |
| 5544 | }, .{ | 5684 | }, .{ |
| 5545 | .required_features = .{ .avx, null, null, null }, | 5685 | .required_features = .{ .avx, null, null, null }, |
| 5546 | .src_constraints = .{ | 5686 | .src_constraints = .{ |
| 5547 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5687 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 5548 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5688 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 5689 | .any, |
| 5549 | }, | 5690 | }, |
| 5550 | .patterns = &.{ | 5691 | .patterns = &.{ |
| 5551 | .{ .src = .{ .to_mem, .to_mem } }, | 5692 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 5552 | }, | 5693 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 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, | | |
| 5564 | }, | 5694 | }, |
| 5565 | .dst_temps = .{.mem}, | 5695 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 5566 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 5567 | .each = .{ .once = &.{ | 5696 | .each = .{ .once = &.{ |
| 5568 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5697 | .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 5576 | } }, | 5698 | } }, |
| 5577 | }, .{ | 5699 | }, .{ |
| 5578 | .required_features = .{ .sse4_1, null, null, null }, | 5700 | .required_features = .{ .avx, null, null, null }, |
| 5579 | .src_constraints = .{ | 5701 | .src_constraints = .{ |
| 5580 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5702 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 5581 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5703 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 5704 | .any, |
| 5582 | }, | 5705 | }, |
| 5583 | .patterns = &.{ | 5706 | .patterns = &.{ |
| 5584 | .{ .src = .{ .to_mem, .to_mem } }, | 5707 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5585 | }, | 5708 | }, |
| 5586 | .call_frame = .{ .alignment = .@"16" }, | | |
| 5587 | .extra_temps = .{ | 5709 | .extra_temps = .{ |
| 5588 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5710 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5589 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 5711 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 5590 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 5712 | .unused, |
| 5591 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, | 5713 | .unused, |
| 5592 | .unused, | 5714 | .unused, |
| 5593 | .unused, | 5715 | .unused, |
| 5594 | .unused, | 5716 | .unused, |
| ... | @@ -5596,103 +5718,90 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5596,103 +5718,90 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5596 | .unused, | 5718 | .unused, |
| 5597 | }, | 5719 | }, |
| 5598 | .dst_temps = .{.mem}, | 5720 | .dst_temps = .{.mem}, |
| 5599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 5721 | .clobbers = .{ .eflags = true }, |
| 5600 | .each = .{ .once = &.{ | 5722 | .each = .{ .once = &.{ |
| 5601 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5723 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5602 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 5724 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5603 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, | 5725 | .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 5604 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, | 5726 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 5605 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, | 5727 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 5606 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | | |
| 5607 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_size), .tmp1x, .ui(0), ._ }, | | |
| 5608 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 5609 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5728 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5610 | } }, | 5729 | } }, |
| 5611 | }, .{ | 5730 | }, .{ |
| 5612 | .required_features = .{ .sse2, null, null, null }, | 5731 | .required_features = .{ .sse2, null, null, null }, |
| 5613 | .src_constraints = .{ | 5732 | .src_constraints = .{ |
| 5614 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5733 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 5615 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5734 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 5735 | .any, |
| 5616 | }, | 5736 | }, |
| 5617 | .patterns = &.{ | 5737 | .patterns = &.{ |
| 5618 | .{ .src = .{ .to_mem, .to_mem } }, | 5738 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5619 | }, | 5739 | }, |
| 5620 | .call_frame = .{ .alignment = .@"16" }, | | |
| 5621 | .extra_temps = .{ | 5740 | .extra_temps = .{ |
| 5622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5741 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5623 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 5742 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 5624 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 5743 | .unused, |
| 5625 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, | 5744 | .unused, |
| 5626 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 5745 | .unused, |
| 5627 | .unused, | 5746 | .unused, |
| 5628 | .unused, | 5747 | .unused, |
| 5629 | .unused, | 5748 | .unused, |
| 5630 | .unused, | 5749 | .unused, |
| 5631 | }, | 5750 | }, |
| 5632 | .dst_temps = .{.mem}, | 5751 | .dst_temps = .{.mem}, |
| 5633 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 5752 | .clobbers = .{ .eflags = true }, |
| 5634 | .each = .{ .once = &.{ | 5753 | .each = .{ .once = &.{ |
| 5635 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5754 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5636 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 5755 | .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5637 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, | 5756 | .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5638 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_size), .ui(0), ._ }, | 5757 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5639 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_size), .ui(0), ._ }, | 5758 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5640 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | | |
| 5641 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, | | |
| 5642 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp4w, ._, ._ }, | | |
| 5643 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 5644 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5759 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5645 | } }, | 5760 | } }, |
| 5646 | }, .{ | 5761 | }, .{ |
| 5647 | .required_features = .{ .sse, null, null, null }, | 5762 | .required_features = .{ .x87, null, null, null }, |
| 5648 | .src_constraints = .{ | 5763 | .src_constraints = .{ |
| 5649 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5764 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 5650 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 5765 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 5766 | .any, |
| 5651 | }, | 5767 | }, |
| 5652 | .patterns = &.{ | 5768 | .patterns = &.{ |
| 5653 | .{ .src = .{ .to_mem, .to_mem } }, | 5769 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5654 | }, | 5770 | }, |
| 5655 | .call_frame = .{ .alignment = .@"16" }, | | |
| 5656 | .extra_temps = .{ | 5771 | .extra_temps = .{ |
| 5657 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5658 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 5773 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 5659 | .{ .type = .f32, .kind = .mem }, | 5774 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 5660 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 5775 | .unused, |
| 5661 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 5776 | .unused, |
| 5662 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, | 5777 | .unused, |
| 5663 | .unused, | 5778 | .unused, |
| 5664 | .unused, | 5779 | .unused, |
| 5665 | .unused, | 5780 | .unused, |
| 5666 | }, | 5781 | }, |
| 5667 | .dst_temps = .{.mem}, | 5782 | .dst_temps = .{.mem}, |
| 5668 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 5669 | .each = .{ .once = &.{ | 5783 | .each = .{ .once = &.{ |
| 5670 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5784 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5671 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 5785 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5672 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, | 5786 | .{ ._, .f_, .ld, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5673 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, | 5787 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5674 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_size), ._, ._ }, | 5788 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5675 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, | 5789 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 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), ._, ._ }, | | |
| 5682 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5790 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5683 | } }, | 5791 | } }, |
| 5684 | }, .{ | 5792 | }, .{ |
| 5685 | .required_features = .{ .avx, null, null, null }, | 5793 | .required_features = .{ .x87, null, null, null }, |
| 5686 | .src_constraints = .{ | 5794 | .src_constraints = .{ |
| 5687 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 5795 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5688 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 5796 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5797 | .any, |
| 5689 | }, | 5798 | }, |
| 5690 | .patterns = &.{ | 5799 | .patterns = &.{ |
| 5691 | .{ .src = .{ .to_sse, .to_sse } }, | 5800 | .{ .src = .{ .mem, .mem, .none } }, |
| 5692 | }, | 5801 | }, |
| 5693 | .extra_temps = .{ | 5802 | .extra_temps = .{ |
| 5694 | .{ .type = .f32, .kind = .{ .rc = .sse } }, | 5803 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 5695 | .unused, | 5804 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5696 | .unused, | 5805 | .unused, |
| 5697 | .unused, | 5806 | .unused, |
| 5698 | .unused, | 5807 | .unused, |
| ... | @@ -5701,39 +5810,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5701,39 +5810,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5701 | .unused, | 5810 | .unused, |
| 5702 | .unused, | 5811 | .unused, |
| 5703 | }, | 5812 | }, |
| 5704 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 5813 | .dst_temps = .{.{ .rc = .x87 }}, |
| 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 }}, | | |
| 5720 | .each = .{ .once = &.{ | 5814 | .each = .{ .once = &.{ |
| 5721 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, | 5815 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 5722 | .{ ._, ._ss, .max, .dst0x, .src0x, ._, ._ }, | 5816 | .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, |
| 5723 | .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, | 5817 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5724 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, | 5818 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5725 | } }, | 5819 | } }, |
| 5726 | }, .{ | 5820 | }, .{ |
| 5727 | .required_features = .{ .sse, null, null, null }, | 5821 | .required_features = .{ .x87, null, null, null }, |
| 5728 | .src_constraints = .{ | 5822 | .src_constraints = .{ |
| 5729 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 5823 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5730 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 5824 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5825 | .any, |
| 5731 | }, | 5826 | }, |
| 5732 | .patterns = &.{ | 5827 | .patterns = &.{ |
| 5733 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 5828 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 5734 | }, | 5829 | }, |
| 5735 | .extra_temps = .{ | 5830 | .extra_temps = .{ |
| 5736 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 5831 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5737 | .unused, | 5832 | .unused, |
| 5738 | .unused, | 5833 | .unused, |
| 5739 | .unused, | 5834 | .unused, |
| ... | @@ -5743,26 +5838,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5743,26 +5838,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5743 | .unused, | 5838 | .unused, |
| 5744 | .unused, | 5839 | .unused, |
| 5745 | }, | 5840 | }, |
| 5746 | .dst_temps = .{.{ .ref = .src0 }}, | 5841 | .dst_temps = .{.{ .rc = .x87 }}, |
| 5747 | .each = .{ .once = &.{ | 5842 | .each = .{ .once = &.{ |
| 5748 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, | 5843 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 5749 | .{ ._, ._ss, .max, .tmp0x, .src0x, ._, ._ }, | 5844 | .{ ._, .f_, .divr, .tmp0t, .src1t, ._, ._ }, |
| 5750 | .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, | 5845 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5751 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, | | |
| 5752 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, | | |
| 5753 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, | | |
| 5754 | } }, | 5846 | } }, |
| 5755 | }, .{ | 5847 | }, .{ |
| 5756 | .required_features = .{ .avx, null, null, null }, | 5848 | .required_features = .{ .x87, null, null, null }, |
| 5757 | .src_constraints = .{ | 5849 | .src_constraints = .{ |
| 5758 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 5850 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5759 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 5851 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5852 | .any, |
| 5760 | }, | 5853 | }, |
| 5761 | .patterns = &.{ | 5854 | .patterns = &.{ |
| 5762 | .{ .src = .{ .to_sse, .to_sse } }, | 5855 | .{ .src = .{ .mem, .to_x87, .none } }, |
| | 5856 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 5763 | }, | 5857 | }, |
| 5764 | .extra_temps = .{ | 5858 | .extra_temps = .{ |
| 5765 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 5859 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5766 | .unused, | 5860 | .unused, |
| 5767 | .unused, | 5861 | .unused, |
| 5768 | .unused, | 5862 | .unused, |
| ... | @@ -5772,45 +5866,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5772,45 +5866,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5772 | .unused, | 5866 | .unused, |
| 5773 | .unused, | 5867 | .unused, |
| 5774 | }, | 5868 | }, |
| 5775 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 5869 | .dst_temps = .{.{ .rc = .x87 }}, |
| 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 }}, | | |
| 5793 | .each = .{ .once = &.{ | 5870 | .each = .{ .once = &.{ |
| 5794 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, | 5871 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 5795 | .{ ._, ._ps, .max, .dst0x, .src0x, ._, ._ }, | 5872 | .{ ._, .f_, .div, .tmp0t, .src1t, ._, ._ }, |
| 5796 | .{ ._, ._ps, .cmp, .src0x, .src0x, .vp(.unord), ._ }, | 5873 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 5797 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, | | |
| 5798 | } }, | 5874 | } }, |
| 5799 | }, .{ | 5875 | }, .{ |
| 5800 | .required_features = .{ .sse, null, null, null }, | 5876 | .required_features = .{ .x87, null, null, null }, |
| 5801 | .src_constraints = .{ | 5877 | .src_constraints = .{ |
| 5802 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 5878 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 5803 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 5879 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 5880 | .any, |
| 5804 | }, | 5881 | }, |
| 5805 | .patterns = &.{ | 5882 | .patterns = &.{ |
| 5806 | .{ .src = .{ .to_mut_sse, .mem } }, | 5883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5807 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | | |
| 5808 | .{ .src = .{ .to_mut_sse, .to_sse } }, | | |
| 5809 | }, | 5884 | }, |
| 5810 | .extra_temps = .{ | 5885 | .extra_temps = .{ |
| 5811 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 5886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5812 | .unused, | 5887 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| 5813 | .unused, | 5888 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 5814 | .unused, | 5889 | .unused, |
| 5815 | .unused, | 5890 | .unused, |
| 5816 | .unused, | 5891 | .unused, |
| ... | @@ -5818,26 +5893,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5818,26 +5893,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5818 | .unused, | 5893 | .unused, |
| 5819 | .unused, | 5894 | .unused, |
| 5820 | }, | 5895 | }, |
| 5821 | .dst_temps = .{.{ .ref = .src0 }}, | 5896 | .dst_temps = .{.mem}, |
| 5822 | .each = .{ .once = &.{ | 5897 | .each = .{ .once = &.{ |
| 5823 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, | 5898 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5824 | .{ ._, ._ps, .max, .tmp0x, .src0x, ._, ._ }, | 5899 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5825 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, | 5900 | .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5826 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, | 5901 | .{ ._, .f_p, .div, ._, ._, ._, ._ }, |
| 5827 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, | 5902 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 5828 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, | 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 | .src_constraints = .{ | 5908 | .src_constraints = .{ |
| 5833 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, | 5909 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5834 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, | 5910 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5911 | .any, |
| 5835 | }, | 5912 | }, |
| 5836 | .patterns = &.{ | 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 | .extra_temps = .{ | 5917 | .extra_temps = .{ |
| 5840 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, | 5918 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5841 | .unused, | 5919 | .unused, |
| 5842 | .unused, | 5920 | .unused, |
| 5843 | .unused, | 5921 | .unused, |
| ... | @@ -5847,26 +5925,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5847,26 +5925,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5847 | .unused, | 5925 | .unused, |
| 5848 | .unused, | 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 | .each = .{ .once = &.{ | 5930 | .each = .{ .once = &.{ |
| 5852 | .{ ._, .v_ps, .cmp, .tmp0y, .src0y, .src0y, .vp(.unord) }, | 5931 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 5853 | .{ ._, .v_ps, .max, .dst0y, .src1y, .src0y, ._ }, | | |
| 5854 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .src1y, .tmp0y }, | | |
| 5855 | } }, | 5932 | } }, |
| 5856 | }, .{ | 5933 | }, .{ |
| 5857 | .required_features = .{ .avx, null, null, null }, | 5934 | .required_features = .{ .avx, null, null, null }, |
| 5858 | .src_constraints = .{ | 5935 | .src_constraints = .{ |
| 5859 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 5936 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5860 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 5937 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5938 | .any, |
| 5861 | }, | 5939 | }, |
| 5862 | .patterns = &.{ | 5940 | .patterns = &.{ |
| 5863 | .{ .src = .{ .to_mem, .to_mem } }, | 5941 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5864 | }, | 5942 | }, |
| | 5943 | .call_frame = .{ .alignment = .@"16" }, |
| 5865 | .extra_temps = .{ | 5944 | .extra_temps = .{ |
| 5866 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5945 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5867 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, | 5946 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5868 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, | 5947 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5869 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, | 5948 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5870 | .unused, | 5949 | .unused, |
| 5871 | .unused, | 5950 | .unused, |
| 5872 | .unused, | 5951 | .unused, |
| ... | @@ -5874,32 +5953,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5874,32 +5953,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5874 | .unused, | 5953 | .unused, |
| 5875 | }, | 5954 | }, |
| 5876 | .dst_temps = .{.mem}, | 5955 | .dst_temps = .{.mem}, |
| 5877 | .clobbers = .{ .eflags = true }, | 5956 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5878 | .each = .{ .once = &.{ | 5957 | .each = .{ .once = &.{ |
| 5879 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5958 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5880 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 5959 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5881 | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_size), ._, ._ }, | 5960 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5882 | .{ ._, .v_ps, .cmp, .tmp3y, .tmp1y, .tmp1y, .vp(.unord) }, | 5961 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5883 | .{ ._, .v_ps, .max, .tmp1y, .tmp2y, .tmp1y, ._ }, | 5962 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5884 | .{ ._, .v_ps, .blendv, .tmp1y, .tmp1y, .tmp2y, .tmp3y }, | 5963 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5885 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp1y, ._, ._ }, | | |
| 5886 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | | |
| 5887 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5964 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5888 | } }, | 5965 | } }, |
| 5889 | }, .{ | 5966 | }, .{ |
| 5890 | .required_features = .{ .sse4_1, null, null, null }, | 5967 | .required_features = .{ .sse2, null, null, null }, |
| 5891 | .src_constraints = .{ | 5968 | .src_constraints = .{ |
| 5892 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 5969 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5893 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 5970 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 5971 | .any, |
| 5894 | }, | 5972 | }, |
| 5895 | .patterns = &.{ | 5973 | .patterns = &.{ |
| 5896 | .{ .src = .{ .to_mem, .to_mem } }, | 5974 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5897 | }, | 5975 | }, |
| | 5976 | .call_frame = .{ .alignment = .@"16" }, |
| 5898 | .extra_temps = .{ | 5977 | .extra_temps = .{ |
| 5899 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 5978 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5900 | .{ .type = .vector_4_f32, .kind = .{ .reg = .xmm0 } }, | 5979 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5901 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 5980 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5902 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 5981 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5903 | .unused, | 5982 | .unused, |
| 5904 | .unused, | 5983 | .unused, |
| 5905 | .unused, | 5984 | .unused, |
| ... | @@ -5907,33 +5986,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5907,33 +5986,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5907 | .unused, | 5986 | .unused, |
| 5908 | }, | 5987 | }, |
| 5909 | .dst_temps = .{.mem}, | 5988 | .dst_temps = .{.mem}, |
| 5910 | .clobbers = .{ .eflags = true }, | 5989 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5911 | .each = .{ .once = &.{ | 5990 | .each = .{ .once = &.{ |
| 5912 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 5991 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5913 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 5992 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5914 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 5993 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5915 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 5994 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 5916 | .{ ._, ._ps, .max, .tmp3x, .tmp1x, ._, ._ }, | 5995 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 5917 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, | | |
| 5918 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, | | |
| 5919 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | | |
| 5920 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 5996 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 5921 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 5997 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5922 | } }, | 5998 | } }, |
| 5923 | }, .{ | 5999 | }, .{ |
| 5924 | .required_features = .{ .sse, null, null, null }, | 6000 | .required_features = .{ .sse, null, null, null }, |
| 5925 | .src_constraints = .{ | 6001 | .src_constraints = .{ |
| 5926 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 6002 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 5927 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 6003 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 6004 | .any, |
| 5928 | }, | 6005 | }, |
| 5929 | .patterns = &.{ | 6006 | .patterns = &.{ |
| 5930 | .{ .src = .{ .to_mem, .to_mem } }, | 6007 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5931 | }, | 6008 | }, |
| | 6009 | .call_frame = .{ .alignment = .@"16" }, |
| 5932 | .extra_temps = .{ | 6010 | .extra_temps = .{ |
| 5933 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 6011 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5934 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 6012 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 5935 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 6013 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 5936 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 6014 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } }, |
| 5937 | .unused, | 6015 | .unused, |
| 5938 | .unused, | 6016 | .unused, |
| 5939 | .unused, | 6017 | .unused, |
| ... | @@ -5941,712 +6019,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5941,712 +6019,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5941 | .unused, | 6019 | .unused, |
| 5942 | }, | 6020 | }, |
| 5943 | .dst_temps = .{.mem}, | 6021 | .dst_temps = .{.mem}, |
| 5944 | .clobbers = .{ .eflags = true }, | 6022 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 5945 | .each = .{ .once = &.{ | 6023 | .each = .{ .once = &.{ |
| 5946 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 6024 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5947 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 6025 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5948 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 6026 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_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), ._, ._ }, | | |
| 6289 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 6027 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6290 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 6028 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 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, ._, ._ }, | | |
| 6650 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 6029 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6651 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 6030 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6652 | } }, | 6031 | } }, |
| ... | @@ -6661,455 +6040,7677 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6661,455 +6040,7677 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6661 | }; | 6040 | }; |
| 6662 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 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 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 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 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 6046 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 6667 | var res: [1]Temp = undefined; | 6047 | var res: [1]Temp = undefined; |
| 6668 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 6048 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) { |
| 6669 | .required_features = .{ .cmov, null, null, null }, | 6049 | else => unreachable, |
| 6670 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, | 6050 | .div_trunc => .zero, |
| 6671 | .patterns = &.{ | 6051 | .div_floor => .down, |
| 6672 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6052 | })) { |
| 6673 | }, | 6053 | else => unreachable, |
| 6674 | .dst_temps = .{.{ .ref = .src0 }}, | 6054 | inline .zero, .down => |direction| comptime &.{ .{ |
| 6675 | .clobbers = .{ .eflags = true }, | 6055 | .required_features = .{ .f16c, null, null, null }, |
| 6676 | .each = .{ .once = &.{ | 6056 | .src_constraints = .{ |
| 6677 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 6057 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6678 | .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ }, | 6058 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6679 | } }, | 6059 | .any, |
| 6680 | }, .{ | 6060 | }, |
| 6681 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte } }, | 6061 | .patterns = &.{ |
| 6682 | .patterns = &.{ | 6062 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6683 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6063 | }, |
| 6684 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6064 | .extra_temps = .{ |
| 6685 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6065 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 6686 | }, | 6066 | .unused, |
| 6687 | .dst_temps = .{.{ .ref = .src0 }}, | 6067 | .unused, |
| 6688 | .clobbers = .{ .eflags = true }, | 6068 | .unused, |
| 6689 | .each = .{ .once = &.{ | 6069 | .unused, |
| 6690 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 6070 | .unused, |
| 6691 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, | 6071 | .unused, |
| 6692 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, | 6072 | .unused, |
| 6693 | } }, | 6073 | .unused, |
| 6694 | }, .{ | 6074 | }, |
| 6695 | .required_features = .{ .cmov, null, null, null }, | 6075 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6696 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, | 6076 | .each = .{ .once = &.{ |
| 6697 | .patterns = &.{ | 6077 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 6698 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6078 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 6699 | }, | 6079 | .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ }, |
| 6700 | .dst_temps = .{.{ .ref = .src0 }}, | 6080 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6701 | .clobbers = .{ .eflags = true }, | 6081 | .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ }, |
| 6702 | .each = .{ .once = &.{ | 6082 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 6703 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 6083 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6704 | .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ }, | 6084 | } }, |
| 6705 | } }, | 6085 | }, .{ |
| 6706 | }, .{ | 6086 | .required_features = .{ .sse, null, null, null }, |
| 6707 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte } }, | 6087 | .src_constraints = .{ |
| 6708 | .patterns = &.{ | 6088 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6709 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6089 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 6710 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6090 | .any, |
| 6711 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6091 | }, |
| 6712 | }, | 6092 | .patterns = &.{ |
| 6713 | .dst_temps = .{.{ .ref = .src0 }}, | 6093 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 6714 | .clobbers = .{ .eflags = true }, | 6094 | }, |
| 6715 | .each = .{ .once = &.{ | 6095 | .call_frame = .{ .alignment = .@"16" }, |
| 6716 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 6096 | .extra_temps = .{ |
| 6717 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, | 6097 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6718 | .{ ._, ._, .mov, .dst0b, .src1b, ._, ._ }, | 6098 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6719 | } }, | 6099 | else => unreachable, |
| 6720 | }, .{ | 6100 | .zero => "__trunch", |
| 6721 | .required_features = .{ .cmov, null, null, null }, | 6101 | .down => "__floorh", |
| 6722 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, | 6102 | } } } }, |
| 6723 | .patterns = &.{ | 6103 | .unused, |
| 6724 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6104 | .unused, |
| 6725 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6105 | .unused, |
| 6726 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6106 | .unused, |
| 6727 | }, | 6107 | .unused, |
| 6728 | .dst_temps = .{.{ .ref = .src0 }}, | 6108 | .unused, |
| 6729 | .clobbers = .{ .eflags = true }, | 6109 | .unused, |
| 6730 | .each = .{ .once = &.{ | 6110 | }, |
| 6731 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 6111 | .dst_temps = .{.{ .ref = .src0 }}, |
| 6732 | .{ ._, ._ge, .cmov, .dst0w, .src1w, ._, ._ }, | 6112 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6733 | } }, | 6113 | .each = .{ .once = &.{ |
| 6734 | }, .{ | 6114 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 6735 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word } }, | 6115 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 6736 | .patterns = &.{ | 6116 | } }, |
| 6737 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6117 | }, .{ |
| 6738 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6118 | .required_features = .{ .f16c, null, null, null }, |
| 6739 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6119 | .src_constraints = .{ |
| 6740 | }, | 6120 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 6741 | .dst_temps = .{.{ .ref = .src0 }}, | 6121 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 6742 | .clobbers = .{ .eflags = true }, | 6122 | .any, |
| 6743 | .each = .{ .once = &.{ | 6123 | }, |
| 6744 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 6124 | .patterns = &.{ |
| 6745 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, | 6125 | .{ .src = .{ .mem, .mem, .none } }, |
| 6746 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, | 6126 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6747 | } }, | 6127 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 6748 | }, .{ | 6128 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6749 | .required_features = .{ .cmov, null, null, null }, | 6129 | }, |
| 6750 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, | 6130 | .extra_temps = .{ |
| 6751 | .patterns = &.{ | 6131 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 6752 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6132 | .unused, |
| 6753 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6133 | .unused, |
| 6754 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6134 | .unused, |
| 6755 | }, | 6135 | .unused, |
| 6756 | .dst_temps = .{.{ .ref = .src0 }}, | 6136 | .unused, |
| 6757 | .clobbers = .{ .eflags = true }, | 6137 | .unused, |
| 6758 | .each = .{ .once = &.{ | 6138 | .unused, |
| 6759 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 6139 | .unused, |
| 6760 | .{ ._, ._ae, .cmov, .dst0w, .src1w, ._, ._ }, | 6140 | }, |
| 6761 | } }, | 6141 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6762 | }, .{ | 6142 | .each = .{ .once = &.{ |
| 6763 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word } }, | 6143 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 6764 | .patterns = &.{ | 6144 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 6765 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6145 | .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ }, |
| 6766 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6146 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6767 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6147 | .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ }, |
| 6768 | }, | 6148 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6769 | .dst_temps = .{.{ .ref = .src0 }}, | 6149 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 6770 | .clobbers = .{ .eflags = true }, | 6150 | } }, |
| 6771 | .each = .{ .once = &.{ | 6151 | }, .{ |
| 6772 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 6152 | .required_features = .{ .f16c, null, null, null }, |
| 6773 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, | 6153 | .src_constraints = .{ |
| 6774 | .{ ._, ._, .mov, .dst0w, .src1w, ._, ._ }, | 6154 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 6775 | } }, | 6155 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 6776 | }, .{ | 6156 | .any, |
| 6777 | .required_features = .{ .cmov, null, null, null }, | 6157 | }, |
| 6778 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, | 6158 | .patterns = &.{ |
| 6779 | .patterns = &.{ | 6159 | .{ .src = .{ .mem, .mem, .none } }, |
| 6780 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6160 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 6781 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6161 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 6782 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6162 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 6783 | }, | 6163 | }, |
| 6784 | .dst_temps = .{.{ .ref = .src0 }}, | 6164 | .extra_temps = .{ |
| 6785 | .clobbers = .{ .eflags = true }, | 6165 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 6786 | .each = .{ .once = &.{ | 6166 | .unused, |
| 6787 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 6167 | .unused, |
| 6788 | .{ ._, ._ge, .cmov, .dst0d, .src1d, ._, ._ }, | 6168 | .unused, |
| 6789 | } }, | 6169 | .unused, |
| 6790 | }, .{ | 6170 | .unused, |
| 6791 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword } }, | 6171 | .unused, |
| 6792 | .patterns = &.{ | 6172 | .unused, |
| 6793 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6173 | .unused, |
| 6794 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6174 | }, |
| 6795 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6175 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 6796 | }, | 6176 | .each = .{ .once = &.{ |
| 6797 | .dst_temps = .{.{ .ref = .src0 }}, | 6177 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 6798 | .clobbers = .{ .eflags = true }, | 6178 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 6799 | .each = .{ .once = &.{ | 6179 | .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ }, |
| 6800 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 6180 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 6801 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, | 6181 | .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ }, |
| 6802 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, | 6182 | .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6803 | } }, | 6183 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 6804 | }, .{ | 6184 | } }, |
| 6805 | .required_features = .{ .cmov, null, null, null }, | 6185 | }, .{ |
| 6806 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, | 6186 | .required_features = .{ .f16c, null, null, null }, |
| 6807 | .patterns = &.{ | 6187 | .src_constraints = .{ |
| 6808 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6188 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 6809 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6189 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 6810 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6190 | .any, |
| 6811 | }, | 6191 | }, |
| 6812 | .dst_temps = .{.{ .ref = .src0 }}, | 6192 | .patterns = &.{ |
| 6813 | .clobbers = .{ .eflags = true }, | 6193 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6814 | .each = .{ .once = &.{ | 6194 | }, |
| 6815 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 6195 | .extra_temps = .{ |
| 6816 | .{ ._, ._ae, .cmov, .dst0d, .src1d, ._, ._ }, | 6196 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6817 | } }, | 6197 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 6818 | }, .{ | 6198 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 6819 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword } }, | 6199 | .unused, |
| 6820 | .patterns = &.{ | 6200 | .unused, |
| 6821 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6201 | .unused, |
| 6822 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6202 | .unused, |
| 6823 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6203 | .unused, |
| 6824 | }, | 6204 | .unused, |
| 6825 | .dst_temps = .{.{ .ref = .src0 }}, | 6205 | }, |
| 6826 | .clobbers = .{ .eflags = true }, | 6206 | .dst_temps = .{.mem}, |
| 6827 | .each = .{ .once = &.{ | 6207 | .clobbers = .{ .eflags = true }, |
| 6828 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 6208 | .each = .{ .once = &.{ |
| 6829 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, | 6209 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6830 | .{ ._, ._, .mov, .dst0d, .src1d, ._, ._ }, | 6210 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6831 | } }, | 6211 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6832 | }, .{ | 6212 | .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ }, |
| 6833 | .required_features = .{ .@"64bit", .cmov, null, null }, | 6213 | .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ }, |
| 6834 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, | 6214 | .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ }, |
| 6835 | .patterns = &.{ | 6215 | .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 6836 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6216 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 6837 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6217 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 6838 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6218 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6839 | }, | 6219 | } }, |
| 6840 | .dst_temps = .{.{ .ref = .src0 }}, | 6220 | }, .{ |
| 6841 | .clobbers = .{ .eflags = true }, | 6221 | .required_features = .{ .avx, null, null, null }, |
| 6842 | .each = .{ .once = &.{ | 6222 | .src_constraints = .{ |
| 6843 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 6223 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6844 | .{ ._, ._ge, .cmov, .dst0q, .src1q, ._, ._ }, | 6224 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6845 | } }, | 6225 | .any, |
| 6846 | }, .{ | 6226 | }, |
| 6847 | .required_features = .{ .@"64bit", null, null, null }, | 6227 | .patterns = &.{ |
| 6848 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword } }, | 6228 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6849 | .patterns = &.{ | 6229 | }, |
| 6850 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6230 | .call_frame = .{ .alignment = .@"16" }, |
| 6851 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6231 | .extra_temps = .{ |
| 6852 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6853 | }, | 6233 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6854 | .dst_temps = .{.{ .ref = .src0 }}, | 6234 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6855 | .clobbers = .{ .eflags = true }, | 6235 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6856 | .each = .{ .once = &.{ | 6236 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6857 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 6237 | else => unreachable, |
| 6858 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, | 6238 | .zero => "__trunch", |
| 6859 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, | 6239 | .down => "__floorh", |
| 6860 | } }, | 6240 | } } } }, |
| 6861 | }, .{ | 6241 | .unused, |
| 6862 | .required_features = .{ .@"64bit", .cmov, null, null }, | 6242 | .unused, |
| 6863 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, | 6243 | .unused, |
| 6864 | .patterns = &.{ | 6244 | .unused, |
| 6865 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6245 | }, |
| 6866 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6246 | .dst_temps = .{.mem}, |
| 6867 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6247 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6868 | }, | 6248 | .each = .{ .once = &.{ |
| 6869 | .dst_temps = .{.{ .ref = .src0 }}, | 6249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6870 | .clobbers = .{ .eflags = true }, | 6250 | .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| 6871 | .each = .{ .once = &.{ | 6251 | .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 6872 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 6252 | .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 6873 | .{ ._, ._ae, .cmov, .dst0q, .src1q, ._, ._ }, | 6253 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6874 | } }, | 6254 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6875 | }, .{ | 6255 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 6876 | .required_features = .{ .@"64bit", null, null, null }, | 6256 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6877 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword } }, | 6257 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6878 | .patterns = &.{ | 6258 | } }, |
| 6879 | .{ .src = .{ .to_mut_gpr, .mem } }, | 6259 | }, .{ |
| 6880 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 6260 | .required_features = .{ .sse4_1, null, null, null }, |
| 6881 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 6261 | .src_constraints = .{ |
| 6882 | }, | 6262 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6883 | .dst_temps = .{.{ .ref = .src0 }}, | 6263 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6884 | .clobbers = .{ .eflags = true }, | 6264 | .any, |
| 6885 | .each = .{ .once = &.{ | 6265 | }, |
| 6886 | .{ ._, ._, .cmp, .src0q, .src1q, ._, ._ }, | 6266 | .patterns = &.{ |
| 6887 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, | 6267 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6888 | .{ ._, ._, .mov, .dst0q, .src1q, ._, ._ }, | 6268 | }, |
| 6889 | } }, | 6269 | .call_frame = .{ .alignment = .@"16" }, |
| 6890 | }, .{ | 6270 | .extra_temps = .{ |
| 6891 | .required_features = .{ .@"64bit", .cmov, null, null }, | 6271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6892 | .src_constraints = .{ .any_signed_int, .any_signed_int }, | 6272 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6893 | .patterns = &.{ | 6273 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6894 | .{ .src = .{ .to_mem, .to_mem } }, | 6274 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6895 | }, | 6275 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6896 | .extra_temps = .{ | 6276 | else => unreachable, |
| 6897 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 6277 | .zero => "__trunch", |
| 6898 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 6278 | .down => "__floorh", |
| 6899 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 6279 | } } } }, |
| 6900 | .unused, | 6280 | .unused, |
| 6901 | .unused, | 6281 | .unused, |
| 6902 | .unused, | 6282 | .unused, |
| 6903 | .unused, | 6283 | .unused, |
| 6904 | .unused, | 6284 | }, |
| 6905 | .unused, | 6285 | .dst_temps = .{.mem}, |
| 6906 | }, | 6286 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6907 | .dst_temps = .{.mem}, | 6287 | .each = .{ .once = &.{ |
| 6908 | .clobbers = .{ .eflags = true }, | 6288 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6909 | .each = .{ .once = &.{ | 6289 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6910 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 6290 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6911 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 6291 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6912 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 6292 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6913 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 6293 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6914 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 6294 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6915 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 6295 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 6916 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, | 6296 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6917 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, | 6297 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6918 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 6298 | } }, |
| 6919 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, | 6299 | }, .{ |
| 6920 | .{ ._, ._ge, .cmov, .tmp0p, .tmp1p, ._, ._ }, | 6300 | .required_features = .{ .sse2, null, null, null }, |
| 6921 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 6301 | .src_constraints = .{ |
| 6922 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 6302 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6923 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 6303 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6924 | } }, | 6304 | .any, |
| 6925 | }, .{ | 6305 | }, |
| 6926 | .required_features = .{ .@"64bit", null, null, null }, | 6306 | .patterns = &.{ |
| 6927 | .src_constraints = .{ .any_signed_int, .any_signed_int }, | 6307 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6928 | .patterns = &.{ | 6308 | }, |
| 6929 | .{ .src = .{ .to_mem, .to_mem } }, | 6309 | .call_frame = .{ .alignment = .@"16" }, |
| 6930 | }, | 6310 | .extra_temps = .{ |
| 6931 | .extra_temps = .{ | 6311 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6932 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 6312 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6933 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 6313 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6934 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 6314 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6935 | .unused, | 6315 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6936 | .unused, | 6316 | else => unreachable, |
| 6937 | .unused, | 6317 | .zero => "__trunch", |
| 6938 | .unused, | 6318 | .down => "__floorh", |
| 6939 | .unused, | 6319 | } } } }, |
| 6940 | .unused, | 6320 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 6941 | }, | 6321 | .unused, |
| 6942 | .dst_temps = .{.mem}, | 6322 | .unused, |
| 6943 | .clobbers = .{ .eflags = true }, | 6323 | .unused, |
| 6944 | .each = .{ .once = &.{ | 6324 | }, |
| 6945 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 6325 | .dst_temps = .{.mem}, |
| 6946 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 6326 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6947 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 6327 | .each = .{ .once = &.{ |
| 6948 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 6328 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6949 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 6329 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 6950 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 6330 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 6951 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, | 6331 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6952 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, | 6332 | .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 6953 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 6333 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 6954 | .{ ._, ._nge, .j, .@"0f", ._, ._, ._ }, | 6334 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 6955 | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, | 6335 | .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ }, |
| 6956 | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 6336 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ }, |
| 6957 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 6337 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 6958 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 6338 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6959 | } }, | 6339 | } }, |
| 6960 | }, .{ | 6340 | }, .{ |
| 6961 | .required_features = .{ .@"64bit", .cmov, null, null }, | 6341 | .required_features = .{ .sse, null, null, null }, |
| 6962 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, | 6342 | .src_constraints = .{ |
| 6963 | .patterns = &.{ | 6343 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6964 | .{ .src = .{ .to_mem, .to_mem } }, | 6344 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 6965 | }, | 6345 | .any, |
| 6966 | .extra_temps = .{ | 6346 | }, |
| 6967 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 6347 | .patterns = &.{ |
| 6968 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 6348 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6969 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 6349 | }, |
| 6970 | .unused, | 6350 | .call_frame = .{ .alignment = .@"16" }, |
| 6971 | .unused, | 6351 | .extra_temps = .{ |
| 6972 | .unused, | 6352 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 6973 | .unused, | 6353 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 6974 | .unused, | 6354 | .{ .type = .f32, .kind = .mem }, |
| 6975 | .unused, | 6355 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 6976 | }, | 6356 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 6977 | .dst_temps = .{.mem}, | 6357 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } }, |
| 6978 | .clobbers = .{ .eflags = true }, | 6358 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 6979 | .each = .{ .once = &.{ | 6359 | else => unreachable, |
| 6980 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 6360 | .zero => "__trunch", |
| 6981 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 6361 | .down => "__floorh", |
| 6982 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, | 6362 | } } } }, |
| 6983 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, | 6363 | .unused, |
| 6984 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 6364 | .unused, |
| 6985 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 6365 | }, |
| 6986 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 6366 | .dst_temps = .{.mem}, |
| 6987 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, | 6367 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 6988 | .{ ._, ._ae, .cmov, .tmp0p, .tmp1p, ._, ._ }, | 6368 | .each = .{ .once = &.{ |
| 6989 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 6369 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6990 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 6370 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6991 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 6371 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 6992 | } }, | 6372 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 6993 | }, .{ | 6373 | .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 6994 | .required_features = .{ .@"64bit", null, null, null }, | 6374 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 6995 | .src_constraints = .{ .any_unsigned_int, .any_unsigned_int }, | 6375 | .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ }, |
| 6996 | .patterns = &.{ | 6376 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 6997 | .{ .src = .{ .to_mem, .to_mem } }, | 6377 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 6998 | }, | 6378 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ }, |
| 6999 | .extra_temps = .{ | 6379 | .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ }, |
| 7000 | .{ .type = .isize, .kind = .{ .reg = .rsi } }, | 6380 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 7001 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, | 6381 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 7002 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 6382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7003 | .unused, | 6383 | } }, |
| 7004 | .unused, | 6384 | }, .{ |
| 7005 | .unused, | 6385 | .required_features = .{ .avx, null, null, null }, |
| 7006 | .unused, | 6386 | .src_constraints = .{ |
| 7007 | .unused, | 6387 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7008 | .unused, | 6388 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7009 | }, | 6389 | .any, |
| 7010 | .dst_temps = .{.mem}, | 6390 | }, |
| 7011 | .clobbers = .{ .eflags = true }, | 6391 | .patterns = &.{ |
| 7012 | .each = .{ .once = &.{ | 6392 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7013 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 6393 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7014 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 6394 | }, |
| 7015 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, | 6395 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7016 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, | 6396 | .each = .{ .once = &.{ |
| 7017 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 6397 | .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ }, |
| 7018 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 6398 | .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) }, |
| 7019 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 6399 | } }, |
| 7020 | .{ ._, ._nae, .j, .@"0f", ._, ._, ._ }, | 6400 | }, .{ |
| 7021 | .{ ._, ._, .lea, .tmp0p, .mem(.src1), ._, ._ }, | 6401 | .required_features = .{ .sse4_1, null, null, null }, |
| 7022 | .{ .@"0:", ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 6402 | .src_constraints = .{ |
| 7023 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 6403 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7024 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 6404 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7025 | } }, | 6405 | .any, |
| 7026 | }, .{ | 6406 | }, |
| 7027 | .required_features = .{ .avx, null, null, null }, | 6407 | .patterns = &.{ |
| 7028 | .src_constraints = .{ | 6408 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7029 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 6409 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7030 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 6410 | }, |
| 7031 | }, | 6411 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7032 | .patterns = &.{ | 6412 | .each = .{ .once = &.{ |
| 7033 | .{ .src = .{ .to_sse, .mem } }, | 6413 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 7034 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 6414 | .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7035 | .{ .src = .{ .to_sse, .to_sse } }, | 6415 | } }, |
| 7036 | }, | 6416 | }, .{ |
| 7037 | .dst_temps = .{.{ .rc = .sse }}, | 6417 | .required_features = .{ .sse, null, null, null }, |
| 7038 | .each = .{ .once = &.{ | 6418 | .src_constraints = .{ |
| 7039 | .{ ._, .vp_b, .mins, .dst0x, .src0x, .src1x, ._ }, | 6419 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7040 | } }, | 6420 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7041 | }, .{ | 6421 | .any, |
| 7042 | .required_features = .{ .sse4_1, null, null, null }, | 6422 | }, |
| 7043 | .src_constraints = .{ | 6423 | .patterns = &.{ |
| 7044 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 6424 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } }, |
| 7045 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 6425 | }, |
| 7046 | }, | 6426 | .call_frame = .{ .alignment = .@"16" }, |
| 7047 | .patterns = &.{ | 6427 | .extra_temps = .{ |
| 7048 | .{ .src = .{ .to_mut_sse, .mem } }, | 6428 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) { |
| 7049 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 6429 | else => unreachable, |
| 7050 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 6430 | .zero => "truncf", |
| 7051 | }, | 6431 | .down => "floorf", |
| 7052 | .dst_temps = .{.{ .ref = .src0 }}, | 6432 | } } } }, |
| 7053 | .each = .{ .once = &.{ | 6433 | .unused, |
| 7054 | .{ ._, .p_b, .mins, .dst0x, .src1x, ._, ._ }, | 6434 | .unused, |
| 7055 | } }, | 6435 | .unused, |
| 7056 | }, .{ | 6436 | .unused, |
| 7057 | .required_features = .{ .sse2, null, null, null }, | 6437 | .unused, |
| 7058 | .src_constraints = .{ | 6438 | .unused, |
| 7059 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 6439 | .unused, |
| 7060 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 6440 | .unused, |
| 7061 | }, | 6441 | }, |
| 7062 | .patterns = &.{ | 6442 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7063 | .{ .src = .{ .to_mut_sse, .mem } }, | 6443 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7064 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 6444 | .each = .{ .once = &.{ |
| 7065 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 6445 | .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ }, |
| 7066 | }, | 6446 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7067 | .dst_temps = .{.{ .rc = .sse }}, | 6447 | } }, |
| 7068 | .each = .{ .once = &.{ | 6448 | }, .{ |
| 7069 | .{ ._, ._dqa, .mov, .dst0x, .src1x, ._, ._ }, | 6449 | .required_features = .{ .avx, null, null, null }, |
| 7070 | .{ ._, .p_b, .cmpgt, .dst0x, .src0x, ._, ._ }, | 6450 | .src_constraints = .{ |
| 7071 | .{ ._, .p_, .@"and", .src0x, .dst0x, ._, ._ }, | 6451 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7072 | .{ ._, .p_, .andn, .dst0x, .src1x, ._, ._ }, | 6452 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7073 | .{ ._, .p_, .@"or", .dst0x, .src0x, ._, ._ }, | 6453 | .any, |
| 7074 | } }, | 6454 | }, |
| 7075 | }, .{ | 6455 | .patterns = &.{ |
| 7076 | .required_features = .{ .avx2, null, null, null }, | 6456 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7077 | .src_constraints = .{ | 6457 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7078 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, | 6458 | }, |
| 7079 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, | 6459 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 7080 | }, | 6460 | .each = .{ .once = &.{ |
| 7081 | .patterns = &.{ | 6461 | .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ }, |
| 7082 | .{ .src = .{ .to_sse, .mem } }, | 6462 | .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7083 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 6463 | } }, |
| 7084 | .{ .src = .{ .to_sse, .to_sse } }, | 6464 | }, .{ |
| 7085 | }, | 6465 | .required_features = .{ .sse4_1, null, null, null }, |
| 7086 | .dst_temps = .{.{ .rc = .sse }}, | 6466 | .src_constraints = .{ |
| 7087 | .each = .{ .once = &.{ | 6467 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7088 | .{ ._, .vp_b, .mins, .dst0y, .src0y, .src1y, ._ }, | 6468 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 7089 | } }, | 6469 | .any, |
| 7090 | }, .{ | 6470 | }, |
| 7091 | .required_features = .{ .avx2, null, null, null }, | 6471 | .patterns = &.{ |
| 7092 | .src_constraints = .{ | 6472 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7093 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, | 6473 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7094 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, | 6474 | }, |
| 7095 | }, | 6475 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7096 | .patterns = &.{ | 6476 | .each = .{ .once = &.{ |
| 7097 | .{ .src = .{ .to_mem, .to_mem } }, | 6477 | .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ }, |
| 7098 | }, | 6478 | .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ }, |
| 7099 | .extra_temps = .{ | 6479 | } }, |
| 7100 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 6480 | }, .{ |
| 7101 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, | 6481 | .required_features = .{ .sse, null, null, null }, |
| 7102 | .unused, | 6482 | .src_constraints = .{ |
| 7103 | .unused, | 6483 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7104 | .unused, | 6484 | .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, |
| 7105 | .unused, | 6485 | .any, |
| 7106 | .unused, | 6486 | }, |
| 7107 | .unused, | 6487 | .patterns = &.{ |
| 7108 | .unused, | 6488 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7109 | }, | 6489 | }, |
| 7110 | .dst_temps = .{.mem}, | 6490 | .call_frame = .{ .alignment = .@"16" }, |
| 7111 | .clobbers = .{ .eflags = true }, | 6491 | .extra_temps = .{ |
| 7112 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 13714 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 7114 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, | 13715 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, |
| 7115 | .{ ._, .vp_b, .mins, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_size), ._ }, | 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,9 +13723,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7122 | .src_constraints = .{ | 13723 | .src_constraints = .{ |
| 7123 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 13724 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7124 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 13725 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 13726 | .any, |
| 7125 | }, | 13727 | }, |
| 7126 | .patterns = &.{ | 13728 | .patterns = &.{ |
| 7127 | .{ .src = .{ .to_mem, .to_mem } }, | 13729 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7128 | }, | 13730 | }, |
| 7129 | .extra_temps = .{ | 13731 | .extra_temps = .{ |
| 7130 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13732 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7152,9 +13754,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7152,9 +13754,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7152 | .src_constraints = .{ | 13754 | .src_constraints = .{ |
| 7153 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 13755 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7154 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 13756 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 13757 | .any, |
| 7155 | }, | 13758 | }, |
| 7156 | .patterns = &.{ | 13759 | .patterns = &.{ |
| 7157 | .{ .src = .{ .to_mem, .to_mem } }, | 13760 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7158 | }, | 13761 | }, |
| 7159 | .extra_temps = .{ | 13762 | .extra_temps = .{ |
| 7160 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13763 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7182,9 +13785,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7182,9 +13785,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7182 | .src_constraints = .{ | 13785 | .src_constraints = .{ |
| 7183 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 13786 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| 7184 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, | 13787 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 13788 | .any, |
| 7185 | }, | 13789 | }, |
| 7186 | .patterns = &.{ | 13790 | .patterns = &.{ |
| 7187 | .{ .src = .{ .to_mem, .to_mem } }, | 13791 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7188 | }, | 13792 | }, |
| 7189 | .extra_temps = .{ | 13793 | .extra_temps = .{ |
| 7190 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13794 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7216,9 +13820,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7216,9 +13820,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7216 | .src_constraints = .{ | 13820 | .src_constraints = .{ |
| 7217 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13821 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7218 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13822 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 13823 | .any, |
| 7219 | }, | 13824 | }, |
| 7220 | .patterns = &.{ | 13825 | .patterns = &.{ |
| 7221 | .{ .src = .{ .to_mem, .to_mem } }, | 13826 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7222 | }, | 13827 | }, |
| 7223 | .extra_temps = .{ | 13828 | .extra_temps = .{ |
| 7224 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13829 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7248,9 +13853,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7248,9 +13853,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7248 | .src_constraints = .{ | 13853 | .src_constraints = .{ |
| 7249 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13854 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7250 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13855 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 13856 | .any, |
| 7251 | }, | 13857 | }, |
| 7252 | .patterns = &.{ | 13858 | .patterns = &.{ |
| 7253 | .{ .src = .{ .to_mem, .to_mem } }, | 13859 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7254 | }, | 13860 | }, |
| 7255 | .extra_temps = .{ | 13861 | .extra_temps = .{ |
| 7256 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13862 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7280,9 +13886,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7280,9 +13886,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7280 | .src_constraints = .{ | 13886 | .src_constraints = .{ |
| 7281 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13887 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7282 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13888 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 13889 | .any, |
| 7283 | }, | 13890 | }, |
| 7284 | .patterns = &.{ | 13891 | .patterns = &.{ |
| 7285 | .{ .src = .{ .to_mem, .to_mem } }, | 13892 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7286 | }, | 13893 | }, |
| 7287 | .extra_temps = .{ | 13894 | .extra_temps = .{ |
| 7288 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13895 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7311,9 +13918,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7311,9 +13918,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7311 | .src_constraints = .{ | 13918 | .src_constraints = .{ |
| 7312 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13919 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 7313 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, | 13920 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 13921 | .any, |
| 7314 | }, | 13922 | }, |
| 7315 | .patterns = &.{ | 13923 | .patterns = &.{ |
| 7316 | .{ .src = .{ .to_mem, .to_mem } }, | 13924 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7317 | }, | 13925 | }, |
| 7318 | .extra_temps = .{ | 13926 | .extra_temps = .{ |
| 7319 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 13927 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7343,11 +13951,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7343,11 +13951,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7343 | .src_constraints = .{ | 13951 | .src_constraints = .{ |
| 7344 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, | 13952 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| 7345 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, | 13953 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 13954 | .any, |
| 7346 | }, | 13955 | }, |
| 7347 | .patterns = &.{ | 13956 | .patterns = &.{ |
| 7348 | .{ .src = .{ .to_mut_mmx, .mem } }, | 13957 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 7349 | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, | 13958 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 7350 | .{ .src = .{ .to_mut_mmx, .to_mmx } }, | 13959 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 7351 | }, | 13960 | }, |
| 7352 | .dst_temps = .{.{ .ref = .src0 }}, | 13961 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7353 | .each = .{ .once = &.{ | 13962 | .each = .{ .once = &.{ |
| ... | @@ -7358,11 +13967,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7358,11 +13967,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7358 | .src_constraints = .{ | 13967 | .src_constraints = .{ |
| 7359 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 13968 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7360 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 13969 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 13970 | .any, |
| 7361 | }, | 13971 | }, |
| 7362 | .patterns = &.{ | 13972 | .patterns = &.{ |
| 7363 | .{ .src = .{ .to_sse, .mem } }, | 13973 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7364 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 13974 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 7365 | .{ .src = .{ .to_sse, .to_sse } }, | 13975 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7366 | }, | 13976 | }, |
| 7367 | .dst_temps = .{.{ .rc = .sse }}, | 13977 | .dst_temps = .{.{ .rc = .sse }}, |
| 7368 | .each = .{ .once = &.{ | 13978 | .each = .{ .once = &.{ |
| ... | @@ -7373,11 +13983,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7373,11 +13983,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7373 | .src_constraints = .{ | 13983 | .src_constraints = .{ |
| 7374 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 13984 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7375 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 13985 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 13986 | .any, |
| 7376 | }, | 13987 | }, |
| 7377 | .patterns = &.{ | 13988 | .patterns = &.{ |
| 7378 | .{ .src = .{ .to_mut_sse, .mem } }, | 13989 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7379 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 13990 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 7380 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 13991 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7381 | }, | 13992 | }, |
| 7382 | .dst_temps = .{.{ .ref = .src0 }}, | 13993 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7383 | .each = .{ .once = &.{ | 13994 | .each = .{ .once = &.{ |
| ... | @@ -7388,11 +13999,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7388,11 +13999,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7388 | .src_constraints = .{ | 13999 | .src_constraints = .{ |
| 7389 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 14000 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 7390 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 14001 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 14002 | .any, |
| 7391 | }, | 14003 | }, |
| 7392 | .patterns = &.{ | 14004 | .patterns = &.{ |
| 7393 | .{ .src = .{ .to_sse, .mem } }, | 14005 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7394 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14006 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 7395 | .{ .src = .{ .to_sse, .to_sse } }, | 14007 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7396 | }, | 14008 | }, |
| 7397 | .dst_temps = .{.{ .rc = .sse }}, | 14009 | .dst_temps = .{.{ .rc = .sse }}, |
| 7398 | .each = .{ .once = &.{ | 14010 | .each = .{ .once = &.{ |
| ... | @@ -7403,9 +14015,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7403,9 +14015,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7403 | .src_constraints = .{ | 14015 | .src_constraints = .{ |
| 7404 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 14016 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| 7405 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, | 14017 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 14018 | .any, |
| 7406 | }, | 14019 | }, |
| 7407 | .patterns = &.{ | 14020 | .patterns = &.{ |
| 7408 | .{ .src = .{ .to_mem, .to_mem } }, | 14021 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7409 | }, | 14022 | }, |
| 7410 | .extra_temps = .{ | 14023 | .extra_temps = .{ |
| 7411 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14024 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7433,9 +14046,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7433,9 +14046,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7433 | .src_constraints = .{ | 14046 | .src_constraints = .{ |
| 7434 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 14047 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7435 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 14048 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 14049 | .any, |
| 7436 | }, | 14050 | }, |
| 7437 | .patterns = &.{ | 14051 | .patterns = &.{ |
| 7438 | .{ .src = .{ .to_mem, .to_mem } }, | 14052 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7439 | }, | 14053 | }, |
| 7440 | .extra_temps = .{ | 14054 | .extra_temps = .{ |
| 7441 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14055 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7463,9 +14077,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7463,9 +14077,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7463 | .src_constraints = .{ | 14077 | .src_constraints = .{ |
| 7464 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 14078 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| 7465 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, | 14079 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 14080 | .any, |
| 7466 | }, | 14081 | }, |
| 7467 | .patterns = &.{ | 14082 | .patterns = &.{ |
| 7468 | .{ .src = .{ .to_mem, .to_mem } }, | 14083 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7469 | }, | 14084 | }, |
| 7470 | .extra_temps = .{ | 14085 | .extra_temps = .{ |
| 7471 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14086 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7493,9 +14108,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7493,9 +14108,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7493 | .src_constraints = .{ | 14108 | .src_constraints = .{ |
| 7494 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14109 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7495 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14110 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 14111 | .any, |
| 7496 | }, | 14112 | }, |
| 7497 | .patterns = &.{ | 14113 | .patterns = &.{ |
| 7498 | .{ .src = .{ .to_mem, .to_mem } }, | 14114 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7499 | }, | 14115 | }, |
| 7500 | .extra_temps = .{ | 14116 | .extra_temps = .{ |
| 7501 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14117 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7525,9 +14141,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7525,9 +14141,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7525 | .src_constraints = .{ | 14141 | .src_constraints = .{ |
| 7526 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14142 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7527 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14143 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 14144 | .any, |
| 7528 | }, | 14145 | }, |
| 7529 | .patterns = &.{ | 14146 | .patterns = &.{ |
| 7530 | .{ .src = .{ .to_mem, .to_mem } }, | 14147 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7531 | }, | 14148 | }, |
| 7532 | .extra_temps = .{ | 14149 | .extra_temps = .{ |
| 7533 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14150 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7557,9 +14174,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7557,9 +14174,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7557 | .src_constraints = .{ | 14174 | .src_constraints = .{ |
| 7558 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14175 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7559 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14176 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 14177 | .any, |
| 7560 | }, | 14178 | }, |
| 7561 | .patterns = &.{ | 14179 | .patterns = &.{ |
| 7562 | .{ .src = .{ .to_mem, .to_mem } }, | 14180 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7563 | }, | 14181 | }, |
| 7564 | .extra_temps = .{ | 14182 | .extra_temps = .{ |
| 7565 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14183 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7588,9 +14206,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7588,9 +14206,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7588 | .src_constraints = .{ | 14206 | .src_constraints = .{ |
| 7589 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14207 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 7590 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, | 14208 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 14209 | .any, |
| 7591 | }, | 14210 | }, |
| 7592 | .patterns = &.{ | 14211 | .patterns = &.{ |
| 7593 | .{ .src = .{ .to_mem, .to_mem } }, | 14212 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7594 | }, | 14213 | }, |
| 7595 | .extra_temps = .{ | 14214 | .extra_temps = .{ |
| 7596 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14215 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7620,11 +14239,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7620,11 +14239,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7620 | .src_constraints = .{ | 14239 | .src_constraints = .{ |
| 7621 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, | 14240 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| 7622 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, | 14241 | .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, |
| | 14242 | .any, |
| 7623 | }, | 14243 | }, |
| 7624 | .patterns = &.{ | 14244 | .patterns = &.{ |
| 7625 | .{ .src = .{ .to_mut_mmx, .mem } }, | 14245 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 7626 | .{ .src = .{ .mem, .to_mut_mmx }, .commute = .{ 0, 1 } }, | 14246 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 7627 | .{ .src = .{ .to_mut_mmx, .to_mmx } }, | 14247 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 7628 | }, | 14248 | }, |
| 7629 | .dst_temps = .{.{ .ref = .src0 }}, | 14249 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7630 | .each = .{ .once = &.{ | 14250 | .each = .{ .once = &.{ |
| ... | @@ -7635,11 +14255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7635,11 +14255,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7635 | .src_constraints = .{ | 14255 | .src_constraints = .{ |
| 7636 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14256 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7637 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14257 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 14258 | .any, |
| 7638 | }, | 14259 | }, |
| 7639 | .patterns = &.{ | 14260 | .patterns = &.{ |
| 7640 | .{ .src = .{ .to_sse, .mem } }, | 14261 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7641 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14262 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 7642 | .{ .src = .{ .to_sse, .to_sse } }, | 14263 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7643 | }, | 14264 | }, |
| 7644 | .dst_temps = .{.{ .rc = .sse }}, | 14265 | .dst_temps = .{.{ .rc = .sse }}, |
| 7645 | .each = .{ .once = &.{ | 14266 | .each = .{ .once = &.{ |
| ... | @@ -7650,11 +14271,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7650,11 +14271,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7650 | .src_constraints = .{ | 14271 | .src_constraints = .{ |
| 7651 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14272 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7652 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14273 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 14274 | .any, |
| 7653 | }, | 14275 | }, |
| 7654 | .patterns = &.{ | 14276 | .patterns = &.{ |
| 7655 | .{ .src = .{ .to_mut_sse, .mem } }, | 14277 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7656 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 14278 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 7657 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 14279 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7658 | }, | 14280 | }, |
| 7659 | .dst_temps = .{.{ .ref = .src0 }}, | 14281 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7660 | .each = .{ .once = &.{ | 14282 | .each = .{ .once = &.{ |
| ... | @@ -7665,11 +14287,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7665,11 +14287,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7665 | .src_constraints = .{ | 14287 | .src_constraints = .{ |
| 7666 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, | 14288 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 7667 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, | 14289 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 14290 | .any, |
| 7668 | }, | 14291 | }, |
| 7669 | .patterns = &.{ | 14292 | .patterns = &.{ |
| 7670 | .{ .src = .{ .to_sse, .mem } }, | 14293 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7671 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14294 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 7672 | .{ .src = .{ .to_sse, .to_sse } }, | 14295 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7673 | }, | 14296 | }, |
| 7674 | .dst_temps = .{.{ .rc = .sse }}, | 14297 | .dst_temps = .{.{ .rc = .sse }}, |
| 7675 | .each = .{ .once = &.{ | 14298 | .each = .{ .once = &.{ |
| ... | @@ -7680,9 +14303,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7680,9 +14303,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7680 | .src_constraints = .{ | 14303 | .src_constraints = .{ |
| 7681 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, | 14304 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| 7682 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, | 14305 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 14306 | .any, |
| 7683 | }, | 14307 | }, |
| 7684 | .patterns = &.{ | 14308 | .patterns = &.{ |
| 7685 | .{ .src = .{ .to_mem, .to_mem } }, | 14309 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7686 | }, | 14310 | }, |
| 7687 | .extra_temps = .{ | 14311 | .extra_temps = .{ |
| 7688 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14312 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7710,9 +14334,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7710,9 +14334,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7710 | .src_constraints = .{ | 14334 | .src_constraints = .{ |
| 7711 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14335 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7712 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14336 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 14337 | .any, |
| 7713 | }, | 14338 | }, |
| 7714 | .patterns = &.{ | 14339 | .patterns = &.{ |
| 7715 | .{ .src = .{ .to_mem, .to_mem } }, | 14340 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7716 | }, | 14341 | }, |
| 7717 | .extra_temps = .{ | 14342 | .extra_temps = .{ |
| 7718 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14343 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7740,9 +14365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7740,9 +14365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7740 | .src_constraints = .{ | 14365 | .src_constraints = .{ |
| 7741 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14366 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| 7742 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 14367 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 14368 | .any, |
| 7743 | }, | 14369 | }, |
| 7744 | .patterns = &.{ | 14370 | .patterns = &.{ |
| 7745 | .{ .src = .{ .to_mem, .to_mem } }, | 14371 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7746 | }, | 14372 | }, |
| 7747 | .extra_temps = .{ | 14373 | .extra_temps = .{ |
| 7748 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14374 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7770,9 +14396,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7770,9 +14396,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7770 | .src_constraints = .{ | 14396 | .src_constraints = .{ |
| 7771 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 14397 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 7772 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 14398 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 14399 | .any, |
| 7773 | }, | 14400 | }, |
| 7774 | .patterns = &.{ | 14401 | .patterns = &.{ |
| 7775 | .{ .src = .{ .to_mem, .to_mem } }, | 14402 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7776 | }, | 14403 | }, |
| 7777 | .extra_temps = .{ | 14404 | .extra_temps = .{ |
| 7778 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14405 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7800,9 +14427,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7800,9 +14427,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7800 | .src_constraints = .{ | 14427 | .src_constraints = .{ |
| 7801 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 14428 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 7802 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, | 14429 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 14430 | .any, |
| 7803 | }, | 14431 | }, |
| 7804 | .patterns = &.{ | 14432 | .patterns = &.{ |
| 7805 | .{ .src = .{ .to_mem, .to_mem } }, | 14433 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7806 | }, | 14434 | }, |
| 7807 | .extra_temps = .{ | 14435 | .extra_temps = .{ |
| 7808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14436 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7832,11 +14460,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7832,11 +14460,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7832 | .src_constraints = .{ | 14460 | .src_constraints = .{ |
| 7833 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14461 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7834 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14462 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 14463 | .any, |
| 7835 | }, | 14464 | }, |
| 7836 | .patterns = &.{ | 14465 | .patterns = &.{ |
| 7837 | .{ .src = .{ .to_sse, .mem } }, | 14466 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7838 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14467 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 7839 | .{ .src = .{ .to_sse, .to_sse } }, | 14468 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7840 | }, | 14469 | }, |
| 7841 | .dst_temps = .{.{ .rc = .sse }}, | 14470 | .dst_temps = .{.{ .rc = .sse }}, |
| 7842 | .each = .{ .once = &.{ | 14471 | .each = .{ .once = &.{ |
| ... | @@ -7847,11 +14476,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7847,11 +14476,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7847 | .src_constraints = .{ | 14476 | .src_constraints = .{ |
| 7848 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14477 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7849 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14478 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 14479 | .any, |
| 7850 | }, | 14480 | }, |
| 7851 | .patterns = &.{ | 14481 | .patterns = &.{ |
| 7852 | .{ .src = .{ .to_mut_sse, .mem } }, | 14482 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7853 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 14483 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 7854 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 14484 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7855 | }, | 14485 | }, |
| 7856 | .dst_temps = .{.{ .ref = .src0 }}, | 14486 | .dst_temps = .{.{ .ref = .src0 }}, |
| 7857 | .each = .{ .once = &.{ | 14487 | .each = .{ .once = &.{ |
| ... | @@ -7862,11 +14492,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7862,11 +14492,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7862 | .src_constraints = .{ | 14492 | .src_constraints = .{ |
| 7863 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14493 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7864 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14494 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 14495 | .any, |
| 7865 | }, | 14496 | }, |
| 7866 | .patterns = &.{ | 14497 | .patterns = &.{ |
| 7867 | .{ .src = .{ .to_mut_sse, .mem } }, | 14498 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 7868 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 14499 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 7869 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 14500 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 7870 | }, | 14501 | }, |
| 7871 | .dst_temps = .{.{ .rc = .sse }}, | 14502 | .dst_temps = .{.{ .rc = .sse }}, |
| 7872 | .each = .{ .once = &.{ | 14503 | .each = .{ .once = &.{ |
| ... | @@ -7879,11 +14510,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7879,11 +14510,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7879 | .src_constraints = .{ | 14510 | .src_constraints = .{ |
| 7880 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 14511 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 7881 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 14512 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 14513 | .any, |
| 7882 | }, | 14514 | }, |
| 7883 | .patterns = &.{ | 14515 | .patterns = &.{ |
| 7884 | .{ .src = .{ .to_sse, .mem } }, | 14516 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 7885 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14517 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 7886 | .{ .src = .{ .to_sse, .to_sse } }, | 14518 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 7887 | }, | 14519 | }, |
| 7888 | .dst_temps = .{.{ .rc = .sse }}, | 14520 | .dst_temps = .{.{ .rc = .sse }}, |
| 7889 | .each = .{ .once = &.{ | 14521 | .each = .{ .once = &.{ |
| ... | @@ -7894,9 +14526,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7894,9 +14526,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7894 | .src_constraints = .{ | 14526 | .src_constraints = .{ |
| 7895 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 14527 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| 7896 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, | 14528 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 14529 | .any, |
| 7897 | }, | 14530 | }, |
| 7898 | .patterns = &.{ | 14531 | .patterns = &.{ |
| 7899 | .{ .src = .{ .to_mem, .to_mem } }, | 14532 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7900 | }, | 14533 | }, |
| 7901 | .extra_temps = .{ | 14534 | .extra_temps = .{ |
| 7902 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14535 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7924,9 +14557,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7924,9 +14557,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7924 | .src_constraints = .{ | 14557 | .src_constraints = .{ |
| 7925 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14558 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7926 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14559 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 14560 | .any, |
| 7927 | }, | 14561 | }, |
| 7928 | .patterns = &.{ | 14562 | .patterns = &.{ |
| 7929 | .{ .src = .{ .to_mem, .to_mem } }, | 14563 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7930 | }, | 14564 | }, |
| 7931 | .extra_temps = .{ | 14565 | .extra_temps = .{ |
| 7932 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14566 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7954,9 +14588,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7954,9 +14588,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7954 | .src_constraints = .{ | 14588 | .src_constraints = .{ |
| 7955 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14589 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7956 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14590 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 14591 | .any, |
| 7957 | }, | 14592 | }, |
| 7958 | .patterns = &.{ | 14593 | .patterns = &.{ |
| 7959 | .{ .src = .{ .to_mem, .to_mem } }, | 14594 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7960 | }, | 14595 | }, |
| 7961 | .extra_temps = .{ | 14596 | .extra_temps = .{ |
| 7962 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14597 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -7984,9 +14619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7984,9 +14619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7984 | .src_constraints = .{ | 14619 | .src_constraints = .{ |
| 7985 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14620 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| 7986 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, | 14621 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 14622 | .any, |
| 7987 | }, | 14623 | }, |
| 7988 | .patterns = &.{ | 14624 | .patterns = &.{ |
| 7989 | .{ .src = .{ .to_mem, .to_mem } }, | 14625 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 7990 | }, | 14626 | }, |
| 7991 | .extra_temps = .{ | 14627 | .extra_temps = .{ |
| 7992 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8016,9 +14652,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8016,9 +14652,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8016 | .src_constraints = .{ | 14652 | .src_constraints = .{ |
| 8017 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 14653 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 8018 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 14654 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 14655 | .any, |
| 8019 | }, | 14656 | }, |
| 8020 | .patterns = &.{ | 14657 | .patterns = &.{ |
| 8021 | .{ .src = .{ .to_mem, .to_mem } }, | 14658 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8022 | }, | 14659 | }, |
| 8023 | .extra_temps = .{ | 14660 | .extra_temps = .{ |
| 8024 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14661 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8046,9 +14683,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8046,9 +14683,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8046 | .src_constraints = .{ | 14683 | .src_constraints = .{ |
| 8047 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 14684 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 8048 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, | 14685 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 14686 | .any, |
| 8049 | }, | 14687 | }, |
| 8050 | .patterns = &.{ | 14688 | .patterns = &.{ |
| 8051 | .{ .src = .{ .to_mem, .to_mem } }, | 14689 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8052 | }, | 14690 | }, |
| 8053 | .extra_temps = .{ | 14691 | .extra_temps = .{ |
| 8054 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14692 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8078,11 +14716,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8078,11 +14716,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8078 | .src_constraints = .{ | 14716 | .src_constraints = .{ |
| 8079 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14717 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8080 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14718 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 14719 | .any, |
| 8081 | }, | 14720 | }, |
| 8082 | .patterns = &.{ | 14721 | .patterns = &.{ |
| 8083 | .{ .src = .{ .to_sse, .mem } }, | 14722 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8084 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14723 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8085 | .{ .src = .{ .to_sse, .to_sse } }, | 14724 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8086 | }, | 14725 | }, |
| 8087 | .dst_temps = .{.{ .rc = .sse }}, | 14726 | .dst_temps = .{.{ .rc = .sse }}, |
| 8088 | .each = .{ .once = &.{ | 14727 | .each = .{ .once = &.{ |
| ... | @@ -8093,11 +14732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8093,11 +14732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8093 | .src_constraints = .{ | 14732 | .src_constraints = .{ |
| 8094 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14733 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8095 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14734 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 14735 | .any, |
| 8096 | }, | 14736 | }, |
| 8097 | .patterns = &.{ | 14737 | .patterns = &.{ |
| 8098 | .{ .src = .{ .to_mut_sse, .mem } }, | 14738 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 8099 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 14739 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 8100 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 14740 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8101 | }, | 14741 | }, |
| 8102 | .dst_temps = .{.{ .ref = .src0 }}, | 14742 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8103 | .each = .{ .once = &.{ | 14743 | .each = .{ .once = &.{ |
| ... | @@ -8108,11 +14748,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8108,11 +14748,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8108 | .src_constraints = .{ | 14748 | .src_constraints = .{ |
| 8109 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14749 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8110 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14750 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 14751 | .any, |
| 8111 | }, | 14752 | }, |
| 8112 | .patterns = &.{ | 14753 | .patterns = &.{ |
| 8113 | .{ .src = .{ .to_mut_sse, .mem } }, | 14754 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 8114 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 14755 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 8115 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 14756 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8116 | }, | 14757 | }, |
| 8117 | .dst_temps = .{.{ .rc = .sse }}, | 14758 | .dst_temps = .{.{ .rc = .sse }}, |
| 8118 | .each = .{ .once = &.{ | 14759 | .each = .{ .once = &.{ |
| ... | @@ -8127,11 +14768,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8127,11 +14768,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8127 | .src_constraints = .{ | 14768 | .src_constraints = .{ |
| 8128 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, | 14769 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 8129 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, | 14770 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 14771 | .any, |
| 8130 | }, | 14772 | }, |
| 8131 | .patterns = &.{ | 14773 | .patterns = &.{ |
| 8132 | .{ .src = .{ .to_sse, .mem } }, | 14774 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8133 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14775 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8134 | .{ .src = .{ .to_sse, .to_sse } }, | 14776 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8135 | }, | 14777 | }, |
| 8136 | .dst_temps = .{.{ .rc = .sse }}, | 14778 | .dst_temps = .{.{ .rc = .sse }}, |
| 8137 | .each = .{ .once = &.{ | 14779 | .each = .{ .once = &.{ |
| ... | @@ -8142,9 +14784,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8142,9 +14784,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8142 | .src_constraints = .{ | 14784 | .src_constraints = .{ |
| 8143 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, | 14785 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| 8144 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, | 14786 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 14787 | .any, |
| 8145 | }, | 14788 | }, |
| 8146 | .patterns = &.{ | 14789 | .patterns = &.{ |
| 8147 | .{ .src = .{ .to_mem, .to_mem } }, | 14790 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8148 | }, | 14791 | }, |
| 8149 | .extra_temps = .{ | 14792 | .extra_temps = .{ |
| 8150 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14793 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8172,9 +14815,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8172,9 +14815,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8172 | .src_constraints = .{ | 14815 | .src_constraints = .{ |
| 8173 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14816 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8174 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14817 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 14818 | .any, |
| 8175 | }, | 14819 | }, |
| 8176 | .patterns = &.{ | 14820 | .patterns = &.{ |
| 8177 | .{ .src = .{ .to_mem, .to_mem } }, | 14821 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8178 | }, | 14822 | }, |
| 8179 | .extra_temps = .{ | 14823 | .extra_temps = .{ |
| 8180 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8202,9 +14846,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8202,9 +14846,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8202 | .src_constraints = .{ | 14846 | .src_constraints = .{ |
| 8203 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14847 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8204 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14848 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 14849 | .any, |
| 8205 | }, | 14850 | }, |
| 8206 | .patterns = &.{ | 14851 | .patterns = &.{ |
| 8207 | .{ .src = .{ .to_mem, .to_mem } }, | 14852 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8208 | }, | 14853 | }, |
| 8209 | .extra_temps = .{ | 14854 | .extra_temps = .{ |
| 8210 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14855 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8232,9 +14877,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8232,9 +14877,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8232 | .src_constraints = .{ | 14877 | .src_constraints = .{ |
| 8233 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14878 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 8234 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, | 14879 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 14880 | .any, |
| 8235 | }, | 14881 | }, |
| 8236 | .patterns = &.{ | 14882 | .patterns = &.{ |
| 8237 | .{ .src = .{ .to_mem, .to_mem } }, | 14883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8238 | }, | 14884 | }, |
| 8239 | .extra_temps = .{ | 14885 | .extra_temps = .{ |
| 8240 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8266,9 +14912,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8266,9 +14912,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8266 | .src_constraints = .{ | 14912 | .src_constraints = .{ |
| 8267 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 14913 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8268 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 14914 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 14915 | .any, |
| 8269 | }, | 14916 | }, |
| 8270 | .patterns = &.{ | 14917 | .patterns = &.{ |
| 8271 | .{ .src = .{ .to_mem, .to_mem } }, | 14918 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8272 | }, | 14919 | }, |
| 8273 | .extra_temps = .{ | 14920 | .extra_temps = .{ |
| 8274 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14921 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8296,9 +14943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8296,9 +14943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8296 | .src_constraints = .{ | 14943 | .src_constraints = .{ |
| 8297 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 14944 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8298 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, | 14945 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 14946 | .any, |
| 8299 | }, | 14947 | }, |
| 8300 | .patterns = &.{ | 14948 | .patterns = &.{ |
| 8301 | .{ .src = .{ .to_mem, .to_mem } }, | 14949 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8302 | }, | 14950 | }, |
| 8303 | .extra_temps = .{ | 14951 | .extra_temps = .{ |
| 8304 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 14952 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8328,11 +14976,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8328,11 +14976,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8328 | .src_constraints = .{ | 14976 | .src_constraints = .{ |
| 8329 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 14977 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8330 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 14978 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 14979 | .any, |
| 8331 | }, | 14980 | }, |
| 8332 | .patterns = &.{ | 14981 | .patterns = &.{ |
| 8333 | .{ .src = .{ .to_sse, .mem } }, | 14982 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8334 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 14983 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8335 | .{ .src = .{ .to_sse, .to_sse } }, | 14984 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8336 | }, | 14985 | }, |
| 8337 | .dst_temps = .{.{ .rc = .sse }}, | 14986 | .dst_temps = .{.{ .rc = .sse }}, |
| 8338 | .each = .{ .once = &.{ | 14987 | .each = .{ .once = &.{ |
| ... | @@ -8343,11 +14992,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8343,11 +14992,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8343 | .src_constraints = .{ | 14992 | .src_constraints = .{ |
| 8344 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 14993 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8345 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 14994 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 14995 | .any, |
| 8346 | }, | 14996 | }, |
| 8347 | .patterns = &.{ | 14997 | .patterns = &.{ |
| 8348 | .{ .src = .{ .to_mut_sse, .mem } }, | 14998 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 8349 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 14999 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 8350 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 15000 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8351 | }, | 15001 | }, |
| 8352 | .dst_temps = .{.{ .ref = .src0 }}, | 15002 | .dst_temps = .{.{ .ref = .src0 }}, |
| 8353 | .each = .{ .once = &.{ | 15003 | .each = .{ .once = &.{ |
| ... | @@ -8358,11 +15008,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8358,11 +15008,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8358 | .src_constraints = .{ | 15008 | .src_constraints = .{ |
| 8359 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15009 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8360 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15010 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 15011 | .any, |
| 8361 | }, | 15012 | }, |
| 8362 | .patterns = &.{ | 15013 | .patterns = &.{ |
| 8363 | .{ .src = .{ .to_mut_sse, .mem } }, | 15014 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 8364 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 15015 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 8365 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 15016 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8366 | }, | 15017 | }, |
| 8367 | .extra_temps = .{ | 15018 | .extra_temps = .{ |
| 8368 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 15019 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8392,11 +15043,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8392,11 +15043,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8392 | .src_constraints = .{ | 15043 | .src_constraints = .{ |
| 8393 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 15044 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 8394 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 15045 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 15046 | .any, |
| 8395 | }, | 15047 | }, |
| 8396 | .patterns = &.{ | 15048 | .patterns = &.{ |
| 8397 | .{ .src = .{ .to_sse, .mem } }, | 15049 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8398 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 15050 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8399 | .{ .src = .{ .to_sse, .to_sse } }, | 15051 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8400 | }, | 15052 | }, |
| 8401 | .dst_temps = .{.{ .rc = .sse }}, | 15053 | .dst_temps = .{.{ .rc = .sse }}, |
| 8402 | .each = .{ .once = &.{ | 15054 | .each = .{ .once = &.{ |
| ... | @@ -8407,9 +15059,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8407,9 +15059,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8407 | .src_constraints = .{ | 15059 | .src_constraints = .{ |
| 8408 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 15060 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| 8409 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, | 15061 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 15062 | .any, |
| 8410 | }, | 15063 | }, |
| 8411 | .patterns = &.{ | 15064 | .patterns = &.{ |
| 8412 | .{ .src = .{ .to_mem, .to_mem } }, | 15065 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8413 | }, | 15066 | }, |
| 8414 | .extra_temps = .{ | 15067 | .extra_temps = .{ |
| 8415 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15068 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8437,9 +15090,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8437,9 +15090,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8437 | .src_constraints = .{ | 15090 | .src_constraints = .{ |
| 8438 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15091 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8439 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15092 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 15093 | .any, |
| 8440 | }, | 15094 | }, |
| 8441 | .patterns = &.{ | 15095 | .patterns = &.{ |
| 8442 | .{ .src = .{ .to_mem, .to_mem } }, | 15096 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8443 | }, | 15097 | }, |
| 8444 | .extra_temps = .{ | 15098 | .extra_temps = .{ |
| 8445 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15099 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8467,9 +15121,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8467,9 +15121,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8467 | .src_constraints = .{ | 15121 | .src_constraints = .{ |
| 8468 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15122 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8469 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15123 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 15124 | .any, |
| 8470 | }, | 15125 | }, |
| 8471 | .patterns = &.{ | 15126 | .patterns = &.{ |
| 8472 | .{ .src = .{ .to_mem, .to_mem } }, | 15127 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8473 | }, | 15128 | }, |
| 8474 | .extra_temps = .{ | 15129 | .extra_temps = .{ |
| 8475 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15130 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8497,9 +15152,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8497,9 +15152,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8497 | .src_constraints = .{ | 15152 | .src_constraints = .{ |
| 8498 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15153 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| 8499 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, | 15154 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 15155 | .any, |
| 8500 | }, | 15156 | }, |
| 8501 | .patterns = &.{ | 15157 | .patterns = &.{ |
| 8502 | .{ .src = .{ .to_mem, .to_mem } }, | 15158 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8503 | }, | 15159 | }, |
| 8504 | .extra_temps = .{ | 15160 | .extra_temps = .{ |
| 8505 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15161 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8537,9 +15193,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8537,9 +15193,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8537 | .src_constraints = .{ | 15193 | .src_constraints = .{ |
| 8538 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 15194 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8539 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 15195 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 15196 | .any, |
| 8540 | }, | 15197 | }, |
| 8541 | .patterns = &.{ | 15198 | .patterns = &.{ |
| 8542 | .{ .src = .{ .to_mem, .to_mem } }, | 15199 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8543 | }, | 15200 | }, |
| 8544 | .extra_temps = .{ | 15201 | .extra_temps = .{ |
| 8545 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15202 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8567,9 +15224,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8567,9 +15224,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8567 | .src_constraints = .{ | 15224 | .src_constraints = .{ |
| 8568 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 15225 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8569 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, | 15226 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 15227 | .any, |
| 8570 | }, | 15228 | }, |
| 8571 | .patterns = &.{ | 15229 | .patterns = &.{ |
| 8572 | .{ .src = .{ .to_mem, .to_mem } }, | 15230 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8573 | }, | 15231 | }, |
| 8574 | .extra_temps = .{ | 15232 | .extra_temps = .{ |
| 8575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15233 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8599,11 +15257,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8599,11 +15257,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8599 | .src_constraints = .{ | 15257 | .src_constraints = .{ |
| 8600 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15258 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8601 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15259 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 15260 | .any, |
| 8602 | }, | 15261 | }, |
| 8603 | .patterns = &.{ | 15262 | .patterns = &.{ |
| 8604 | .{ .src = .{ .to_sse, .mem } }, | 15263 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8605 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 15264 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8606 | .{ .src = .{ .to_sse, .to_sse } }, | 15265 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8607 | }, | 15266 | }, |
| 8608 | .dst_temps = .{.{ .rc = .sse }}, | 15267 | .dst_temps = .{.{ .rc = .sse }}, |
| 8609 | .each = .{ .once = &.{ | 15268 | .each = .{ .once = &.{ |
| ... | @@ -8615,11 +15274,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8615,11 +15274,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8615 | .src_constraints = .{ | 15274 | .src_constraints = .{ |
| 8616 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15275 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8617 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15276 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 15277 | .any, |
| 8618 | }, | 15278 | }, |
| 8619 | .patterns = &.{ | 15279 | .patterns = &.{ |
| 8620 | .{ .src = .{ .to_mut_sse, .mem } }, | 15280 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 8621 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 15281 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 8622 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 15282 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8623 | }, | 15283 | }, |
| 8624 | .extra_temps = .{ | 15284 | .extra_temps = .{ |
| 8625 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, | 15285 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| ... | @@ -8643,11 +15303,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8643,11 +15303,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8643 | .src_constraints = .{ | 15303 | .src_constraints = .{ |
| 8644 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 15304 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 8645 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 15305 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 15306 | .any, |
| 8646 | }, | 15307 | }, |
| 8647 | .patterns = &.{ | 15308 | .patterns = &.{ |
| 8648 | .{ .src = .{ .to_sse, .mem } }, | 15309 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8649 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 15310 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8650 | .{ .src = .{ .to_sse, .to_sse } }, | 15311 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8651 | }, | 15312 | }, |
| 8652 | .dst_temps = .{.{ .rc = .sse }}, | 15313 | .dst_temps = .{.{ .rc = .sse }}, |
| 8653 | .each = .{ .once = &.{ | 15314 | .each = .{ .once = &.{ |
| ... | @@ -8659,9 +15320,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8659,9 +15320,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8659 | .src_constraints = .{ | 15320 | .src_constraints = .{ |
| 8660 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 15321 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| 8661 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, | 15322 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 15323 | .any, |
| 8662 | }, | 15324 | }, |
| 8663 | .patterns = &.{ | 15325 | .patterns = &.{ |
| 8664 | .{ .src = .{ .to_mem, .to_mem } }, | 15326 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8665 | }, | 15327 | }, |
| 8666 | .extra_temps = .{ | 15328 | .extra_temps = .{ |
| 8667 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15329 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8691,9 +15353,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8691,9 +15353,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8691 | .src_constraints = .{ | 15353 | .src_constraints = .{ |
| 8692 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15354 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8693 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15355 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 15356 | .any, |
| 8694 | }, | 15357 | }, |
| 8695 | .patterns = &.{ | 15358 | .patterns = &.{ |
| 8696 | .{ .src = .{ .to_mem, .to_mem } }, | 15359 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8697 | }, | 15360 | }, |
| 8698 | .extra_temps = .{ | 15361 | .extra_temps = .{ |
| 8699 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15362 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8723,9 +15386,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8723,9 +15386,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8723 | .src_constraints = .{ | 15386 | .src_constraints = .{ |
| 8724 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15387 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| 8725 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, | 15388 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 15389 | .any, |
| 8726 | }, | 15390 | }, |
| 8727 | .patterns = &.{ | 15391 | .patterns = &.{ |
| 8728 | .{ .src = .{ .to_mem, .to_mem } }, | 15392 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8729 | }, | 15393 | }, |
| 8730 | .extra_temps = .{ | 15394 | .extra_temps = .{ |
| 8731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15395 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8756,9 +15420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8756,9 +15420,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8756 | .src_constraints = .{ | 15420 | .src_constraints = .{ |
| 8757 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 15421 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 8758 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 15422 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 15423 | .any, |
| 8759 | }, | 15424 | }, |
| 8760 | .patterns = &.{ | 15425 | .patterns = &.{ |
| 8761 | .{ .src = .{ .to_mem, .to_mem } }, | 15426 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8762 | }, | 15427 | }, |
| 8763 | .extra_temps = .{ | 15428 | .extra_temps = .{ |
| 8764 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15429 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8787,9 +15452,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8787,9 +15452,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8787 | .src_constraints = .{ | 15452 | .src_constraints = .{ |
| 8788 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 15453 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 8789 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, | 15454 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 15455 | .any, |
| 8790 | }, | 15456 | }, |
| 8791 | .patterns = &.{ | 15457 | .patterns = &.{ |
| 8792 | .{ .src = .{ .to_mem, .to_mem } }, | 15458 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8793 | }, | 15459 | }, |
| 8794 | .extra_temps = .{ | 15460 | .extra_temps = .{ |
| 8795 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15461 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8819,11 +15485,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8819,11 +15485,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8819 | .src_constraints = .{ | 15485 | .src_constraints = .{ |
| 8820 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15486 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8821 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15487 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 15488 | .any, |
| 8822 | }, | 15489 | }, |
| 8823 | .patterns = &.{ | 15490 | .patterns = &.{ |
| 8824 | .{ .src = .{ .to_sse, .mem } }, | 15491 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8825 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 15492 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8826 | .{ .src = .{ .to_sse, .to_sse } }, | 15493 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8827 | }, | 15494 | }, |
| 8828 | .extra_temps = .{ | 15495 | .extra_temps = .{ |
| 8829 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 15496 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8850,11 +15517,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8850,11 +15517,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8850 | .src_constraints = .{ | 15517 | .src_constraints = .{ |
| 8851 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15518 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8852 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15519 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 15520 | .any, |
| 8853 | }, | 15521 | }, |
| 8854 | .patterns = &.{ | 15522 | .patterns = &.{ |
| 8855 | .{ .src = .{ .to_mut_sse, .mem } }, | 15523 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 8856 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 15524 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 8857 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 15525 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 8858 | }, | 15526 | }, |
| 8859 | .extra_temps = .{ | 15527 | .extra_temps = .{ |
| 8860 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 15528 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8882,11 +15550,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8882,11 +15550,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8882 | .src_constraints = .{ | 15550 | .src_constraints = .{ |
| 8883 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 15551 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 8884 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 15552 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 15553 | .any, |
| 8885 | }, | 15554 | }, |
| 8886 | .patterns = &.{ | 15555 | .patterns = &.{ |
| 8887 | .{ .src = .{ .to_sse, .mem } }, | 15556 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 8888 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 15557 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 8889 | .{ .src = .{ .to_sse, .to_sse } }, | 15558 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 8890 | }, | 15559 | }, |
| 8891 | .extra_temps = .{ | 15560 | .extra_temps = .{ |
| 8892 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 15561 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8913,9 +15582,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8913,9 +15582,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8913 | .src_constraints = .{ | 15582 | .src_constraints = .{ |
| 8914 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 15583 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| 8915 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, | 15584 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 15585 | .any, |
| 8916 | }, | 15586 | }, |
| 8917 | .patterns = &.{ | 15587 | .patterns = &.{ |
| 8918 | .{ .src = .{ .to_mem, .to_mem } }, | 15588 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8919 | }, | 15589 | }, |
| 8920 | .extra_temps = .{ | 15590 | .extra_temps = .{ |
| 8921 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15591 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8949,9 +15619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8949,9 +15619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8949 | .src_constraints = .{ | 15619 | .src_constraints = .{ |
| 8950 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15620 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8951 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15621 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 15622 | .any, |
| 8952 | }, | 15623 | }, |
| 8953 | .patterns = &.{ | 15624 | .patterns = &.{ |
| 8954 | .{ .src = .{ .to_mem, .to_mem } }, | 15625 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8955 | }, | 15626 | }, |
| 8956 | .extra_temps = .{ | 15627 | .extra_temps = .{ |
| 8957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -8985,9 +15656,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -8985,9 +15656,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 8985 | .src_constraints = .{ | 15656 | .src_constraints = .{ |
| 8986 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15657 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 8987 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, | 15658 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 15659 | .any, |
| 8988 | }, | 15660 | }, |
| 8989 | .patterns = &.{ | 15661 | .patterns = &.{ |
| 8990 | .{ .src = .{ .to_mem, .to_mem } }, | 15662 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8991 | }, | 15663 | }, |
| 8992 | .extra_temps = .{ | 15664 | .extra_temps = .{ |
| 8993 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15665 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9023,9 +15695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9023,9 +15695,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9023 | .src_constraints = .{ | 15695 | .src_constraints = .{ |
| 9024 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 15696 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 9025 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 15697 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 15698 | .any, |
| 9026 | }, | 15699 | }, |
| 9027 | .patterns = &.{ | 15700 | .patterns = &.{ |
| 9028 | .{ .src = .{ .to_mem, .to_mem } }, | 15701 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9029 | }, | 15702 | }, |
| 9030 | .extra_temps = .{ | 15703 | .extra_temps = .{ |
| 9031 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9054,9 +15727,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9054,9 +15727,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9054 | .src_constraints = .{ | 15727 | .src_constraints = .{ |
| 9055 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 15728 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 9056 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, | 15729 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 15730 | .any, |
| 9057 | }, | 15731 | }, |
| 9058 | .patterns = &.{ | 15732 | .patterns = &.{ |
| 9059 | .{ .src = .{ .to_mem, .to_mem } }, | 15733 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9060 | }, | 15734 | }, |
| 9061 | .extra_temps = .{ | 15735 | .extra_temps = .{ |
| 9062 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9083,9 +15757,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9083,9 +15757,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9083 | } }, | 15757 | } }, |
| 9084 | }, .{ | 15758 | }, .{ |
| 9085 | .required_features = .{ .@"64bit", .cmov, null, null }, | 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 | .patterns = &.{ | 15761 | .patterns = &.{ |
| 9088 | .{ .src = .{ .to_mem, .to_mem } }, | 15762 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9089 | }, | 15763 | }, |
| 9090 | .extra_temps = .{ | 15764 | .extra_temps = .{ |
| 9091 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15765 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9122,9 +15796,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9122,9 +15796,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9122 | } }, | 15796 | } }, |
| 9123 | }, .{ | 15797 | }, .{ |
| 9124 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 15800 | .patterns = &.{ |
| 9127 | .{ .src = .{ .to_mem, .to_mem } }, | 15801 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9128 | }, | 15802 | }, |
| 9129 | .extra_temps = .{ | 15803 | .extra_temps = .{ |
| 9130 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15804 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9161,9 +15835,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9161,9 +15835,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9161 | } }, | 15835 | } }, |
| 9162 | }, .{ | 15836 | }, .{ |
| 9163 | .required_features = .{ .@"64bit", .cmov, null, null }, | 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 | .patterns = &.{ | 15839 | .patterns = &.{ |
| 9166 | .{ .src = .{ .to_mem, .to_mem } }, | 15840 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9167 | }, | 15841 | }, |
| 9168 | .extra_temps = .{ | 15842 | .extra_temps = .{ |
| 9169 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15843 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9198,9 +15872,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9198,9 +15872,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9198 | } }, | 15872 | } }, |
| 9199 | }, .{ | 15873 | }, .{ |
| 9200 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 15876 | .patterns = &.{ |
| 9203 | .{ .src = .{ .to_mem, .to_mem } }, | 15877 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9204 | }, | 15878 | }, |
| 9205 | .extra_temps = .{ | 15879 | .extra_temps = .{ |
| 9206 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 15880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9238,9 +15912,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9238,9 +15912,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9238 | .src_constraints = .{ | 15912 | .src_constraints = .{ |
| 9239 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 15913 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 9240 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 15914 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 15915 | .any, |
| 9241 | }, | 15916 | }, |
| 9242 | .patterns = &.{ | 15917 | .patterns = &.{ |
| 9243 | .{ .src = .{ .to_sse, .to_sse } }, | 15918 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9244 | }, | 15919 | }, |
| 9245 | .extra_temps = .{ | 15920 | .extra_temps = .{ |
| 9246 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 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,8 +15932,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9257 | .each = .{ .once = &.{ | 15932 | .each = .{ .once = &.{ |
| 9258 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 15933 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 9259 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, | 15934 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 9260 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, | 15935 | .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0d, .vp(.unord) }, |
| 9261 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, | 15936 | .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0d, ._ }, |
| 9262 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, | 15937 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, |
| 9263 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 15938 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 9264 | } }, | 15939 | } }, |
| ... | @@ -9267,9 +15942,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9267,9 +15942,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9267 | .src_constraints = .{ | 15942 | .src_constraints = .{ |
| 9268 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 15943 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 9269 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 15944 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 15945 | .any, |
| 9270 | }, | 15946 | }, |
| 9271 | .patterns = &.{ | 15947 | .patterns = &.{ |
| 9272 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 15948 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 9273 | }, | 15949 | }, |
| 9274 | .call_frame = .{ .alignment = .@"16" }, | 15950 | .call_frame = .{ .alignment = .@"16" }, |
| 9275 | .extra_temps = .{ | 15951 | .extra_temps = .{ |
| ... | @@ -9293,16 +15969,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9293,16 +15969,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9293 | .src_constraints = .{ | 15969 | .src_constraints = .{ |
| 9294 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, | 15970 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 9295 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, | 15971 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 15972 | .any, |
| 9296 | }, | 15973 | }, |
| 9297 | .patterns = &.{ | 15974 | .patterns = &.{ |
| 9298 | .{ .src = .{ .mem, .mem } }, | 15975 | .{ .src = .{ .mem, .mem, .none } }, |
| 9299 | .{ .src = .{ .to_sse, .mem } }, | 15976 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 9300 | .{ .src = .{ .mem, .to_sse } }, | 15977 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 9301 | .{ .src = .{ .to_sse, .to_sse } }, | 15978 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9302 | }, | 15979 | }, |
| 9303 | .extra_temps = .{ | 15980 | .extra_temps = .{ |
| 9304 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 15981 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9305 | .{ .type = .vector_4_f16, .kind = .{ .rc = .sse } }, | 15982 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 9306 | .unused, | 15983 | .unused, |
| 9307 | .unused, | 15984 | .unused, |
| 9308 | .unused, | 15985 | .unused, |
| ... | @@ -9325,16 +16002,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9325,16 +16002,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9325 | .src_constraints = .{ | 16002 | .src_constraints = .{ |
| 9326 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, | 16003 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 9327 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, | 16004 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 16005 | .any, |
| 9328 | }, | 16006 | }, |
| 9329 | .patterns = &.{ | 16007 | .patterns = &.{ |
| 9330 | .{ .src = .{ .mem, .mem } }, | 16008 | .{ .src = .{ .mem, .mem, .none } }, |
| 9331 | .{ .src = .{ .to_sse, .mem } }, | 16009 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 9332 | .{ .src = .{ .mem, .to_sse } }, | 16010 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 9333 | .{ .src = .{ .to_sse, .to_sse } }, | 16011 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9334 | }, | 16012 | }, |
| 9335 | .extra_temps = .{ | 16013 | .extra_temps = .{ |
| 9336 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 16014 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 9337 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 16015 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9338 | .unused, | 16016 | .unused, |
| 9339 | .unused, | 16017 | .unused, |
| 9340 | .unused, | 16018 | .unused, |
| ... | @@ -9350,22 +16028,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9350,22 +16028,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9350 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, | 16028 | .{ ._, .v_ps, .cmp, .tmp1y, .dst0y, .dst0y, .vp(.unord) }, |
| 9351 | .{ ._, .v_ps, .min, .dst0y, .tmp0y, .dst0y, ._ }, | 16029 | .{ ._, .v_ps, .min, .dst0y, .tmp0y, .dst0y, ._ }, |
| 9352 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp0y, .tmp1y }, | 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 | .required_features = .{ .f16c, null, null, null }, | 16034 | .required_features = .{ .f16c, null, null, null }, |
| 9357 | .src_constraints = .{ | 16035 | .src_constraints = .{ |
| 9358 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 16036 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 9359 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 16037 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| | 16038 | .any, |
| 9360 | }, | 16039 | }, |
| 9361 | .patterns = &.{ | 16040 | .patterns = &.{ |
| 9362 | .{ .src = .{ .to_mem, .to_mem } }, | 16041 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9363 | }, | 16042 | }, |
| 9364 | .extra_temps = .{ | 16043 | .extra_temps = .{ |
| 9365 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16044 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 9366 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 16045 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9367 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 16046 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9368 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 16047 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 9369 | .unused, | 16048 | .unused, |
| 9370 | .unused, | 16049 | .unused, |
| 9371 | .unused, | 16050 | .unused, |
| ... | @@ -9390,9 +16069,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9390,9 +16069,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9390 | .src_constraints = .{ | 16069 | .src_constraints = .{ |
| 9391 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16070 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9392 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16071 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 16072 | .any, |
| 9393 | }, | 16073 | }, |
| 9394 | .patterns = &.{ | 16074 | .patterns = &.{ |
| 9395 | .{ .src = .{ .to_mem, .to_mem } }, | 16075 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9396 | }, | 16076 | }, |
| 9397 | .call_frame = .{ .alignment = .@"16" }, | 16077 | .call_frame = .{ .alignment = .@"16" }, |
| 9398 | .extra_temps = .{ | 16078 | .extra_temps = .{ |
| ... | @@ -9423,9 +16103,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9423,9 +16103,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9423 | .src_constraints = .{ | 16103 | .src_constraints = .{ |
| 9424 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16104 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9425 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16105 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 16106 | .any, |
| 9426 | }, | 16107 | }, |
| 9427 | .patterns = &.{ | 16108 | .patterns = &.{ |
| 9428 | .{ .src = .{ .to_mem, .to_mem } }, | 16109 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9429 | }, | 16110 | }, |
| 9430 | .call_frame = .{ .alignment = .@"16" }, | 16111 | .call_frame = .{ .alignment = .@"16" }, |
| 9431 | .extra_temps = .{ | 16112 | .extra_temps = .{ |
| ... | @@ -9457,9 +16138,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9457,9 +16138,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9457 | .src_constraints = .{ | 16138 | .src_constraints = .{ |
| 9458 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16139 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9459 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16140 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 16141 | .any, |
| 9460 | }, | 16142 | }, |
| 9461 | .patterns = &.{ | 16143 | .patterns = &.{ |
| 9462 | .{ .src = .{ .to_mem, .to_mem } }, | 16144 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9463 | }, | 16145 | }, |
| 9464 | .call_frame = .{ .alignment = .@"16" }, | 16146 | .call_frame = .{ .alignment = .@"16" }, |
| 9465 | .extra_temps = .{ | 16147 | .extra_temps = .{ |
| ... | @@ -9492,9 +16174,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9492,9 +16174,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9492 | .src_constraints = .{ | 16174 | .src_constraints = .{ |
| 9493 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16175 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 9494 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 16176 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 16177 | .any, |
| 9495 | }, | 16178 | }, |
| 9496 | .patterns = &.{ | 16179 | .patterns = &.{ |
| 9497 | .{ .src = .{ .to_mem, .to_mem } }, | 16180 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9498 | }, | 16181 | }, |
| 9499 | .call_frame = .{ .alignment = .@"16" }, | 16182 | .call_frame = .{ .alignment = .@"16" }, |
| 9500 | .extra_temps = .{ | 16183 | .extra_temps = .{ |
| ... | @@ -9530,9 +16213,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9530,9 +16213,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9530 | .src_constraints = .{ | 16213 | .src_constraints = .{ |
| 9531 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 16214 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 9532 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 16215 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 16216 | .any, |
| 9533 | }, | 16217 | }, |
| 9534 | .patterns = &.{ | 16218 | .patterns = &.{ |
| 9535 | .{ .src = .{ .to_sse, .to_sse } }, | 16219 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9536 | }, | 16220 | }, |
| 9537 | .extra_temps = .{ | 16221 | .extra_temps = .{ |
| 9538 | .{ .type = .f32, .kind = .{ .rc = .sse } }, | 16222 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| ... | @@ -9547,8 +16231,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9547,8 +16231,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9547 | }, | 16231 | }, |
| 9548 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 16232 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9549 | .each = .{ .once = &.{ | 16233 | .each = .{ .once = &.{ |
| 9550 | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, | 16234 | .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0d, .vp(.unord) }, |
| 9551 | .{ ._, .v_ss, .min, .dst0x, .src1x, .src0x, ._ }, | 16235 | .{ ._, .v_ss, .min, .dst0x, .src1x, .src0d, ._ }, |
| 9552 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, | 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,15 +16240,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9556 | .src_constraints = .{ | 16240 | .src_constraints = .{ |
| 9557 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 16241 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 9558 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 16242 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 16243 | .any, |
| 9559 | }, | 16244 | }, |
| 9560 | .patterns = &.{ | 16245 | .patterns = &.{ |
| 9561 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, | 16246 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9562 | }, | 16247 | }, |
| 9563 | .dst_temps = .{.{ .rc = .sse }}, | 16248 | .dst_temps = .{.{ .rc = .sse }}, |
| 9564 | .each = .{ .once = &.{ | 16249 | .each = .{ .once = &.{ |
| 9565 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, | 16250 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 9566 | .{ ._, ._ss, .min, .dst0x, .src0x, ._, ._ }, | 16251 | .{ ._, ._ss, .min, .dst0x, .src0d, ._, ._ }, |
| 9567 | .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, | 16252 | .{ ._, ._ss, .cmp, .src0x, .src0d, .sp(.unord), ._ }, |
| 9568 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, | 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,9 +16257,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9572 | .src_constraints = .{ | 16257 | .src_constraints = .{ |
| 9573 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 16258 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 9574 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 16259 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 16260 | .any, |
| 9575 | }, | 16261 | }, |
| 9576 | .patterns = &.{ | 16262 | .patterns = &.{ |
| 9577 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 16263 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9578 | }, | 16264 | }, |
| 9579 | .extra_temps = .{ | 16265 | .extra_temps = .{ |
| 9580 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 16266 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| ... | @@ -9590,8 +16276,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9590,8 +16276,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9590 | .dst_temps = .{.{ .ref = .src0 }}, | 16276 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9591 | .each = .{ .once = &.{ | 16277 | .each = .{ .once = &.{ |
| 9592 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, | 16278 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9593 | .{ ._, ._ss, .min, .tmp0x, .src0x, ._, ._ }, | 16279 | .{ ._, ._ss, .min, .tmp0x, .src0d, ._, ._ }, |
| 9594 | .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, | 16280 | .{ ._, ._ss, .cmp, .dst0x, .src0d, .sp(.ord), ._ }, |
| 9595 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, | 16281 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9596 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, | 16282 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 9597 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, | 16283 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | @@ -9601,9 +16287,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9601,9 +16287,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9601 | .src_constraints = .{ | 16287 | .src_constraints = .{ |
| 9602 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 16288 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9603 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 16289 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 16290 | .any, |
| 9604 | }, | 16291 | }, |
| 9605 | .patterns = &.{ | 16292 | .patterns = &.{ |
| 9606 | .{ .src = .{ .to_sse, .to_sse } }, | 16293 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9607 | }, | 16294 | }, |
| 9608 | .extra_temps = .{ | 16295 | .extra_temps = .{ |
| 9609 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 16296 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| ... | @@ -9627,17 +16314,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9627,17 +16314,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9627 | .src_constraints = .{ | 16314 | .src_constraints = .{ |
| 9628 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 16315 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9629 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 16316 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 16317 | .any, |
| 9630 | }, | 16318 | }, |
| 9631 | .patterns = &.{ | 16319 | .patterns = &.{ |
| 9632 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, | 16320 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| 9633 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, | 16321 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } }, |
| 9634 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, | 16322 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9635 | }, | 16323 | }, |
| 9636 | .dst_temps = .{.{ .rc = .sse }}, | 16324 | .dst_temps = .{.{ .rc = .sse }}, |
| 9637 | .each = .{ .once = &.{ | 16325 | .each = .{ .once = &.{ |
| 9638 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, | 16326 | .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, |
| 9639 | .{ ._, ._ps, .min, .dst0x, .src0x, ._, ._ }, | 16327 | .{ ._, ._ps, .min, .dst0x, .src0x, ._, ._ }, |
| 9640 | .{ ._, ._ps, .cmp, .src0x, .src0x, .vp(.unord), ._ }, | 16328 | .{ ._, ._ps, .cmp, .src0x, .src0x, .sp(.unord), ._ }, |
| 9641 | .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, | 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,11 +16333,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9645 | .src_constraints = .{ | 16333 | .src_constraints = .{ |
| 9646 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 16334 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9647 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 16335 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 16336 | .any, |
| 9648 | }, | 16337 | }, |
| 9649 | .patterns = &.{ | 16338 | .patterns = &.{ |
| 9650 | .{ .src = .{ .to_mut_sse, .mem } }, | 16339 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 9651 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 16340 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 9652 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 16341 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9653 | }, | 16342 | }, |
| 9654 | .extra_temps = .{ | 16343 | .extra_temps = .{ |
| 9655 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 16344 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| ... | @@ -9666,7 +16355,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9666,7 +16355,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9666 | .each = .{ .once = &.{ | 16355 | .each = .{ .once = &.{ |
| 9667 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, | 16356 | .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9668 | .{ ._, ._ps, .min, .tmp0x, .src0x, ._, ._ }, | 16357 | .{ ._, ._ps, .min, .tmp0x, .src0x, ._, ._ }, |
| 9669 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, | 16358 | .{ ._, ._ps, .cmp, .dst0x, .src0x, .sp(.ord), ._ }, |
| 9670 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, | 16359 | .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9671 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, | 16360 | .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, |
| 9672 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, | 16361 | .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | @@ -9676,9 +16365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9676,9 +16365,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9676 | .src_constraints = .{ | 16365 | .src_constraints = .{ |
| 9677 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, | 16366 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9678 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, | 16367 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 16368 | .any, |
| 9679 | }, | 16369 | }, |
| 9680 | .patterns = &.{ | 16370 | .patterns = &.{ |
| 9681 | .{ .src = .{ .to_sse, .to_sse } }, | 16371 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9682 | }, | 16372 | }, |
| 9683 | .extra_temps = .{ | 16373 | .extra_temps = .{ |
| 9684 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, | 16374 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| ... | @@ -9702,9 +16392,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9702,9 +16392,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9702 | .src_constraints = .{ | 16392 | .src_constraints = .{ |
| 9703 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 16393 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 9704 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 16394 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 16395 | .any, |
| 9705 | }, | 16396 | }, |
| 9706 | .patterns = &.{ | 16397 | .patterns = &.{ |
| 9707 | .{ .src = .{ .to_mem, .to_mem } }, | 16398 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9708 | }, | 16399 | }, |
| 9709 | .extra_temps = .{ | 16400 | .extra_temps = .{ |
| 9710 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16401 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9735,9 +16426,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9735,9 +16426,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9735 | .src_constraints = .{ | 16426 | .src_constraints = .{ |
| 9736 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 16427 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9737 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 16428 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 16429 | .any, |
| 9738 | }, | 16430 | }, |
| 9739 | .patterns = &.{ | 16431 | .patterns = &.{ |
| 9740 | .{ .src = .{ .to_mem, .to_mem } }, | 16432 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9741 | }, | 16433 | }, |
| 9742 | .extra_temps = .{ | 16434 | .extra_temps = .{ |
| 9743 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9758,7 +16450,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9758,7 +16450,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9758 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 16450 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9759 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 16451 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 9760 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, | 16452 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 9761 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, | 16453 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ }, |
| 9762 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, | 16454 | .{ ._, ._ps, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 9763 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | 16455 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 9764 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 16456 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| ... | @@ -9769,9 +16461,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9769,9 +16461,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9769 | .src_constraints = .{ | 16461 | .src_constraints = .{ |
| 9770 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 16462 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 9771 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 16463 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 16464 | .any, |
| 9772 | }, | 16465 | }, |
| 9773 | .patterns = &.{ | 16466 | .patterns = &.{ |
| 9774 | .{ .src = .{ .to_mem, .to_mem } }, | 16467 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 9775 | }, | 16468 | }, |
| 9776 | .extra_temps = .{ | 16469 | .extra_temps = .{ |
| 9777 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16470 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -9792,7 +16485,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9792,7 +16485,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9792 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 16485 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 9793 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 16486 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 9794 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, | 16487 | .{ ._, ._ps, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 9795 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, | 16488 | .{ ._, ._ps, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ }, |
| 9796 | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, | 16489 | .{ ._, ._ps, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 9797 | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, | 16490 | .{ ._, ._ps, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 9798 | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, | 16491 | .{ ._, ._ps, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| ... | @@ -9805,9 +16498,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9805,9 +16498,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9805 | .src_constraints = .{ | 16498 | .src_constraints = .{ |
| 9806 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16499 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9807 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16500 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 16501 | .any, |
| 9808 | }, | 16502 | }, |
| 9809 | .patterns = &.{ | 16503 | .patterns = &.{ |
| 9810 | .{ .src = .{ .to_sse, .to_sse } }, | 16504 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9811 | }, | 16505 | }, |
| 9812 | .extra_temps = .{ | 16506 | .extra_temps = .{ |
| 9813 | .{ .type = .f64, .kind = .{ .rc = .sse } }, | 16507 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| ... | @@ -9822,8 +16516,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9822,8 +16516,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9822 | }, | 16516 | }, |
| 9823 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 16517 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 9824 | .each = .{ .once = &.{ | 16518 | .each = .{ .once = &.{ |
| 9825 | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, | 16519 | .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0q, .vp(.unord) }, |
| 9826 | .{ ._, .v_sd, .min, .dst0x, .src1x, .src0x, ._ }, | 16520 | .{ ._, .v_sd, .min, .dst0x, .src1x, .src0q, ._ }, |
| 9827 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, | 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,15 +16525,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9831 | .src_constraints = .{ | 16525 | .src_constraints = .{ |
| 9832 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16526 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9833 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16527 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 16528 | .any, |
| 9834 | }, | 16529 | }, |
| 9835 | .patterns = &.{ | 16530 | .patterns = &.{ |
| 9836 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, | 16531 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9837 | }, | 16532 | }, |
| 9838 | .dst_temps = .{.{ .rc = .sse }}, | 16533 | .dst_temps = .{.{ .rc = .sse }}, |
| 9839 | .each = .{ .once = &.{ | 16534 | .each = .{ .once = &.{ |
| 9840 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, | 16535 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 9841 | .{ ._, ._sd, .min, .dst0x, .src0x, ._, ._ }, | 16536 | .{ ._, ._sd, .min, .dst0x, .src0q, ._, ._ }, |
| 9842 | .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, | 16537 | .{ ._, ._sd, .cmp, .src0x, .src0q, .sp(.unord), ._ }, |
| 9843 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, | 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,9 +16542,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9847 | .src_constraints = .{ | 16542 | .src_constraints = .{ |
| 9848 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16543 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9849 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16544 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 16545 | .any, |
| 9850 | }, | 16546 | }, |
| 9851 | .patterns = &.{ | 16547 | .patterns = &.{ |
| 9852 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 16548 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9853 | }, | 16549 | }, |
| 9854 | .extra_temps = .{ | 16550 | .extra_temps = .{ |
| 9855 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, | 16551 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| ... | @@ -9865,8 +16561,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9865,8 +16561,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9865 | .dst_temps = .{.{ .ref = .src0 }}, | 16561 | .dst_temps = .{.{ .ref = .src0 }}, |
| 9866 | .each = .{ .once = &.{ | 16562 | .each = .{ .once = &.{ |
| 9867 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, | 16563 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9868 | .{ ._, ._sd, .min, .tmp0x, .src0x, ._, ._ }, | 16564 | .{ ._, ._sd, .min, .tmp0x, .src0q, ._, ._ }, |
| 9869 | .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, | 16565 | .{ ._, ._sd, .cmp, .dst0x, .src0q, .sp(.ord), ._ }, |
| 9870 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, | 16566 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9871 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, | 16567 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 9872 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, | 16568 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | @@ -9876,9 +16572,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9876,9 +16572,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9876 | .src_constraints = .{ | 16572 | .src_constraints = .{ |
| 9877 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16573 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 9878 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 16574 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 16575 | .any, |
| 9879 | }, | 16576 | }, |
| 9880 | .patterns = &.{ | 16577 | .patterns = &.{ |
| 9881 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 16578 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 9882 | }, | 16579 | }, |
| 9883 | .call_frame = .{ .alignment = .@"16" }, | 16580 | .call_frame = .{ .alignment = .@"16" }, |
| 9884 | .extra_temps = .{ | 16581 | .extra_temps = .{ |
| ... | @@ -9902,9 +16599,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9902,9 +16599,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9902 | .src_constraints = .{ | 16599 | .src_constraints = .{ |
| 9903 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 16600 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9904 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 16601 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 16602 | .any, |
| 9905 | }, | 16603 | }, |
| 9906 | .patterns = &.{ | 16604 | .patterns = &.{ |
| 9907 | .{ .src = .{ .to_sse, .to_sse } }, | 16605 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9908 | }, | 16606 | }, |
| 9909 | .extra_temps = .{ | 16607 | .extra_temps = .{ |
| 9910 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, | 16608 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| ... | @@ -9928,17 +16626,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9928,17 +16626,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9928 | .src_constraints = .{ | 16626 | .src_constraints = .{ |
| 9929 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 16627 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9930 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 16628 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 16629 | .any, |
| 9931 | }, | 16630 | }, |
| 9932 | .patterns = &.{ | 16631 | .patterns = &.{ |
| 9933 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem } }, | 16632 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| 9934 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 } }, .commute = .{ 0, 1 } }, | 16633 | .{ .src = .{ .mem, .{ .to_reg = .xmm0 }, .none }, .commute = .{ 0, 1 } }, |
| 9935 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, | 16634 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| 9936 | }, | 16635 | }, |
| 9937 | .dst_temps = .{.{ .rc = .sse }}, | 16636 | .dst_temps = .{.{ .rc = .sse }}, |
| 9938 | .each = .{ .once = &.{ | 16637 | .each = .{ .once = &.{ |
| 9939 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, | 16638 | .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, |
| 9940 | .{ ._, ._pd, .min, .dst0x, .src0x, ._, ._ }, | 16639 | .{ ._, ._pd, .min, .dst0x, .src0x, ._, ._ }, |
| 9941 | .{ ._, ._pd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, | 16640 | .{ ._, ._pd, .cmp, .src0x, .src0x, .sp(.unord), ._ }, |
| 9942 | .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, | 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,11 +16645,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9946 | .src_constraints = .{ | 16645 | .src_constraints = .{ |
| 9947 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 16646 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 9948 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 16647 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 16648 | .any, |
| 9949 | }, | 16649 | }, |
| 9950 | .patterns = &.{ | 16650 | .patterns = &.{ |
| 9951 | .{ .src = .{ .to_mut_sse, .mem } }, | 16651 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 9952 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 16652 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 9953 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 16653 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 9954 | }, | 16654 | }, |
| 9955 | .extra_temps = .{ | 16655 | .extra_temps = .{ |
| 9956 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, | 16656 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| ... | @@ -9967,7 +16667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9967,7 +16667,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9967 | .each = .{ .once = &.{ | 16667 | .each = .{ .once = &.{ |
| 9968 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, | 16668 | .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, |
| 9969 | .{ ._, ._pd, .min, .tmp0x, .src0x, ._, ._ }, | 16669 | .{ ._, ._pd, .min, .tmp0x, .src0x, ._, ._ }, |
| 9970 | .{ ._, ._pd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, | 16670 | .{ ._, ._pd, .cmp, .dst0x, .src0x, .sp(.ord), ._ }, |
| 9971 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, | 16671 | .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, |
| 9972 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, | 16672 | .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, |
| 9973 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, | 16673 | .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, |
| ... | @@ -9977,9 +16677,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9977,9 +16677,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9977 | .src_constraints = .{ | 16677 | .src_constraints = .{ |
| 9978 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, | 16678 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 9979 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, | 16679 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 16680 | .any, |
| 9980 | }, | 16681 | }, |
| 9981 | .patterns = &.{ | 16682 | .patterns = &.{ |
| 9982 | .{ .src = .{ .to_sse, .to_sse } }, | 16683 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 9983 | }, | 16684 | }, |
| 9984 | .extra_temps = .{ | 16685 | .extra_temps = .{ |
| 9985 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, | 16686 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| ... | @@ -10003,9 +16704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10003,9 +16704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10003 | .src_constraints = .{ | 16704 | .src_constraints = .{ |
| 10004 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, | 16705 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 10005 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, | 16706 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 16707 | .any, |
| 10006 | }, | 16708 | }, |
| 10007 | .patterns = &.{ | 16709 | .patterns = &.{ |
| 10008 | .{ .src = .{ .to_mem, .to_mem } }, | 16710 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10009 | }, | 16711 | }, |
| 10010 | .extra_temps = .{ | 16712 | .extra_temps = .{ |
| 10011 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16713 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10036,9 +16738,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10036,9 +16738,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10036 | .src_constraints = .{ | 16738 | .src_constraints = .{ |
| 10037 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, | 16739 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10038 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, | 16740 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 16741 | .any, |
| 10039 | }, | 16742 | }, |
| 10040 | .patterns = &.{ | 16743 | .patterns = &.{ |
| 10041 | .{ .src = .{ .to_mem, .to_mem } }, | 16744 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10042 | }, | 16745 | }, |
| 10043 | .extra_temps = .{ | 16746 | .extra_temps = .{ |
| 10044 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16747 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10059,7 +16762,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10059,7 +16762,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10059 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 16762 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10060 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, | 16763 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 10061 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, | 16764 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 10062 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.unord), ._ }, | 16765 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.unord), ._ }, |
| 10063 | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, | 16766 | .{ ._, ._pd, .blendv, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| 10064 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | 16767 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 10065 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 16768 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| ... | @@ -10070,9 +16773,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10070,9 +16773,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10070 | .src_constraints = .{ | 16773 | .src_constraints = .{ |
| 10071 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, | 16774 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 10072 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, | 16775 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 16776 | .any, |
| 10073 | }, | 16777 | }, |
| 10074 | .patterns = &.{ | 16778 | .patterns = &.{ |
| 10075 | .{ .src = .{ .to_mem, .to_mem } }, | 16779 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10076 | }, | 16780 | }, |
| 10077 | .extra_temps = .{ | 16781 | .extra_temps = .{ |
| 10078 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16782 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10093,7 +16797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10093,7 +16797,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10093 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, | 16797 | .{ ._, ._pd, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_size), ._, ._ }, |
| 10094 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, | 16798 | .{ ._, ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 10095 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, | 16799 | .{ ._, ._pd, .min, .tmp3x, .tmp1x, ._, ._ }, |
| 10096 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .vp(.ord), ._ }, | 16800 | .{ ._, ._pd, .cmp, .tmp1x, .tmp1x, .sp(.ord), ._ }, |
| 10097 | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, | 16801 | .{ ._, ._pd, .@"and", .tmp3x, .tmp1x, ._, ._ }, |
| 10098 | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, | 16802 | .{ ._, ._pd, .andn, .tmp1x, .tmp2x, ._, ._ }, |
| 10099 | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, | 16803 | .{ ._, ._pd, .@"or", .tmp1x, .tmp3x, ._, ._ }, |
| ... | @@ -10106,9 +16810,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10106,9 +16810,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10106 | .src_constraints = .{ | 16810 | .src_constraints = .{ |
| 10107 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 16811 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 10108 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 16812 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 16813 | .any, |
| 10109 | }, | 16814 | }, |
| 10110 | .patterns = &.{ | 16815 | .patterns = &.{ |
| 10111 | .{ .src = .{ .to_mem, .to_mem } }, | 16816 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10112 | }, | 16817 | }, |
| 10113 | .call_frame = .{ .alignment = .@"16" }, | 16818 | .call_frame = .{ .alignment = .@"16" }, |
| 10114 | .extra_temps = .{ | 16819 | .extra_temps = .{ |
| ... | @@ -10140,11 +16845,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10140,11 +16845,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10140 | .src_constraints = .{ | 16845 | .src_constraints = .{ |
| 10141 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16846 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10142 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16847 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 16848 | .any, |
| 10143 | }, | 16849 | }, |
| 10144 | .patterns = &.{ | 16850 | .patterns = &.{ |
| 10145 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 16851 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 10146 | .{ .src = .{ .mem, .to_x87 } }, | 16852 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 10147 | .{ .src = .{ .to_x87, .to_x87 } }, | 16853 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 10148 | }, | 16854 | }, |
| 10149 | .extra_temps = .{ | 16855 | .extra_temps = .{ |
| 10150 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 16856 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | @@ -10172,11 +16878,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10172,11 +16878,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10172 | .src_constraints = .{ | 16878 | .src_constraints = .{ |
| 10173 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16879 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10174 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16880 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 16881 | .any, |
| 10175 | }, | 16882 | }, |
| 10176 | .patterns = &.{ | 16883 | .patterns = &.{ |
| 10177 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 16884 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 10178 | .{ .src = .{ .mem, .to_x87 } }, | 16885 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 10179 | .{ .src = .{ .to_x87, .to_x87 } }, | 16886 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 10180 | }, | 16887 | }, |
| 10181 | .extra_temps = .{ | 16888 | .extra_temps = .{ |
| 10182 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 16889 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | @@ -10210,11 +16917,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10210,11 +16917,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10210 | .src_constraints = .{ | 16917 | .src_constraints = .{ |
| 10211 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16918 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10212 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16919 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 16920 | .any, |
| 10213 | }, | 16921 | }, |
| 10214 | .patterns = &.{ | 16922 | .patterns = &.{ |
| 10215 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 16923 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 10216 | .{ .src = .{ .mem, .to_x87 } }, | 16924 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 10217 | .{ .src = .{ .to_x87, .to_x87 } }, | 16925 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 10218 | }, | 16926 | }, |
| 10219 | .extra_temps = .{ | 16927 | .extra_temps = .{ |
| 10220 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 16928 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | @@ -10248,9 +16956,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10248,9 +16956,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10248 | .src_constraints = .{ | 16956 | .src_constraints = .{ |
| 10249 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16957 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10250 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16958 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 16959 | .any, |
| 10251 | }, | 16960 | }, |
| 10252 | .patterns = &.{ | 16961 | .patterns = &.{ |
| 10253 | .{ .src = .{ .to_mem, .to_mem } }, | 16962 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10254 | }, | 16963 | }, |
| 10255 | .extra_temps = .{ | 16964 | .extra_temps = .{ |
| 10256 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 16965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10283,9 +16992,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10283,9 +16992,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10283 | .src_constraints = .{ | 16992 | .src_constraints = .{ |
| 10284 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16993 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10285 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 16994 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 16995 | .any, |
| 10286 | }, | 16996 | }, |
| 10287 | .patterns = &.{ | 16997 | .patterns = &.{ |
| 10288 | .{ .src = .{ .to_mem, .to_mem } }, | 16998 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10289 | }, | 16999 | }, |
| 10290 | .extra_temps = .{ | 17000 | .extra_temps = .{ |
| 10291 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17001 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10324,9 +17034,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10324,9 +17034,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10324 | .src_constraints = .{ | 17034 | .src_constraints = .{ |
| 10325 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 17035 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 10326 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 17036 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 17037 | .any, |
| 10327 | }, | 17038 | }, |
| 10328 | .patterns = &.{ | 17039 | .patterns = &.{ |
| 10329 | .{ .src = .{ .to_mem, .to_mem } }, | 17040 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10330 | }, | 17041 | }, |
| 10331 | .extra_temps = .{ | 17042 | .extra_temps = .{ |
| 10332 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17043 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10365,9 +17076,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10365,9 +17076,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10365 | .src_constraints = .{ | 17076 | .src_constraints = .{ |
| 10366 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, | 17077 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10367 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, | 17078 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 17079 | .any, |
| 10368 | }, | 17080 | }, |
| 10369 | .patterns = &.{ | 17081 | .patterns = &.{ |
| 10370 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 17082 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 10371 | }, | 17083 | }, |
| 10372 | .call_frame = .{ .alignment = .@"16" }, | 17084 | .call_frame = .{ .alignment = .@"16" }, |
| 10373 | .extra_temps = .{ | 17085 | .extra_temps = .{ |
| ... | @@ -10391,9 +17103,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10391,9 +17103,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10391 | .src_constraints = .{ | 17103 | .src_constraints = .{ |
| 10392 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 17104 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10393 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 17105 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 17106 | .any, |
| 10394 | }, | 17107 | }, |
| 10395 | .patterns = &.{ | 17108 | .patterns = &.{ |
| 10396 | .{ .src = .{ .to_mem, .to_mem } }, | 17109 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10397 | }, | 17110 | }, |
| 10398 | .call_frame = .{ .alignment = .@"16" }, | 17111 | .call_frame = .{ .alignment = .@"16" }, |
| 10399 | .extra_temps = .{ | 17112 | .extra_temps = .{ |
| ... | @@ -10423,9 +17136,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10423,9 +17136,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10423 | .src_constraints = .{ | 17136 | .src_constraints = .{ |
| 10424 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 17137 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10425 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 17138 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 17139 | .any, |
| 10426 | }, | 17140 | }, |
| 10427 | .patterns = &.{ | 17141 | .patterns = &.{ |
| 10428 | .{ .src = .{ .to_mem, .to_mem } }, | 17142 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10429 | }, | 17143 | }, |
| 10430 | .call_frame = .{ .alignment = .@"16" }, | 17144 | .call_frame = .{ .alignment = .@"16" }, |
| 10431 | .extra_temps = .{ | 17145 | .extra_temps = .{ |
| ... | @@ -10455,9 +17169,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10455,9 +17169,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10455 | .src_constraints = .{ | 17169 | .src_constraints = .{ |
| 10456 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 17170 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 10457 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 17171 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 17172 | .any, |
| 10458 | }, | 17173 | }, |
| 10459 | .patterns = &.{ | 17174 | .patterns = &.{ |
| 10460 | .{ .src = .{ .to_mem, .to_mem } }, | 17175 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10461 | }, | 17176 | }, |
| 10462 | .call_frame = .{ .alignment = .@"16" }, | 17177 | .call_frame = .{ .alignment = .@"16" }, |
| 10463 | .extra_temps = .{ | 17178 | .extra_temps = .{ |
| ... | @@ -10529,17 +17244,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10529,17 +17244,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10529 | })) { | 17244 | })) { |
| 10530 | else => unreachable, | 17245 | else => unreachable, |
| 10531 | inline .@"and", .@"or", .xor => |mir_tag| comptime &.{ .{ | 17246 | inline .@"and", .@"or", .xor => |mir_tag| comptime &.{ .{ |
| 10532 | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte } }, | 17247 | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte }, .any }, |
| 10533 | .patterns = &.{ | 17248 | .patterns = &.{ |
| 10534 | .{ .src = .{ .mut_mem, .imm8 } }, | 17249 | .{ .src = .{ .mut_mem, .imm8, .none } }, |
| 10535 | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, | 17250 | .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10536 | .{ .src = .{ .to_mut_gpr, .imm8 } }, | 17251 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 10537 | .{ .src = .{ .imm8, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17252 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10538 | .{ .src = .{ .mut_mem, .to_gpr } }, | 17253 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 10539 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 17254 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10540 | .{ .src = .{ .to_mut_gpr, .mem } }, | 17255 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 10541 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17256 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10542 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 17257 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10543 | }, | 17258 | }, |
| 10544 | .dst_temps = .{.{ .ref = .src0 }}, | 17259 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10545 | .clobbers = .{ .eflags = true }, | 17260 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10547,17 +17262,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10547,17 +17262,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10547 | .{ ._, ._, mir_tag, .dst0b, .src1b, ._, ._ }, | 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 | .patterns = &.{ | 17266 | .patterns = &.{ |
| 10552 | .{ .src = .{ .mut_mem, .imm16 } }, | 17267 | .{ .src = .{ .mut_mem, .imm16, .none } }, |
| 10553 | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, | 17268 | .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10554 | .{ .src = .{ .to_mut_gpr, .imm16 } }, | 17269 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 10555 | .{ .src = .{ .imm16, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17270 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10556 | .{ .src = .{ .mut_mem, .to_gpr } }, | 17271 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 10557 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 17272 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10558 | .{ .src = .{ .to_mut_gpr, .mem } }, | 17273 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 10559 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17274 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10560 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 17275 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10561 | }, | 17276 | }, |
| 10562 | .dst_temps = .{.{ .ref = .src0 }}, | 17277 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10563 | .clobbers = .{ .eflags = true }, | 17278 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10565,17 +17280,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10565,17 +17280,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10565 | .{ ._, ._, mir_tag, .dst0w, .src1w, ._, ._ }, | 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 | .patterns = &.{ | 17284 | .patterns = &.{ |
| 10570 | .{ .src = .{ .mut_mem, .imm32 } }, | 17285 | .{ .src = .{ .mut_mem, .imm32, .none } }, |
| 10571 | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, | 17286 | .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10572 | .{ .src = .{ .to_mut_gpr, .imm32 } }, | 17287 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 10573 | .{ .src = .{ .imm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17288 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10574 | .{ .src = .{ .mut_mem, .to_gpr } }, | 17289 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 10575 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 17290 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10576 | .{ .src = .{ .to_mut_gpr, .mem } }, | 17291 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 10577 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17292 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10578 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 17293 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10579 | }, | 17294 | }, |
| 10580 | .dst_temps = .{.{ .ref = .src0 }}, | 17295 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10581 | .clobbers = .{ .eflags = true }, | 17296 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10584,17 +17299,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10584,17 +17299,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10584 | } }, | 17299 | } }, |
| 10585 | }, .{ | 17300 | }, .{ |
| 10586 | .required_features = .{ .@"64bit", null, null, null }, | 17301 | .required_features = .{ .@"64bit", null, null, null }, |
| 10587 | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword } }, | 17302 | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword }, .any }, |
| 10588 | .patterns = &.{ | 17303 | .patterns = &.{ |
| 10589 | .{ .src = .{ .mut_mem, .simm32 } }, | 17304 | .{ .src = .{ .mut_mem, .simm32, .none } }, |
| 10590 | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, | 17305 | .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10591 | .{ .src = .{ .to_mut_gpr, .simm32 } }, | 17306 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 10592 | .{ .src = .{ .simm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17307 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10593 | .{ .src = .{ .mut_mem, .to_gpr } }, | 17308 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 10594 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 17309 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 10595 | .{ .src = .{ .to_mut_gpr, .mem } }, | 17310 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 10596 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 17311 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 10597 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 17312 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 10598 | }, | 17313 | }, |
| 10599 | .dst_temps = .{.{ .ref = .src0 }}, | 17314 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10600 | .clobbers = .{ .eflags = true }, | 17315 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10603,11 +17318,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10603,11 +17318,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10603 | } }, | 17318 | } }, |
| 10604 | }, .{ | 17319 | }, .{ |
| 10605 | .required_features = .{ .mmx, null, null, null }, | 17320 | .required_features = .{ .mmx, null, null, null }, |
| 10606 | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword } }, | 17321 | .src_constraints = .{ .{ .size = .qword }, .{ .size = .qword }, .any }, |
| 10607 | .patterns = &.{ | 17322 | .patterns = &.{ |
| 10608 | .{ .src = .{ .to_mut_mm, .mem } }, | 17323 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 10609 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, | 17324 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 10610 | .{ .src = .{ .to_mut_mm, .to_mm } }, | 17325 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 10611 | }, | 17326 | }, |
| 10612 | .dst_temps = .{.{ .ref = .src0 }}, | 17327 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10613 | .each = .{ .once = &.{ | 17328 | .each = .{ .once = &.{ |
| ... | @@ -10615,11 +17330,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10615,11 +17330,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10615 | } }, | 17330 | } }, |
| 10616 | }, .{ | 17331 | }, .{ |
| 10617 | .required_features = .{ .avx, null, null, null }, | 17332 | .required_features = .{ .avx, null, null, null }, |
| 10618 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword } }, | 17333 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any }, |
| 10619 | .patterns = &.{ | 17334 | .patterns = &.{ |
| 10620 | .{ .src = .{ .to_xmm, .mem } }, | 17335 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 10621 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, | 17336 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 10622 | .{ .src = .{ .to_xmm, .to_xmm } }, | 17337 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 10623 | }, | 17338 | }, |
| 10624 | .dst_temps = .{.{ .rc = .sse }}, | 17339 | .dst_temps = .{.{ .rc = .sse }}, |
| 10625 | .each = .{ .once = &.{ | 17340 | .each = .{ .once = &.{ |
| ... | @@ -10627,11 +17342,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10627,11 +17342,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10627 | } }, | 17342 | } }, |
| 10628 | }, .{ | 17343 | }, .{ |
| 10629 | .required_features = .{ .sse2, null, null, null }, | 17344 | .required_features = .{ .sse2, null, null, null }, |
| 10630 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword } }, | 17345 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any }, |
| 10631 | .patterns = &.{ | 17346 | .patterns = &.{ |
| 10632 | .{ .src = .{ .to_mut_xmm, .mem } }, | 17347 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 10633 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 17348 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 10634 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 17349 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 10635 | }, | 17350 | }, |
| 10636 | .dst_temps = .{.{ .ref = .src0 }}, | 17351 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10637 | .each = .{ .once = &.{ | 17352 | .each = .{ .once = &.{ |
| ... | @@ -10639,11 +17354,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10639,11 +17354,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10639 | } }, | 17354 | } }, |
| 10640 | }, .{ | 17355 | }, .{ |
| 10641 | .required_features = .{ .sse, null, null, null }, | 17356 | .required_features = .{ .sse, null, null, null }, |
| 10642 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword } }, | 17357 | .src_constraints = .{ .{ .size = .xword }, .{ .size = .xword }, .any }, |
| 10643 | .patterns = &.{ | 17358 | .patterns = &.{ |
| 10644 | .{ .src = .{ .to_mut_xmm, .mem } }, | 17359 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 10645 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 17360 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 10646 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 17361 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 10647 | }, | 17362 | }, |
| 10648 | .dst_temps = .{.{ .ref = .src0 }}, | 17363 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10649 | .each = .{ .once = &.{ | 17364 | .each = .{ .once = &.{ |
| ... | @@ -10651,11 +17366,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10651,11 +17366,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10651 | } }, | 17366 | } }, |
| 10652 | }, .{ | 17367 | }, .{ |
| 10653 | .required_features = .{ .avx2, null, null, null }, | 17368 | .required_features = .{ .avx2, null, null, null }, |
| 10654 | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword } }, | 17369 | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword }, .any }, |
| 10655 | .patterns = &.{ | 17370 | .patterns = &.{ |
| 10656 | .{ .src = .{ .to_ymm, .mem } }, | 17371 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 10657 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 17372 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 10658 | .{ .src = .{ .to_ymm, .to_ymm } }, | 17373 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 10659 | }, | 17374 | }, |
| 10660 | .dst_temps = .{.{ .rc = .sse }}, | 17375 | .dst_temps = .{.{ .rc = .sse }}, |
| 10661 | .each = .{ .once = &.{ | 17376 | .each = .{ .once = &.{ |
| ... | @@ -10663,11 +17378,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10663,11 +17378,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10663 | } }, | 17378 | } }, |
| 10664 | }, .{ | 17379 | }, .{ |
| 10665 | .required_features = .{ .avx, null, null, null }, | 17380 | .required_features = .{ .avx, null, null, null }, |
| 10666 | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword } }, | 17381 | .src_constraints = .{ .{ .size = .yword }, .{ .size = .yword }, .any }, |
| 10667 | .patterns = &.{ | 17382 | .patterns = &.{ |
| 10668 | .{ .src = .{ .to_ymm, .mem } }, | 17383 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 10669 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 17384 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 10670 | .{ .src = .{ .to_ymm, .to_ymm } }, | 17385 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 10671 | }, | 17386 | }, |
| 10672 | .dst_temps = .{.{ .rc = .sse }}, | 17387 | .dst_temps = .{.{ .rc = .sse }}, |
| 10673 | .each = .{ .once = &.{ | 17388 | .each = .{ .once = &.{ |
| ... | @@ -10675,9 +17390,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10675,9 +17390,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10675 | } }, | 17390 | } }, |
| 10676 | }, .{ | 17391 | }, .{ |
| 10677 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 17394 | .patterns = &.{ |
| 10680 | .{ .src = .{ .to_mem, .to_mem } }, | 17395 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10681 | }, | 17396 | }, |
| 10682 | .extra_temps = .{ | 17397 | .extra_temps = .{ |
| 10683 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17398 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10702,9 +17417,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10702,9 +17417,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10702 | } }, | 17417 | } }, |
| 10703 | }, .{ | 17418 | }, .{ |
| 10704 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17421 | .patterns = &.{ |
| 10707 | .{ .src = .{ .to_mem, .to_mem } }, | 17422 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10708 | }, | 17423 | }, |
| 10709 | .extra_temps = .{ | 17424 | .extra_temps = .{ |
| 10710 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17425 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10729,9 +17444,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10729,9 +17444,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10729 | } }, | 17444 | } }, |
| 10730 | }, .{ | 17445 | }, .{ |
| 10731 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17448 | .patterns = &.{ |
| 10734 | .{ .src = .{ .to_mem, .to_mem } }, | 17449 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10735 | }, | 17450 | }, |
| 10736 | .extra_temps = .{ | 17451 | .extra_temps = .{ |
| 10737 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17452 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10756,9 +17471,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10756,9 +17471,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10756 | } }, | 17471 | } }, |
| 10757 | }, .{ | 17472 | }, .{ |
| 10758 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 17475 | .patterns = &.{ |
| 10761 | .{ .src = .{ .to_mem, .to_mem } }, | 17476 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10762 | }, | 17477 | }, |
| 10763 | .extra_temps = .{ | 17478 | .extra_temps = .{ |
| 10764 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17479 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10783,9 +17498,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10783,9 +17498,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10783 | } }, | 17498 | } }, |
| 10784 | }, .{ | 17499 | }, .{ |
| 10785 | .required_features = .{ .sse, null, null, null }, | 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 | .patterns = &.{ | 17502 | .patterns = &.{ |
| 10788 | .{ .src = .{ .to_mem, .to_mem } }, | 17503 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10789 | }, | 17504 | }, |
| 10790 | .extra_temps = .{ | 17505 | .extra_temps = .{ |
| 10791 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17506 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10810,9 +17525,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10810,9 +17525,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10810 | } }, | 17525 | } }, |
| 10811 | }, .{ | 17526 | }, .{ |
| 10812 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 17529 | .patterns = &.{ |
| 10815 | .{ .src = .{ .to_mem, .to_mem } }, | 17530 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10816 | }, | 17531 | }, |
| 10817 | .extra_temps = .{ | 17532 | .extra_temps = .{ |
| 10818 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17533 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10836,9 +17551,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10836,9 +17551,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10836 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 17555 | .patterns = &.{ |
| 10841 | .{ .src = .{ .to_mem, .to_mem } }, | 17556 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 10842 | }, | 17557 | }, |
| 10843 | .extra_temps = .{ | 17558 | .extra_temps = .{ |
| 10844 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10878,20 +17593,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10878,20 +17593,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10878 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); | 17593 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 10879 | var res: [1]Temp = undefined; | 17594 | var res: [1]Temp = undefined; |
| 10880 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 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 | .patterns = &.{ | 17597 | .patterns = &.{ |
| 10883 | .{ .src = .{ .mut_mem, .none } }, | 17598 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10884 | .{ .src = .{ .to_mut_gpr, .none } }, | 17599 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10885 | }, | 17600 | }, |
| 10886 | .dst_temps = .{.{ .ref = .src0 }}, | 17601 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10887 | .each = .{ .once = &.{ | 17602 | .each = .{ .once = &.{ |
| 10888 | .{ ._, ._, .not, .dst0b, ._, ._, ._ }, | 17603 | .{ ._, ._, .not, .dst0b, ._, ._, ._ }, |
| 10889 | } }, | 17604 | } }, |
| 10890 | }, .{ | 17605 | }, .{ |
| 10891 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, | 17606 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 10892 | .patterns = &.{ | 17607 | .patterns = &.{ |
| 10893 | .{ .src = .{ .mut_mem, .none } }, | 17608 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10894 | .{ .src = .{ .to_mut_gpr, .none } }, | 17609 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10895 | }, | 17610 | }, |
| 10896 | .dst_temps = .{.{ .ref = .src0 }}, | 17611 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10897 | .clobbers = .{ .eflags = true }, | 17612 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10899,20 +17614,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10899,20 +17614,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10899 | .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_umax), ._, ._ }, | 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 | .patterns = &.{ | 17618 | .patterns = &.{ |
| 10904 | .{ .src = .{ .mut_mem, .none } }, | 17619 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10905 | .{ .src = .{ .to_mut_gpr, .none } }, | 17620 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10906 | }, | 17621 | }, |
| 10907 | .dst_temps = .{.{ .ref = .src0 }}, | 17622 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10908 | .each = .{ .once = &.{ | 17623 | .each = .{ .once = &.{ |
| 10909 | .{ ._, ._, .not, .dst0w, ._, ._, ._ }, | 17624 | .{ ._, ._, .not, .dst0w, ._, ._, ._ }, |
| 10910 | } }, | 17625 | } }, |
| 10911 | }, .{ | 17626 | }, .{ |
| 10912 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, | 17627 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 10913 | .patterns = &.{ | 17628 | .patterns = &.{ |
| 10914 | .{ .src = .{ .mut_mem, .none } }, | 17629 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10915 | .{ .src = .{ .to_mut_gpr, .none } }, | 17630 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10916 | }, | 17631 | }, |
| 10917 | .dst_temps = .{.{ .ref = .src0 }}, | 17632 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10918 | .clobbers = .{ .eflags = true }, | 17633 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10920,20 +17635,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10920,20 +17635,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10920 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_umax), ._, ._ }, | 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 | .patterns = &.{ | 17639 | .patterns = &.{ |
| 10925 | .{ .src = .{ .mut_mem, .none } }, | 17640 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10926 | .{ .src = .{ .to_mut_gpr, .none } }, | 17641 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10927 | }, | 17642 | }, |
| 10928 | .dst_temps = .{.{ .ref = .src0 }}, | 17643 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10929 | .each = .{ .once = &.{ | 17644 | .each = .{ .once = &.{ |
| 10930 | .{ ._, ._, .not, .dst0d, ._, ._, ._ }, | 17645 | .{ ._, ._, .not, .dst0d, ._, ._, ._ }, |
| 10931 | } }, | 17646 | } }, |
| 10932 | }, .{ | 17647 | }, .{ |
| 10933 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, | 17648 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 10934 | .patterns = &.{ | 17649 | .patterns = &.{ |
| 10935 | .{ .src = .{ .mut_mem, .none } }, | 17650 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10936 | .{ .src = .{ .to_mut_gpr, .none } }, | 17651 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10937 | }, | 17652 | }, |
| 10938 | .dst_temps = .{.{ .ref = .src0 }}, | 17653 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10939 | .clobbers = .{ .eflags = true }, | 17654 | .clobbers = .{ .eflags = true }, |
| ... | @@ -10942,10 +17657,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10942,10 +17657,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10942 | } }, | 17657 | } }, |
| 10943 | }, .{ | 17658 | }, .{ |
| 10944 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 17661 | .patterns = &.{ |
| 10947 | .{ .src = .{ .mut_mem, .none } }, | 17662 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 10948 | .{ .src = .{ .to_mut_gpr, .none } }, | 17663 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 10949 | }, | 17664 | }, |
| 10950 | .dst_temps = .{.{ .ref = .src0 }}, | 17665 | .dst_temps = .{.{ .ref = .src0 }}, |
| 10951 | .each = .{ .once = &.{ | 17666 | .each = .{ .once = &.{ |
| ... | @@ -10953,10 +17668,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10953,10 +17668,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10953 | } }, | 17668 | } }, |
| 10954 | }, .{ | 17669 | }, .{ |
| 10955 | .required_features = .{ .@"64bit", null, null, null }, | 17670 | .required_features = .{ .@"64bit", null, null, null }, |
| 10956 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, | 17671 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 10957 | .patterns = &.{ | 17672 | .patterns = &.{ |
| 10958 | .{ .src = .{ .mem, .none } }, | 17673 | .{ .src = .{ .mem, .none, .none } }, |
| 10959 | .{ .src = .{ .to_gpr, .none } }, | 17674 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 10960 | }, | 17675 | }, |
| 10961 | .dst_temps = .{.{ .rc = .general_purpose }}, | 17676 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 10962 | .each = .{ .once = &.{ | 17677 | .each = .{ .once = &.{ |
| ... | @@ -10965,10 +17680,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10965,10 +17680,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10965 | } }, | 17680 | } }, |
| 10966 | }, .{ | 17681 | }, .{ |
| 10967 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 17684 | .patterns = &.{ |
| 10970 | .{ .src = .{ .mem, .none } }, | 17685 | .{ .src = .{ .mem, .none, .none } }, |
| 10971 | .{ .src = .{ .to_mm, .none } }, | 17686 | .{ .src = .{ .to_mm, .none, .none } }, |
| 10972 | }, | 17687 | }, |
| 10973 | .dst_temps = .{.{ .rc = .mmx }}, | 17688 | .dst_temps = .{.{ .rc = .mmx }}, |
| 10974 | .each = .{ .once = &.{ | 17689 | .each = .{ .once = &.{ |
| ... | @@ -10977,9 +17692,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10977,9 +17692,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10977 | } }, | 17692 | } }, |
| 10978 | }, .{ | 17693 | }, .{ |
| 10979 | .required_features = .{ .mmx, null, null, null }, | 17694 | .required_features = .{ .mmx, null, null, null }, |
| 10980 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, | 17695 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 10981 | .patterns = &.{ | 17696 | .patterns = &.{ |
| 10982 | .{ .src = .{ .to_mut_mm, .none } }, | 17697 | .{ .src = .{ .to_mut_mm, .none, .none } }, |
| 10983 | }, | 17698 | }, |
| 10984 | .extra_temps = .{ | 17699 | .extra_temps = .{ |
| 10985 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 17700 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -10999,10 +17714,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10999,10 +17714,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10999 | } }, | 17714 | } }, |
| 11000 | }, .{ | 17715 | }, .{ |
| 11001 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17718 | .patterns = &.{ |
| 11004 | .{ .src = .{ .mem, .none } }, | 17719 | .{ .src = .{ .mem, .none, .none } }, |
| 11005 | .{ .src = .{ .to_xmm, .none } }, | 17720 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11006 | }, | 17721 | }, |
| 11007 | .dst_temps = .{.{ .rc = .sse }}, | 17722 | .dst_temps = .{.{ .rc = .sse }}, |
| 11008 | .each = .{ .once = &.{ | 17723 | .each = .{ .once = &.{ |
| ... | @@ -11011,9 +17726,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11011,9 +17726,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11011 | } }, | 17726 | } }, |
| 11012 | }, .{ | 17727 | }, .{ |
| 11013 | .required_features = .{ .avx, null, null, null }, | 17728 | .required_features = .{ .avx, null, null, null }, |
| 11014 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any }, | 17729 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 11015 | .patterns = &.{ | 17730 | .patterns = &.{ |
| 11016 | .{ .src = .{ .to_xmm, .none } }, | 17731 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11017 | }, | 17732 | }, |
| 11018 | .extra_temps = .{ | 17733 | .extra_temps = .{ |
| 11019 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 17734 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11033,10 +17748,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11033,10 +17748,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11033 | } }, | 17748 | } }, |
| 11034 | }, .{ | 17749 | }, .{ |
| 11035 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 17752 | .patterns = &.{ |
| 11038 | .{ .src = .{ .mem, .none } }, | 17753 | .{ .src = .{ .mem, .none, .none } }, |
| 11039 | .{ .src = .{ .to_xmm, .none } }, | 17754 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11040 | }, | 17755 | }, |
| 11041 | .dst_temps = .{.{ .rc = .sse }}, | 17756 | .dst_temps = .{.{ .rc = .sse }}, |
| 11042 | .each = .{ .once = &.{ | 17757 | .each = .{ .once = &.{ |
| ... | @@ -11045,9 +17760,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11045,9 +17760,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11045 | } }, | 17760 | } }, |
| 11046 | }, .{ | 17761 | }, .{ |
| 11047 | .required_features = .{ .sse2, null, null, null }, | 17762 | .required_features = .{ .sse2, null, null, null }, |
| 11048 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any }, | 17763 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 11049 | .patterns = &.{ | 17764 | .patterns = &.{ |
| 11050 | .{ .src = .{ .to_mut_xmm, .none } }, | 17765 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11051 | }, | 17766 | }, |
| 11052 | .extra_temps = .{ | 17767 | .extra_temps = .{ |
| 11053 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 17768 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11067,9 +17782,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11067,9 +17782,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11067 | } }, | 17782 | } }, |
| 11068 | }, .{ | 17783 | }, .{ |
| 11069 | .required_features = .{ .sse, null, null, null }, | 17784 | .required_features = .{ .sse, null, null, null }, |
| 11070 | .src_constraints = .{ .{ .int = .xword }, .any }, | 17785 | .src_constraints = .{ .{ .int = .xword }, .any, .any }, |
| 11071 | .patterns = &.{ | 17786 | .patterns = &.{ |
| 11072 | .{ .src = .{ .to_mut_xmm, .none } }, | 17787 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11073 | }, | 17788 | }, |
| 11074 | .extra_temps = .{ | 17789 | .extra_temps = .{ |
| 11075 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 17790 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11089,10 +17804,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11089,10 +17804,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11089 | } }, | 17804 | } }, |
| 11090 | }, .{ | 17805 | }, .{ |
| 11091 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 17808 | .patterns = &.{ |
| 11094 | .{ .src = .{ .mem, .none } }, | 17809 | .{ .src = .{ .mem, .none, .none } }, |
| 11095 | .{ .src = .{ .to_ymm, .none } }, | 17810 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11096 | }, | 17811 | }, |
| 11097 | .dst_temps = .{.{ .rc = .sse }}, | 17812 | .dst_temps = .{.{ .rc = .sse }}, |
| 11098 | .each = .{ .once = &.{ | 17813 | .each = .{ .once = &.{ |
| ... | @@ -11101,9 +17816,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11101,9 +17816,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11101 | } }, | 17816 | } }, |
| 11102 | }, .{ | 17817 | }, .{ |
| 11103 | .required_features = .{ .avx2, null, null, null }, | 17818 | .required_features = .{ .avx2, null, null, null }, |
| 11104 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any }, | 17819 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any, .any }, |
| 11105 | .patterns = &.{ | 17820 | .patterns = &.{ |
| 11106 | .{ .src = .{ .to_ymm, .none } }, | 17821 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11107 | }, | 17822 | }, |
| 11108 | .extra_temps = .{ | 17823 | .extra_temps = .{ |
| 11109 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 17824 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11123,10 +17838,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11123,10 +17838,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11123 | } }, | 17838 | } }, |
| 11124 | }, .{ | 17839 | }, .{ |
| 11125 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17842 | .patterns = &.{ |
| 11128 | .{ .src = .{ .mem, .none } }, | 17843 | .{ .src = .{ .mem, .none, .none } }, |
| 11129 | .{ .src = .{ .to_ymm, .none } }, | 17844 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11130 | }, | 17845 | }, |
| 11131 | .dst_temps = .{.{ .rc = .sse }}, | 17846 | .dst_temps = .{.{ .rc = .sse }}, |
| 11132 | .each = .{ .once = &.{ | 17847 | .each = .{ .once = &.{ |
| ... | @@ -11135,9 +17850,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11135,9 +17850,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11135 | } }, | 17850 | } }, |
| 11136 | }, .{ | 17851 | }, .{ |
| 11137 | .required_features = .{ .avx, null, null, null }, | 17852 | .required_features = .{ .avx, null, null, null }, |
| 11138 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any }, | 17853 | .src_constraints = .{ .{ .unsigned_int = .yword }, .any, .any }, |
| 11139 | .patterns = &.{ | 17854 | .patterns = &.{ |
| 11140 | .{ .src = .{ .to_ymm, .none } }, | 17855 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11141 | }, | 17856 | }, |
| 11142 | .extra_temps = .{ | 17857 | .extra_temps = .{ |
| 11143 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 17858 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11157,9 +17872,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11157,9 +17872,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11157 | } }, | 17872 | } }, |
| 11158 | }, .{ | 17873 | }, .{ |
| 11159 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 17876 | .patterns = &.{ |
| 11162 | .{ .src = .{ .to_mem, .none } }, | 17877 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11163 | }, | 17878 | }, |
| 11164 | .extra_temps = .{ | 17879 | .extra_temps = .{ |
| 11165 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11186,9 +17901,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11186,9 +17901,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11186 | } }, | 17901 | } }, |
| 11187 | }, .{ | 17902 | }, .{ |
| 11188 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 17905 | .patterns = &.{ |
| 11191 | .{ .src = .{ .to_mem, .none } }, | 17906 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11192 | }, | 17907 | }, |
| 11193 | .extra_temps = .{ | 17908 | .extra_temps = .{ |
| 11194 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17909 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11213,9 +17928,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11213,9 +17928,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11213 | } }, | 17928 | } }, |
| 11214 | }, .{ | 17929 | }, .{ |
| 11215 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17932 | .patterns = &.{ |
| 11218 | .{ .src = .{ .to_mem, .none } }, | 17933 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11219 | }, | 17934 | }, |
| 11220 | .extra_temps = .{ | 17935 | .extra_temps = .{ |
| 11221 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17936 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11242,9 +17957,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11242,9 +17957,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11242 | } }, | 17957 | } }, |
| 11243 | }, .{ | 17958 | }, .{ |
| 11244 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17961 | .patterns = &.{ |
| 11247 | .{ .src = .{ .to_mem, .none } }, | 17962 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11248 | }, | 17963 | }, |
| 11249 | .extra_temps = .{ | 17964 | .extra_temps = .{ |
| 11250 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11269,9 +17984,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11269,9 +17984,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11269 | } }, | 17984 | } }, |
| 11270 | }, .{ | 17985 | }, .{ |
| 11271 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 17988 | .patterns = &.{ |
| 11274 | .{ .src = .{ .to_mem, .none } }, | 17989 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11275 | }, | 17990 | }, |
| 11276 | .extra_temps = .{ | 17991 | .extra_temps = .{ |
| 11277 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 17992 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11296,9 +18011,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11296,9 +18011,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11296 | } }, | 18011 | } }, |
| 11297 | }, .{ | 18012 | }, .{ |
| 11298 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 18015 | .patterns = &.{ |
| 11301 | .{ .src = .{ .to_mem, .none } }, | 18016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11302 | }, | 18017 | }, |
| 11303 | .extra_temps = .{ | 18018 | .extra_temps = .{ |
| 11304 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11324,9 +18039,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11324,9 +18039,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11324 | } }, | 18039 | } }, |
| 11325 | }, .{ | 18040 | }, .{ |
| 11326 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18043 | .patterns = &.{ |
| 11329 | .{ .src = .{ .mut_mem, .none } }, | 18044 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11330 | }, | 18045 | }, |
| 11331 | .extra_temps = .{ | 18046 | .extra_temps = .{ |
| 11332 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18047 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11350,9 +18065,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11350,9 +18065,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11350 | } }, | 18065 | } }, |
| 11351 | }, .{ | 18066 | }, .{ |
| 11352 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18069 | .patterns = &.{ |
| 11355 | .{ .src = .{ .to_mem, .none } }, | 18070 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11356 | }, | 18071 | }, |
| 11357 | .extra_temps = .{ | 18072 | .extra_temps = .{ |
| 11358 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11377,9 +18092,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11377,9 +18092,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11377 | } }, | 18092 | } }, |
| 11378 | }, .{ | 18093 | }, .{ |
| 11379 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18096 | .patterns = &.{ |
| 11382 | .{ .src = .{ .mut_mem, .none } }, | 18097 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11383 | }, | 18098 | }, |
| 11384 | .extra_temps = .{ | 18099 | .extra_temps = .{ |
| 11385 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18100 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11404,9 +18119,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11404,9 +18119,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11404 | } }, | 18119 | } }, |
| 11405 | }, .{ | 18120 | }, .{ |
| 11406 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18123 | .patterns = &.{ |
| 11409 | .{ .src = .{ .to_mem, .none } }, | 18124 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11410 | }, | 18125 | }, |
| 11411 | .extra_temps = .{ | 18126 | .extra_temps = .{ |
| 11412 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18127 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11436,9 +18151,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11436,9 +18151,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11436 | } }, | 18151 | } }, |
| 11437 | }, .{ | 18152 | }, .{ |
| 11438 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18155 | .patterns = &.{ |
| 11441 | .{ .src = .{ .mut_mem, .none } }, | 18156 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11442 | }, | 18157 | }, |
| 11443 | .extra_temps = .{ | 18158 | .extra_temps = .{ |
| 11444 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18159 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11463,9 +18178,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11463,9 +18178,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11463 | } }, | 18178 | } }, |
| 11464 | }, .{ | 18179 | }, .{ |
| 11465 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18182 | .patterns = &.{ |
| 11468 | .{ .src = .{ .to_mem, .none } }, | 18183 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11469 | }, | 18184 | }, |
| 11470 | .extra_temps = .{ | 18185 | .extra_temps = .{ |
| 11471 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18186 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11491,9 +18206,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11491,9 +18206,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11491 | } }, | 18206 | } }, |
| 11492 | }, .{ | 18207 | }, .{ |
| 11493 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18210 | .patterns = &.{ |
| 11496 | .{ .src = .{ .mut_mem, .none } }, | 18211 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11497 | }, | 18212 | }, |
| 11498 | .extra_temps = .{ | 18213 | .extra_temps = .{ |
| 11499 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11517,9 +18232,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11517,9 +18232,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11517 | } }, | 18232 | } }, |
| 11518 | }, .{ | 18233 | }, .{ |
| 11519 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18236 | .patterns = &.{ |
| 11522 | .{ .src = .{ .to_mem, .none } }, | 18237 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11523 | }, | 18238 | }, |
| 11524 | .extra_temps = .{ | 18239 | .extra_temps = .{ |
| 11525 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18240 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11548,9 +18263,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11548,9 +18263,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11548 | } }, | 18263 | } }, |
| 11549 | }, .{ | 18264 | }, .{ |
| 11550 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18267 | .patterns = &.{ |
| 11553 | .{ .src = .{ .mut_mem, .none } }, | 18268 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11554 | }, | 18269 | }, |
| 11555 | .extra_temps = .{ | 18270 | .extra_temps = .{ |
| 11556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11575,9 +18290,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11575,9 +18290,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11575 | } }, | 18290 | } }, |
| 11576 | }, .{ | 18291 | }, .{ |
| 11577 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18294 | .patterns = &.{ |
| 11580 | .{ .src = .{ .to_mem, .none } }, | 18295 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11581 | }, | 18296 | }, |
| 11582 | .extra_temps = .{ | 18297 | .extra_temps = .{ |
| 11583 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11607,9 +18322,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11607,9 +18322,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11607 | } }, | 18322 | } }, |
| 11608 | }, .{ | 18323 | }, .{ |
| 11609 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18326 | .patterns = &.{ |
| 11612 | .{ .src = .{ .mut_mem, .none } }, | 18327 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11613 | }, | 18328 | }, |
| 11614 | .extra_temps = .{ | 18329 | .extra_temps = .{ |
| 11615 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18330 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11633,9 +18348,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11633,9 +18348,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11633 | } }, | 18348 | } }, |
| 11634 | }, .{ | 18349 | }, .{ |
| 11635 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18352 | .patterns = &.{ |
| 11638 | .{ .src = .{ .to_mem, .none } }, | 18353 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11639 | }, | 18354 | }, |
| 11640 | .extra_temps = .{ | 18355 | .extra_temps = .{ |
| 11641 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18356 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11664,9 +18379,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11664,9 +18379,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11664 | } }, | 18379 | } }, |
| 11665 | }, .{ | 18380 | }, .{ |
| 11666 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18383 | .patterns = &.{ |
| 11669 | .{ .src = .{ .mut_mem, .none } }, | 18384 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11670 | }, | 18385 | }, |
| 11671 | .extra_temps = .{ | 18386 | .extra_temps = .{ |
| 11672 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18387 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11692,9 +18407,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11692,9 +18407,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11692 | } }, | 18407 | } }, |
| 11693 | }, .{ | 18408 | }, .{ |
| 11694 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18411 | .patterns = &.{ |
| 11697 | .{ .src = .{ .to_mem, .none } }, | 18412 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11698 | }, | 18413 | }, |
| 11699 | .extra_temps = .{ | 18414 | .extra_temps = .{ |
| 11700 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18415 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11723,9 +18438,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11723,9 +18438,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11723 | } }, | 18438 | } }, |
| 11724 | }, .{ | 18439 | }, .{ |
| 11725 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18442 | .patterns = &.{ |
| 11728 | .{ .src = .{ .mut_mem, .none } }, | 18443 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 11729 | }, | 18444 | }, |
| 11730 | .extra_temps = .{ | 18445 | .extra_temps = .{ |
| 11731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11750,9 +18465,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11750,9 +18465,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11750 | } }, | 18465 | } }, |
| 11751 | }, .{ | 18466 | }, .{ |
| 11752 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 18469 | .patterns = &.{ |
| 11755 | .{ .src = .{ .to_mem, .none } }, | 18470 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11756 | }, | 18471 | }, |
| 11757 | .extra_temps = .{ | 18472 | .extra_temps = .{ |
| 11758 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18473 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11780,10 +18495,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11780,10 +18495,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11780 | } }, | 18495 | } }, |
| 11781 | }, .{ | 18496 | }, .{ |
| 11782 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 18499 | .patterns = &.{ |
| 11785 | .{ .src = .{ .mem, .none } }, | 18500 | .{ .src = .{ .mem, .none, .none } }, |
| 11786 | .{ .src = .{ .to_mm, .none } }, | 18501 | .{ .src = .{ .to_mm, .none, .none } }, |
| 11787 | }, | 18502 | }, |
| 11788 | .dst_temps = .{.{ .rc = .mmx }}, | 18503 | .dst_temps = .{.{ .rc = .mmx }}, |
| 11789 | .each = .{ .once = &.{ | 18504 | .each = .{ .once = &.{ |
| ... | @@ -11792,9 +18507,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11792,9 +18507,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11792 | } }, | 18507 | } }, |
| 11793 | }, .{ | 18508 | }, .{ |
| 11794 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 18511 | .patterns = &.{ |
| 11797 | .{ .src = .{ .to_mut_mm, .none } }, | 18512 | .{ .src = .{ .to_mut_mm, .none, .none } }, |
| 11798 | }, | 18513 | }, |
| 11799 | .extra_temps = .{ | 18514 | .extra_temps = .{ |
| 11800 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 18515 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11814,10 +18529,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11814,10 +18529,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11814 | } }, | 18529 | } }, |
| 11815 | }, .{ | 18530 | }, .{ |
| 11816 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 18533 | .patterns = &.{ |
| 11819 | .{ .src = .{ .mem, .none } }, | 18534 | .{ .src = .{ .mem, .none, .none } }, |
| 11820 | .{ .src = .{ .to_xmm, .none } }, | 18535 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11821 | }, | 18536 | }, |
| 11822 | .dst_temps = .{.{ .rc = .sse }}, | 18537 | .dst_temps = .{.{ .rc = .sse }}, |
| 11823 | .each = .{ .once = &.{ | 18538 | .each = .{ .once = &.{ |
| ... | @@ -11826,9 +18541,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11826,9 +18541,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11826 | } }, | 18541 | } }, |
| 11827 | }, .{ | 18542 | }, .{ |
| 11828 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 18545 | .patterns = &.{ |
| 11831 | .{ .src = .{ .to_xmm, .none } }, | 18546 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11832 | }, | 18547 | }, |
| 11833 | .extra_temps = .{ | 18548 | .extra_temps = .{ |
| 11834 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 18549 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11848,10 +18563,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11848,10 +18563,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11848 | } }, | 18563 | } }, |
| 11849 | }, .{ | 18564 | }, .{ |
| 11850 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 18567 | .patterns = &.{ |
| 11853 | .{ .src = .{ .mem, .none } }, | 18568 | .{ .src = .{ .mem, .none, .none } }, |
| 11854 | .{ .src = .{ .to_xmm, .none } }, | 18569 | .{ .src = .{ .to_xmm, .none, .none } }, |
| 11855 | }, | 18570 | }, |
| 11856 | .dst_temps = .{.{ .rc = .sse }}, | 18571 | .dst_temps = .{.{ .rc = .sse }}, |
| 11857 | .each = .{ .once = &.{ | 18572 | .each = .{ .once = &.{ |
| ... | @@ -11860,9 +18575,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11860,9 +18575,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11860 | } }, | 18575 | } }, |
| 11861 | }, .{ | 18576 | }, .{ |
| 11862 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 18579 | .patterns = &.{ |
| 11865 | .{ .src = .{ .to_mut_xmm, .none } }, | 18580 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11866 | }, | 18581 | }, |
| 11867 | .extra_temps = .{ | 18582 | .extra_temps = .{ |
| 11868 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 18583 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11882,9 +18597,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11882,9 +18597,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11882 | } }, | 18597 | } }, |
| 11883 | }, .{ | 18598 | }, .{ |
| 11884 | .required_features = .{ .sse, null, null, null }, | 18599 | .required_features = .{ .sse, null, null, null }, |
| 11885 | .src_constraints = .{ .{ .vec = .xword }, .any }, | 18600 | .src_constraints = .{ .{ .vec = .xword }, .any, .any }, |
| 11886 | .patterns = &.{ | 18601 | .patterns = &.{ |
| 11887 | .{ .src = .{ .to_mut_xmm, .none } }, | 18602 | .{ .src = .{ .to_mut_xmm, .none, .none } }, |
| 11888 | }, | 18603 | }, |
| 11889 | .extra_temps = .{ | 18604 | .extra_temps = .{ |
| 11890 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 18605 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11904,10 +18619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11904,10 +18619,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11904 | } }, | 18619 | } }, |
| 11905 | }, .{ | 18620 | }, .{ |
| 11906 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 18623 | .patterns = &.{ |
| 11909 | .{ .src = .{ .mem, .none } }, | 18624 | .{ .src = .{ .mem, .none, .none } }, |
| 11910 | .{ .src = .{ .to_ymm, .none } }, | 18625 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11911 | }, | 18626 | }, |
| 11912 | .dst_temps = .{.{ .rc = .sse }}, | 18627 | .dst_temps = .{.{ .rc = .sse }}, |
| 11913 | .each = .{ .once = &.{ | 18628 | .each = .{ .once = &.{ |
| ... | @@ -11916,9 +18631,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11916,9 +18631,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11916 | } }, | 18631 | } }, |
| 11917 | }, .{ | 18632 | }, .{ |
| 11918 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 18635 | .patterns = &.{ |
| 11921 | .{ .src = .{ .to_ymm, .none } }, | 18636 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11922 | }, | 18637 | }, |
| 11923 | .extra_temps = .{ | 18638 | .extra_temps = .{ |
| 11924 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 18639 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11938,10 +18653,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11938,10 +18653,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11938 | } }, | 18653 | } }, |
| 11939 | }, .{ | 18654 | }, .{ |
| 11940 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 18657 | .patterns = &.{ |
| 11943 | .{ .src = .{ .mem, .none } }, | 18658 | .{ .src = .{ .mem, .none, .none } }, |
| 11944 | .{ .src = .{ .to_ymm, .none } }, | 18659 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11945 | }, | 18660 | }, |
| 11946 | .dst_temps = .{.{ .rc = .sse }}, | 18661 | .dst_temps = .{.{ .rc = .sse }}, |
| 11947 | .each = .{ .once = &.{ | 18662 | .each = .{ .once = &.{ |
| ... | @@ -11950,9 +18665,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11950,9 +18665,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11950 | } }, | 18665 | } }, |
| 11951 | }, .{ | 18666 | }, .{ |
| 11952 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 18669 | .patterns = &.{ |
| 11955 | .{ .src = .{ .to_ymm, .none } }, | 18670 | .{ .src = .{ .to_ymm, .none, .none } }, |
| 11956 | }, | 18671 | }, |
| 11957 | .extra_temps = .{ | 18672 | .extra_temps = .{ |
| 11958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 18673 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11973,7 +18688,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11973,7 +18688,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11973 | }, .{ | 18688 | }, .{ |
| 11974 | .required_features = .{ .@"64bit", null, null, null }, | 18689 | .required_features = .{ .@"64bit", null, null, null }, |
| 11975 | .patterns = &.{ | 18690 | .patterns = &.{ |
| 11976 | .{ .src = .{ .to_mem, .none } }, | 18691 | .{ .src = .{ .to_mem, .none, .none } }, |
| 11977 | }, | 18692 | }, |
| 11978 | .extra_temps = .{ | 18693 | .extra_temps = .{ |
| 11979 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18694 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -11999,7 +18714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -11999,7 +18714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 11999 | } }, | 18714 | } }, |
| 12000 | }, .{ | 18715 | }, .{ |
| 12001 | .patterns = &.{ | 18716 | .patterns = &.{ |
| 12002 | .{ .src = .{ .to_mem, .none } }, | 18717 | .{ .src = .{ .to_mem, .none, .none } }, |
| 12003 | }, | 18718 | }, |
| 12004 | .extra_temps = .{ | 18719 | .extra_temps = .{ |
| 12005 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 18720 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12089,10 +18804,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12089,10 +18804,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12089 | var res: [1]Temp = undefined; | 18804 | var res: [1]Temp = undefined; |
| 12090 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 18805 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 12091 | .required_features = .{ .slow_incdec, null, null, null }, | 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 | .patterns = &.{ | 18808 | .patterns = &.{ |
| 12094 | .{ .src = .{ .mut_mem, .none } }, | 18809 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 12095 | .{ .src = .{ .to_mut_gpr, .none } }, | 18810 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12096 | }, | 18811 | }, |
| 12097 | .dst_temps = .{.{ .ref = .src0 }}, | 18812 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12098 | .clobbers = .{ .eflags = true }, | 18813 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12100,10 +18815,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12100,10 +18815,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12100 | .{ ._, ._, .add, .dst0b, .si(1), ._, ._ }, | 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 | .patterns = &.{ | 18819 | .patterns = &.{ |
| 12105 | .{ .src = .{ .mut_mem, .none } }, | 18820 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 12106 | .{ .src = .{ .to_mut_gpr, .none } }, | 18821 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12107 | }, | 18822 | }, |
| 12108 | .dst_temps = .{.{ .ref = .src0 }}, | 18823 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12109 | .clobbers = .{ .eflags = true }, | 18824 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12111,10 +18826,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12111,10 +18826,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12111 | .{ ._, ._c, .in, .dst0b, ._, ._, ._ }, | 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 | .patterns = &.{ | 18830 | .patterns = &.{ |
| 12116 | .{ .src = .{ .mut_mem, .none } }, | 18831 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 12117 | .{ .src = .{ .to_mut_gpr, .none } }, | 18832 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12118 | }, | 18833 | }, |
| 12119 | .dst_temps = .{.{ .ref = .src0 }}, | 18834 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12120 | .clobbers = .{ .eflags = true }, | 18835 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12123,10 +18838,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12123,10 +18838,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12123 | } }, | 18838 | } }, |
| 12124 | }, .{ | 18839 | }, .{ |
| 12125 | .required_features = .{ .lzcnt, null, null, null }, | 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 | .patterns = &.{ | 18842 | .patterns = &.{ |
| 12128 | .{ .src = .{ .mem, .none } }, | 18843 | .{ .src = .{ .mem, .none, .none } }, |
| 12129 | .{ .src = .{ .to_gpr, .none } }, | 18844 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12130 | }, | 18845 | }, |
| 12131 | .dst_temps = .{.{ .rc = .general_purpose }}, | 18846 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12132 | .clobbers = .{ .eflags = true }, | 18847 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12137,10 +18852,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12137,10 +18852,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12137 | } }, | 18852 | } }, |
| 12138 | }, .{ | 18853 | }, .{ |
| 12139 | .required_features = .{ .lzcnt, null, null, null }, | 18854 | .required_features = .{ .lzcnt, null, null, null }, |
| 12140 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, | 18855 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 12141 | .patterns = &.{ | 18856 | .patterns = &.{ |
| 12142 | .{ .src = .{ .mem, .none } }, | 18857 | .{ .src = .{ .mem, .none, .none } }, |
| 12143 | .{ .src = .{ .to_gpr, .none } }, | 18858 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12144 | }, | 18859 | }, |
| 12145 | .dst_temps = .{.{ .rc = .general_purpose }}, | 18860 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12146 | .clobbers = .{ .eflags = true }, | 18861 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12152,9 +18867,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12152,9 +18867,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12152 | } }, | 18867 | } }, |
| 12153 | }, .{ | 18868 | }, .{ |
| 12154 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, | 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 | .patterns = &.{ | 18871 | .patterns = &.{ |
| 12157 | .{ .src = .{ .to_mut_gpr, .none } }, | 18872 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12158 | }, | 18873 | }, |
| 12159 | .dst_temps = .{.{ .ref = .src0 }}, | 18874 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12160 | .clobbers = .{ .eflags = true }, | 18875 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12163,10 +18878,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12163,10 +18878,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12163 | } }, | 18878 | } }, |
| 12164 | }, .{ | 18879 | }, .{ |
| 12165 | .required_features = .{ .lzcnt, null, null, null }, | 18880 | .required_features = .{ .lzcnt, null, null, null }, |
| 12166 | .src_constraints = .{ .{ .exact_int = 16 }, .any }, | 18881 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| 12167 | .patterns = &.{ | 18882 | .patterns = &.{ |
| 12168 | .{ .src = .{ .mem, .none } }, | 18883 | .{ .src = .{ .mem, .none, .none } }, |
| 12169 | .{ .src = .{ .to_gpr, .none } }, | 18884 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12170 | }, | 18885 | }, |
| 12171 | .dst_temps = .{.{ .rc = .general_purpose }}, | 18886 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12172 | .clobbers = .{ .eflags = true }, | 18887 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12175,9 +18890,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12175,9 +18890,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12175 | } }, | 18890 | } }, |
| 12176 | }, .{ | 18891 | }, .{ |
| 12177 | .required_features = .{ .lzcnt, null, null, null }, | 18892 | .required_features = .{ .lzcnt, null, null, null }, |
| 12178 | .src_constraints = .{ .{ .signed_int = .word }, .any }, | 18893 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 12179 | .patterns = &.{ | 18894 | .patterns = &.{ |
| 12180 | .{ .src = .{ .to_mut_gpr, .none } }, | 18895 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12181 | }, | 18896 | }, |
| 12182 | .dst_temps = .{.{ .ref = .src0 }}, | 18897 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12183 | .clobbers = .{ .eflags = true }, | 18898 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12188,9 +18903,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12188,9 +18903,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12188 | } }, | 18903 | } }, |
| 12189 | }, .{ | 18904 | }, .{ |
| 12190 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, | 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 | .patterns = &.{ | 18907 | .patterns = &.{ |
| 12193 | .{ .src = .{ .to_mut_gpr, .none } }, | 18908 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12194 | }, | 18909 | }, |
| 12195 | .dst_temps = .{.{ .ref = .src0 }}, | 18910 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12196 | .clobbers = .{ .eflags = true }, | 18911 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12200,10 +18915,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12200,10 +18915,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12200 | } }, | 18915 | } }, |
| 12201 | }, .{ | 18916 | }, .{ |
| 12202 | .required_features = .{ .lzcnt, null, null, null }, | 18917 | .required_features = .{ .lzcnt, null, null, null }, |
| 12203 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, | 18918 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12204 | .patterns = &.{ | 18919 | .patterns = &.{ |
| 12205 | .{ .src = .{ .mem, .none } }, | 18920 | .{ .src = .{ .mem, .none, .none } }, |
| 12206 | .{ .src = .{ .to_gpr, .none } }, | 18921 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12207 | }, | 18922 | }, |
| 12208 | .dst_temps = .{.{ .rc = .general_purpose }}, | 18923 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12209 | .clobbers = .{ .eflags = true }, | 18924 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12213,9 +18928,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12213,9 +18928,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12213 | } }, | 18928 | } }, |
| 12214 | }, .{ | 18929 | }, .{ |
| 12215 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, | 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 | .patterns = &.{ | 18932 | .patterns = &.{ |
| 12218 | .{ .src = .{ .to_mut_gpr, .none } }, | 18933 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12219 | }, | 18934 | }, |
| 12220 | .dst_temps = .{.{ .ref = .src0 }}, | 18935 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12221 | .clobbers = .{ .eflags = true }, | 18936 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12224,10 +18939,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12224,10 +18939,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12224 | } }, | 18939 | } }, |
| 12225 | }, .{ | 18940 | }, .{ |
| 12226 | .required_features = .{ .lzcnt, null, null, null }, | 18941 | .required_features = .{ .lzcnt, null, null, null }, |
| 12227 | .src_constraints = .{ .{ .exact_int = 32 }, .any }, | 18942 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| 12228 | .patterns = &.{ | 18943 | .patterns = &.{ |
| 12229 | .{ .src = .{ .mem, .none } }, | 18944 | .{ .src = .{ .mem, .none, .none } }, |
| 12230 | .{ .src = .{ .to_gpr, .none } }, | 18945 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12231 | }, | 18946 | }, |
| 12232 | .dst_temps = .{.{ .rc = .general_purpose }}, | 18947 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12233 | .clobbers = .{ .eflags = true }, | 18948 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12236,9 +18951,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12236,9 +18951,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12236 | } }, | 18951 | } }, |
| 12237 | }, .{ | 18952 | }, .{ |
| 12238 | .required_features = .{ .lzcnt, null, null, null }, | 18953 | .required_features = .{ .lzcnt, null, null, null }, |
| 12239 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, | 18954 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 12240 | .patterns = &.{ | 18955 | .patterns = &.{ |
| 12241 | .{ .src = .{ .to_mut_gpr, .none } }, | 18956 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12242 | }, | 18957 | }, |
| 12243 | .dst_temps = .{.{ .ref = .src0 }}, | 18958 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12244 | .clobbers = .{ .eflags = true }, | 18959 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12249,9 +18964,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12249,9 +18964,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12249 | } }, | 18964 | } }, |
| 12250 | }, .{ | 18965 | }, .{ |
| 12251 | .required_features = .{ .false_deps_lzcnt_tzcnt, .lzcnt, null, null }, | 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 | .patterns = &.{ | 18968 | .patterns = &.{ |
| 12254 | .{ .src = .{ .to_mut_gpr, .none } }, | 18969 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12255 | }, | 18970 | }, |
| 12256 | .dst_temps = .{.{ .ref = .src0 }}, | 18971 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12257 | .clobbers = .{ .eflags = true }, | 18972 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12261,10 +18976,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12261,10 +18976,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12261 | } }, | 18976 | } }, |
| 12262 | }, .{ | 18977 | }, .{ |
| 12263 | .required_features = .{ .lzcnt, null, null, null }, | 18978 | .required_features = .{ .lzcnt, null, null, null }, |
| 12264 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, | 18979 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12265 | .patterns = &.{ | 18980 | .patterns = &.{ |
| 12266 | .{ .src = .{ .mem, .none } }, | 18981 | .{ .src = .{ .mem, .none, .none } }, |
| 12267 | .{ .src = .{ .to_gpr, .none } }, | 18982 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12268 | }, | 18983 | }, |
| 12269 | .dst_temps = .{.{ .rc = .general_purpose }}, | 18984 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12270 | .clobbers = .{ .eflags = true }, | 18985 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12274,9 +18989,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12274,9 +18989,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12274 | } }, | 18989 | } }, |
| 12275 | }, .{ | 18990 | }, .{ |
| 12276 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .patterns = &.{ | 18993 | .patterns = &.{ |
| 12279 | .{ .src = .{ .to_mut_gpr, .none } }, | 18994 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12280 | }, | 18995 | }, |
| 12281 | .dst_temps = .{.{ .ref = .src0 }}, | 18996 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12282 | .clobbers = .{ .eflags = true }, | 18997 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12285,10 +19000,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12285,10 +19000,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12285 | } }, | 19000 | } }, |
| 12286 | }, .{ | 19001 | }, .{ |
| 12287 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 19002 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 12288 | .src_constraints = .{ .{ .exact_int = 64 }, .any }, | 19003 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| 12289 | .patterns = &.{ | 19004 | .patterns = &.{ |
| 12290 | .{ .src = .{ .mem, .none } }, | 19005 | .{ .src = .{ .mem, .none, .none } }, |
| 12291 | .{ .src = .{ .to_gpr, .none } }, | 19006 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12292 | }, | 19007 | }, |
| 12293 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19008 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12294 | .clobbers = .{ .eflags = true }, | 19009 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12297,10 +19012,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12297,10 +19012,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12297 | } }, | 19012 | } }, |
| 12298 | }, .{ | 19013 | }, .{ |
| 12299 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 19014 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 12300 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, | 19015 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 12301 | .patterns = &.{ | 19016 | .patterns = &.{ |
| 12302 | .{ .src = .{ .mem, .none } }, | 19017 | .{ .src = .{ .mem, .none, .none } }, |
| 12303 | .{ .src = .{ .to_gpr, .none } }, | 19018 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12304 | }, | 19019 | }, |
| 12305 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19020 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12306 | .clobbers = .{ .eflags = true }, | 19021 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12312,9 +19027,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12312,9 +19027,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12312 | } }, | 19027 | } }, |
| 12313 | }, .{ | 19028 | }, .{ |
| 12314 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .patterns = &.{ | 19031 | .patterns = &.{ |
| 12317 | .{ .src = .{ .to_mut_gpr, .none } }, | 19032 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12318 | }, | 19033 | }, |
| 12319 | .dst_temps = .{.{ .ref = .src0 }}, | 19034 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12320 | .clobbers = .{ .eflags = true }, | 19035 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12324,10 +19039,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12324,10 +19039,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12324 | } }, | 19039 | } }, |
| 12325 | }, .{ | 19040 | }, .{ |
| 12326 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 19041 | .required_features = .{ .@"64bit", .lzcnt, null, null }, |
| 12327 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, | 19042 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 12328 | .patterns = &.{ | 19043 | .patterns = &.{ |
| 12329 | .{ .src = .{ .mem, .none } }, | 19044 | .{ .src = .{ .mem, .none, .none } }, |
| 12330 | .{ .src = .{ .to_gpr, .none } }, | 19045 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12331 | }, | 19046 | }, |
| 12332 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19047 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12333 | .clobbers = .{ .eflags = true }, | 19048 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12337,10 +19052,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12337,10 +19052,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12337 | } }, | 19052 | } }, |
| 12338 | }, .{ | 19053 | }, .{ |
| 12339 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19056 | .patterns = &.{ |
| 12342 | .{ .src = .{ .mem, .none } }, | 19057 | .{ .src = .{ .mem, .none, .none } }, |
| 12343 | .{ .src = .{ .to_gpr, .none } }, | 19058 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12344 | }, | 19059 | }, |
| 12345 | .extra_temps = .{ | 19060 | .extra_temps = .{ |
| 12346 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19061 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12364,10 +19079,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12364,10 +19079,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12364 | } }, | 19079 | } }, |
| 12365 | }, .{ | 19080 | }, .{ |
| 12366 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19083 | .patterns = &.{ |
| 12369 | .{ .src = .{ .mem, .none } }, | 19084 | .{ .src = .{ .mem, .none, .none } }, |
| 12370 | .{ .src = .{ .to_gpr, .none } }, | 19085 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12371 | }, | 19086 | }, |
| 12372 | .extra_temps = .{ | 19087 | .extra_temps = .{ |
| 12373 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19088 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12392,10 +19107,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12392,10 +19107,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12392 | } }, | 19107 | } }, |
| 12393 | }, .{ | 19108 | }, .{ |
| 12394 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19111 | .patterns = &.{ |
| 12397 | .{ .src = .{ .mem, .none } }, | 19112 | .{ .src = .{ .mem, .none, .none } }, |
| 12398 | .{ .src = .{ .to_gpr, .none } }, | 19113 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12399 | }, | 19114 | }, |
| 12400 | .extra_temps = .{ | 19115 | .extra_temps = .{ |
| 12401 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19116 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12421,10 +19136,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12421,10 +19136,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12421 | } }, | 19136 | } }, |
| 12422 | }, .{ | 19137 | }, .{ |
| 12423 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19140 | .patterns = &.{ |
| 12426 | .{ .src = .{ .mem, .none } }, | 19141 | .{ .src = .{ .mem, .none, .none } }, |
| 12427 | .{ .src = .{ .to_gpr, .none } }, | 19142 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12428 | }, | 19143 | }, |
| 12429 | .extra_temps = .{ | 19144 | .extra_temps = .{ |
| 12430 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19145 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12449,10 +19164,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12449,10 +19164,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12449 | } }, | 19164 | } }, |
| 12450 | }, .{ | 19165 | }, .{ |
| 12451 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19168 | .patterns = &.{ |
| 12454 | .{ .src = .{ .mem, .none } }, | 19169 | .{ .src = .{ .mem, .none, .none } }, |
| 12455 | .{ .src = .{ .to_gpr, .none } }, | 19170 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12456 | }, | 19171 | }, |
| 12457 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19172 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12458 | .clobbers = .{ .eflags = true }, | 19173 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12465,10 +19180,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12465,10 +19180,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12465 | } }, | 19180 | } }, |
| 12466 | }, .{ | 19181 | }, .{ |
| 12467 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19184 | .patterns = &.{ |
| 12470 | .{ .src = .{ .mem, .none } }, | 19185 | .{ .src = .{ .mem, .none, .none } }, |
| 12471 | .{ .src = .{ .to_gpr, .none } }, | 19186 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12472 | }, | 19187 | }, |
| 12473 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19188 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12474 | .clobbers = .{ .eflags = true }, | 19189 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12482,10 +19197,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12482,10 +19197,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12482 | } }, | 19197 | } }, |
| 12483 | }, .{ | 19198 | }, .{ |
| 12484 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19201 | .patterns = &.{ |
| 12487 | .{ .src = .{ .mem, .none } }, | 19202 | .{ .src = .{ .mem, .none, .none } }, |
| 12488 | .{ .src = .{ .to_gpr, .none } }, | 19203 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12489 | }, | 19204 | }, |
| 12490 | .extra_temps = .{ | 19205 | .extra_temps = .{ |
| 12491 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19206 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12511,10 +19226,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12511,10 +19226,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12511 | } }, | 19226 | } }, |
| 12512 | }, .{ | 19227 | }, .{ |
| 12513 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19230 | .patterns = &.{ |
| 12516 | .{ .src = .{ .mem, .none } }, | 19231 | .{ .src = .{ .mem, .none, .none } }, |
| 12517 | .{ .src = .{ .to_gpr, .none } }, | 19232 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12518 | }, | 19233 | }, |
| 12519 | .extra_temps = .{ | 19234 | .extra_temps = .{ |
| 12520 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19235 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12538,10 +19253,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12538,10 +19253,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12538 | .{ ._, ._, .sbb, .dst0b, .tmp0b, ._, ._ }, | 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 | .patterns = &.{ | 19257 | .patterns = &.{ |
| 12543 | .{ .src = .{ .mem, .none } }, | 19258 | .{ .src = .{ .mem, .none, .none } }, |
| 12544 | .{ .src = .{ .to_gpr, .none } }, | 19259 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12545 | }, | 19260 | }, |
| 12546 | .extra_temps = .{ | 19261 | .extra_temps = .{ |
| 12547 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19262 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12563,10 +19278,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12563,10 +19278,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12563 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, | 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 | .patterns = &.{ | 19282 | .patterns = &.{ |
| 12568 | .{ .src = .{ .mem, .none } }, | 19283 | .{ .src = .{ .mem, .none, .none } }, |
| 12569 | .{ .src = .{ .to_gpr, .none } }, | 19284 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12570 | }, | 19285 | }, |
| 12571 | .extra_temps = .{ | 19286 | .extra_temps = .{ |
| 12572 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19287 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12589,10 +19304,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12589,10 +19304,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12589 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, | 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 | .patterns = &.{ | 19308 | .patterns = &.{ |
| 12594 | .{ .src = .{ .mem, .none } }, | 19309 | .{ .src = .{ .mem, .none, .none } }, |
| 12595 | .{ .src = .{ .to_gpr, .none } }, | 19310 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12596 | }, | 19311 | }, |
| 12597 | .extra_temps = .{ | 19312 | .extra_temps = .{ |
| 12598 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19313 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12616,10 +19331,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12616,10 +19331,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12616 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, | 19331 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| 12617 | } }, | 19332 | } }, |
| 12618 | }, .{ | 19333 | }, .{ |
| 12619 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any }, | 19334 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 12620 | .patterns = &.{ | 19335 | .patterns = &.{ |
| 12621 | .{ .src = .{ .mem, .none } }, | 19336 | .{ .src = .{ .mem, .none, .none } }, |
| 12622 | .{ .src = .{ .to_gpr, .none } }, | 19337 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12623 | }, | 19338 | }, |
| 12624 | .extra_temps = .{ | 19339 | .extra_temps = .{ |
| 12625 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19340 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12643,9 +19358,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12643,9 +19358,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12643 | } }, | 19358 | } }, |
| 12644 | }, .{ | 19359 | }, .{ |
| 12645 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19362 | .patterns = &.{ |
| 12648 | .{ .src = .{ .to_mut_gpr, .none } }, | 19363 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12649 | }, | 19364 | }, |
| 12650 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19365 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12651 | .clobbers = .{ .eflags = true }, | 19366 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12657,9 +19372,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12657,9 +19372,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12657 | } }, | 19372 | } }, |
| 12658 | }, .{ | 19373 | }, .{ |
| 12659 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19376 | .patterns = &.{ |
| 12662 | .{ .src = .{ .to_mut_gpr, .none } }, | 19377 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12663 | }, | 19378 | }, |
| 12664 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19379 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12665 | .clobbers = .{ .eflags = true }, | 19380 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12673,9 +19388,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12673,9 +19388,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12673 | } }, | 19388 | } }, |
| 12674 | }, .{ | 19389 | }, .{ |
| 12675 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19392 | .patterns = &.{ |
| 12678 | .{ .src = .{ .to_mut_gpr, .none } }, | 19393 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12679 | }, | 19394 | }, |
| 12680 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19395 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12681 | .clobbers = .{ .eflags = true }, | 19396 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12688,9 +19403,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12688,9 +19403,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12688 | } }, | 19403 | } }, |
| 12689 | }, .{ | 19404 | }, .{ |
| 12690 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19407 | .patterns = &.{ |
| 12693 | .{ .src = .{ .to_mut_gpr, .none } }, | 19408 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12694 | }, | 19409 | }, |
| 12695 | .dst_temps = .{.{ .ref = .src0 }}, | 19410 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12696 | .clobbers = .{ .eflags = true }, | 19411 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12702,9 +19417,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12702,9 +19417,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12702 | } }, | 19417 | } }, |
| 12703 | }, .{ | 19418 | }, .{ |
| 12704 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19421 | .patterns = &.{ |
| 12707 | .{ .src = .{ .to_mut_gpr, .none } }, | 19422 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12708 | }, | 19423 | }, |
| 12709 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19424 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12710 | .clobbers = .{ .eflags = true }, | 19425 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12718,9 +19433,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12718,9 +19433,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12718 | } }, | 19433 | } }, |
| 12719 | }, .{ | 19434 | }, .{ |
| 12720 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19437 | .patterns = &.{ |
| 12723 | .{ .src = .{ .to_mut_gpr, .none } }, | 19438 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12724 | }, | 19439 | }, |
| 12725 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19440 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12726 | .clobbers = .{ .eflags = true }, | 19441 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12732,10 +19447,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12732,10 +19447,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12732 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, | 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 | .patterns = &.{ | 19451 | .patterns = &.{ |
| 12737 | .{ .src = .{ .mem, .none } }, | 19452 | .{ .src = .{ .mem, .none, .none } }, |
| 12738 | .{ .src = .{ .to_gpr, .none } }, | 19453 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12739 | }, | 19454 | }, |
| 12740 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19455 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12741 | .clobbers = .{ .eflags = true }, | 19456 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12745,9 +19460,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12745,9 +19460,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12745 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, | 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 | .patterns = &.{ | 19464 | .patterns = &.{ |
| 12750 | .{ .src = .{ .to_mut_gpr, .none } }, | 19465 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12751 | }, | 19466 | }, |
| 12752 | .extra_temps = .{ | 19467 | .extra_temps = .{ |
| 12753 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 19468 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12770,10 +19485,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12770,10 +19485,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12770 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, | 19485 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| 12771 | } }, | 19486 | } }, |
| 12772 | }, .{ | 19487 | }, .{ |
| 12773 | .src_constraints = .{ .{ .unsigned_int = .word }, .any }, | 19488 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 12774 | .patterns = &.{ | 19489 | .patterns = &.{ |
| 12775 | .{ .src = .{ .mem, .none } }, | 19490 | .{ .src = .{ .mem, .none, .none } }, |
| 12776 | .{ .src = .{ .to_gpr, .none } }, | 19491 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12777 | }, | 19492 | }, |
| 12778 | .extra_temps = .{ | 19493 | .extra_temps = .{ |
| 12779 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 19494 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12796,9 +19511,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12796,9 +19511,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12796 | } }, | 19511 | } }, |
| 12797 | }, .{ | 19512 | }, .{ |
| 12798 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19515 | .patterns = &.{ |
| 12801 | .{ .src = .{ .to_mut_gpr, .none } }, | 19516 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12802 | }, | 19517 | }, |
| 12803 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19518 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12804 | .clobbers = .{ .eflags = true }, | 19519 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12810,9 +19525,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12810,9 +19525,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12810 | } }, | 19525 | } }, |
| 12811 | }, .{ | 19526 | }, .{ |
| 12812 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19529 | .patterns = &.{ |
| 12815 | .{ .src = .{ .to_mut_gpr, .none } }, | 19530 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12816 | }, | 19531 | }, |
| 12817 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19532 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12818 | .clobbers = .{ .eflags = true }, | 19533 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12826,9 +19541,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12826,9 +19541,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12826 | } }, | 19541 | } }, |
| 12827 | }, .{ | 19542 | }, .{ |
| 12828 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19545 | .patterns = &.{ |
| 12831 | .{ .src = .{ .to_mut_gpr, .none } }, | 19546 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12832 | }, | 19547 | }, |
| 12833 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19548 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12834 | .clobbers = .{ .eflags = true }, | 19549 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12841,9 +19556,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12841,9 +19556,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12841 | } }, | 19556 | } }, |
| 12842 | }, .{ | 19557 | }, .{ |
| 12843 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19560 | .patterns = &.{ |
| 12846 | .{ .src = .{ .to_mut_gpr, .none } }, | 19561 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12847 | }, | 19562 | }, |
| 12848 | .dst_temps = .{.{ .ref = .src0 }}, | 19563 | .dst_temps = .{.{ .ref = .src0 }}, |
| 12849 | .clobbers = .{ .eflags = true }, | 19564 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12855,9 +19570,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12855,9 +19570,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12855 | } }, | 19570 | } }, |
| 12856 | }, .{ | 19571 | }, .{ |
| 12857 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19574 | .patterns = &.{ |
| 12860 | .{ .src = .{ .to_mut_gpr, .none } }, | 19575 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12861 | }, | 19576 | }, |
| 12862 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19577 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12863 | .clobbers = .{ .eflags = true }, | 19578 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12871,9 +19586,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12871,9 +19586,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12871 | } }, | 19586 | } }, |
| 12872 | }, .{ | 19587 | }, .{ |
| 12873 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 19590 | .patterns = &.{ |
| 12876 | .{ .src = .{ .to_mut_gpr, .none } }, | 19591 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12877 | }, | 19592 | }, |
| 12878 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19593 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12879 | .clobbers = .{ .eflags = true }, | 19594 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12885,10 +19600,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12885,10 +19600,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12885 | .{ ._, ._, .sbb, .dst0b, .src0b, ._, ._ }, | 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 | .patterns = &.{ | 19604 | .patterns = &.{ |
| 12890 | .{ .src = .{ .mem, .none } }, | 19605 | .{ .src = .{ .mem, .none, .none } }, |
| 12891 | .{ .src = .{ .to_gpr, .none } }, | 19606 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12892 | }, | 19607 | }, |
| 12893 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19608 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12894 | .clobbers = .{ .eflags = true }, | 19609 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12898,9 +19613,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12898,9 +19613,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12898 | .{ ._, ._, .xor, .dst0b, .sia(-1, .src0, .add_bit_size), ._, ._ }, | 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 | .patterns = &.{ | 19617 | .patterns = &.{ |
| 12903 | .{ .src = .{ .to_mut_gpr, .none } }, | 19618 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12904 | }, | 19619 | }, |
| 12905 | .extra_temps = .{ | 19620 | .extra_temps = .{ |
| 12906 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19621 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12923,10 +19638,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12923,10 +19638,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12923 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, | 19638 | .{ ._, ._, .sub, .dst0b, .tmp0b, ._, ._ }, |
| 12924 | } }, | 19639 | } }, |
| 12925 | }, .{ | 19640 | }, .{ |
| 12926 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any }, | 19641 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 12927 | .patterns = &.{ | 19642 | .patterns = &.{ |
| 12928 | .{ .src = .{ .mem, .none } }, | 19643 | .{ .src = .{ .mem, .none, .none } }, |
| 12929 | .{ .src = .{ .to_gpr, .none } }, | 19644 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12930 | }, | 19645 | }, |
| 12931 | .extra_temps = .{ | 19646 | .extra_temps = .{ |
| 12932 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19647 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12949,9 +19664,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12949,9 +19664,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12949 | } }, | 19664 | } }, |
| 12950 | }, .{ | 19665 | }, .{ |
| 12951 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, | 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 | .patterns = &.{ | 19668 | .patterns = &.{ |
| 12954 | .{ .src = .{ .to_mut_gpr, .none } }, | 19669 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12955 | }, | 19670 | }, |
| 12956 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19671 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 12957 | .clobbers = .{ .eflags = true }, | 19672 | .clobbers = .{ .eflags = true }, |
| ... | @@ -12963,10 +19678,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12963,10 +19678,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12963 | } }, | 19678 | } }, |
| 12964 | }, .{ | 19679 | }, .{ |
| 12965 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, | 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 | .patterns = &.{ | 19682 | .patterns = &.{ |
| 12968 | .{ .src = .{ .mem, .none } }, | 19683 | .{ .src = .{ .mem, .none, .none } }, |
| 12969 | .{ .src = .{ .to_gpr, .none } }, | 19684 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 12970 | }, | 19685 | }, |
| 12971 | .extra_temps = .{ | 19686 | .extra_temps = .{ |
| 12972 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 19687 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -12992,9 +19707,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12992,9 +19707,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12992 | } }, | 19707 | } }, |
| 12993 | }, .{ | 19708 | }, .{ |
| 12994 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, | 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 | .patterns = &.{ | 19711 | .patterns = &.{ |
| 12997 | .{ .src = .{ .to_mut_gpr, .none } }, | 19712 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 12998 | }, | 19713 | }, |
| 12999 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19714 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 13000 | .clobbers = .{ .eflags = true }, | 19715 | .clobbers = .{ .eflags = true }, |
| ... | @@ -13007,9 +19722,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13007,9 +19722,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13007 | } }, | 19722 | } }, |
| 13008 | }, .{ | 19723 | }, .{ |
| 13009 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19726 | .patterns = &.{ |
| 13012 | .{ .src = .{ .to_mut_gpr, .none } }, | 19727 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 13013 | }, | 19728 | }, |
| 13014 | .dst_temps = .{.{ .ref = .src0 }}, | 19729 | .dst_temps = .{.{ .ref = .src0 }}, |
| 13015 | .clobbers = .{ .eflags = true }, | 19730 | .clobbers = .{ .eflags = true }, |
| ... | @@ -13021,10 +19736,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13021,10 +19736,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13021 | } }, | 19736 | } }, |
| 13022 | }, .{ | 19737 | }, .{ |
| 13023 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19740 | .patterns = &.{ |
| 13026 | .{ .src = .{ .mem, .none } }, | 19741 | .{ .src = .{ .mem, .none, .none } }, |
| 13027 | .{ .src = .{ .to_gpr, .none } }, | 19742 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13028 | }, | 19743 | }, |
| 13029 | .extra_temps = .{ | 19744 | .extra_temps = .{ |
| 13030 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 19745 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13050,9 +19765,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13050,9 +19765,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13050 | } }, | 19765 | } }, |
| 13051 | }, .{ | 19766 | }, .{ |
| 13052 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19769 | .patterns = &.{ |
| 13055 | .{ .src = .{ .to_mut_gpr, .none } }, | 19770 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 13056 | }, | 19771 | }, |
| 13057 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19772 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 13058 | .clobbers = .{ .eflags = true }, | 19773 | .clobbers = .{ .eflags = true }, |
| ... | @@ -13065,10 +19780,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13065,10 +19780,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13065 | } }, | 19780 | } }, |
| 13066 | }, .{ | 19781 | }, .{ |
| 13067 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 19784 | .patterns = &.{ |
| 13070 | .{ .src = .{ .mem, .none } }, | 19785 | .{ .src = .{ .mem, .none, .none } }, |
| 13071 | .{ .src = .{ .to_gpr, .none } }, | 19786 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13072 | }, | 19787 | }, |
| 13073 | .dst_temps = .{.{ .rc = .general_purpose }}, | 19788 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 13074 | .clobbers = .{ .eflags = true }, | 19789 | .clobbers = .{ .eflags = true }, |
| ... | @@ -13079,10 +19794,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13079,10 +19794,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13079 | } }, | 19794 | } }, |
| 13080 | }, .{ | 19795 | }, .{ |
| 13081 | .required_features = .{ .@"64bit", null, null, null }, | 19796 | .required_features = .{ .@"64bit", null, null, null }, |
| 13082 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, | 19797 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 13083 | .patterns = &.{ | 19798 | .patterns = &.{ |
| 13084 | .{ .src = .{ .mem, .none } }, | 19799 | .{ .src = .{ .mem, .none, .none } }, |
| 13085 | .{ .src = .{ .to_gpr, .none } }, | 19800 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13086 | }, | 19801 | }, |
| 13087 | .extra_temps = .{ | 19802 | .extra_temps = .{ |
| 13088 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 19803 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13107,10 +19822,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13107,10 +19822,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13107 | } }, | 19822 | } }, |
| 13108 | }, .{ | 19823 | }, .{ |
| 13109 | .required_features = .{ .@"64bit", null, null, null }, | 19824 | .required_features = .{ .@"64bit", null, null, null }, |
| 13110 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any }, | 19825 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 13111 | .patterns = &.{ | 19826 | .patterns = &.{ |
| 13112 | .{ .src = .{ .mem, .none } }, | 19827 | .{ .src = .{ .mem, .none, .none } }, |
| 13113 | .{ .src = .{ .to_gpr, .none } }, | 19828 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 13114 | }, | 19829 | }, |
| 13115 | .extra_temps = .{ | 19830 | .extra_temps = .{ |
| 13116 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 19831 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13133,9 +19848,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13133,9 +19848,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13133 | } }, | 19848 | } }, |
| 13134 | }, .{ | 19849 | }, .{ |
| 13135 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .patterns = &.{ | 19852 | .patterns = &.{ |
| 13138 | .{ .src = .{ .to_mem, .none } }, | 19853 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13139 | }, | 19854 | }, |
| 13140 | .extra_temps = .{ | 19855 | .extra_temps = .{ |
| 13141 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19856 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13163,9 +19878,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13163,9 +19878,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13163 | } }, | 19878 | } }, |
| 13164 | }, .{ | 19879 | }, .{ |
| 13165 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .patterns = &.{ | 19882 | .patterns = &.{ |
| 13168 | .{ .src = .{ .to_mem, .none } }, | 19883 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13169 | }, | 19884 | }, |
| 13170 | .extra_temps = .{ | 19885 | .extra_temps = .{ |
| 13171 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19886 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13192,9 +19907,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13192,9 +19907,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13192 | } }, | 19907 | } }, |
| 13193 | }, .{ | 19908 | }, .{ |
| 13194 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 19911 | .patterns = &.{ |
| 13197 | .{ .src = .{ .to_mem, .none } }, | 19912 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13198 | }, | 19913 | }, |
| 13199 | .extra_temps = .{ | 19914 | .extra_temps = .{ |
| 13200 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19915 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13223,9 +19938,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13223,9 +19938,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13223 | } }, | 19938 | } }, |
| 13224 | }, .{ | 19939 | }, .{ |
| 13225 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 19942 | .patterns = &.{ |
| 13228 | .{ .src = .{ .to_mem, .none } }, | 19943 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13229 | }, | 19944 | }, |
| 13230 | .extra_temps = .{ | 19945 | .extra_temps = .{ |
| 13231 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19946 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13253,9 +19968,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13253,9 +19968,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13253 | } }, | 19968 | } }, |
| 13254 | }, .{ | 19969 | }, .{ |
| 13255 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .patterns = &.{ | 19972 | .patterns = &.{ |
| 13258 | .{ .src = .{ .to_mem, .none } }, | 19973 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13259 | }, | 19974 | }, |
| 13260 | .extra_temps = .{ | 19975 | .extra_temps = .{ |
| 13261 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 19976 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13283,9 +19998,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13283,9 +19998,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13283 | } }, | 19998 | } }, |
| 13284 | }, .{ | 19999 | }, .{ |
| 13285 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .patterns = &.{ | 20002 | .patterns = &.{ |
| 13288 | .{ .src = .{ .to_mem, .none } }, | 20003 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13289 | }, | 20004 | }, |
| 13290 | .extra_temps = .{ | 20005 | .extra_temps = .{ |
| 13291 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20006 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13312,9 +20027,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13312,9 +20027,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13312 | } }, | 20027 | } }, |
| 13313 | }, .{ | 20028 | }, .{ |
| 13314 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 20031 | .patterns = &.{ |
| 13317 | .{ .src = .{ .to_mem, .none } }, | 20032 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13318 | }, | 20033 | }, |
| 13319 | .extra_temps = .{ | 20034 | .extra_temps = .{ |
| 13320 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20035 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13343,9 +20058,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13343,9 +20058,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13343 | } }, | 20058 | } }, |
| 13344 | }, .{ | 20059 | }, .{ |
| 13345 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 20062 | .patterns = &.{ |
| 13348 | .{ .src = .{ .to_mem, .none } }, | 20063 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13349 | }, | 20064 | }, |
| 13350 | .extra_temps = .{ | 20065 | .extra_temps = .{ |
| 13351 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20066 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13373,9 +20088,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13373,9 +20088,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13373 | } }, | 20088 | } }, |
| 13374 | }, .{ | 20089 | }, .{ |
| 13375 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .patterns = &.{ | 20092 | .patterns = &.{ |
| 13378 | .{ .src = .{ .to_mem, .none } }, | 20093 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13379 | }, | 20094 | }, |
| 13380 | .extra_temps = .{ | 20095 | .extra_temps = .{ |
| 13381 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20096 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13406,9 +20121,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13406,9 +20121,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13406 | } }, | 20121 | } }, |
| 13407 | }, .{ | 20122 | }, .{ |
| 13408 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .patterns = &.{ | 20125 | .patterns = &.{ |
| 13411 | .{ .src = .{ .to_mem, .none } }, | 20126 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13412 | }, | 20127 | }, |
| 13413 | .extra_temps = .{ | 20128 | .extra_temps = .{ |
| 13414 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20129 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13438,9 +20153,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13438,9 +20153,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13438 | } }, | 20153 | } }, |
| 13439 | }, .{ | 20154 | }, .{ |
| 13440 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 20157 | .patterns = &.{ |
| 13443 | .{ .src = .{ .to_mem, .none } }, | 20158 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13444 | }, | 20159 | }, |
| 13445 | .extra_temps = .{ | 20160 | .extra_temps = .{ |
| 13446 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20161 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13470,9 +20185,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13470,9 +20185,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13470 | } }, | 20185 | } }, |
| 13471 | }, .{ | 20186 | }, .{ |
| 13472 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .patterns = &.{ | 20189 | .patterns = &.{ |
| 13475 | .{ .src = .{ .to_mem, .none } }, | 20190 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13476 | }, | 20191 | }, |
| 13477 | .extra_temps = .{ | 20192 | .extra_temps = .{ |
| 13478 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20193 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13503,9 +20218,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13503,9 +20218,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13503 | } }, | 20218 | } }, |
| 13504 | }, .{ | 20219 | }, .{ |
| 13505 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .patterns = &.{ | 20222 | .patterns = &.{ |
| 13508 | .{ .src = .{ .to_mem, .none } }, | 20223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13509 | }, | 20224 | }, |
| 13510 | .extra_temps = .{ | 20225 | .extra_temps = .{ |
| 13511 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20226 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13535,9 +20250,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13535,9 +20250,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13535 | } }, | 20250 | } }, |
| 13536 | }, .{ | 20251 | }, .{ |
| 13537 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 20254 | .patterns = &.{ |
| 13540 | .{ .src = .{ .to_mem, .none } }, | 20255 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13541 | }, | 20256 | }, |
| 13542 | .extra_temps = .{ | 20257 | .extra_temps = .{ |
| 13543 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 20258 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13567,9 +20282,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13567,9 +20282,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13567 | } }, | 20282 | } }, |
| 13568 | }, .{ | 20283 | }, .{ |
| 13569 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, | 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 | .patterns = &.{ | 20286 | .patterns = &.{ |
| 13572 | .{ .src = .{ .to_mem, .none } }, | 20287 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13573 | }, | 20288 | }, |
| 13574 | .extra_temps = .{ | 20289 | .extra_temps = .{ |
| 13575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20290 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13596,9 +20311,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13596,9 +20311,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13596 | } }, | 20311 | } }, |
| 13597 | }, .{ | 20312 | }, .{ |
| 13598 | .required_features = .{ .lzcnt, null, null, null }, | 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 | .patterns = &.{ | 20315 | .patterns = &.{ |
| 13601 | .{ .src = .{ .to_mem, .none } }, | 20316 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13602 | }, | 20317 | }, |
| 13603 | .extra_temps = .{ | 20318 | .extra_temps = .{ |
| 13604 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20319 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13625,9 +20340,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13625,9 +20340,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13625 | } }, | 20340 | } }, |
| 13626 | }, .{ | 20341 | }, .{ |
| 13627 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, | 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 | .patterns = &.{ | 20344 | .patterns = &.{ |
| 13630 | .{ .src = .{ .to_mem, .none } }, | 20345 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13631 | }, | 20346 | }, |
| 13632 | .extra_temps = .{ | 20347 | .extra_temps = .{ |
| 13633 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20348 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13654,9 +20369,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13654,9 +20369,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13654 | } }, | 20369 | } }, |
| 13655 | }, .{ | 20370 | }, .{ |
| 13656 | .required_features = .{ .lzcnt, null, null, null }, | 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 | .patterns = &.{ | 20373 | .patterns = &.{ |
| 13659 | .{ .src = .{ .to_mem, .none } }, | 20374 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13660 | }, | 20375 | }, |
| 13661 | .extra_temps = .{ | 20376 | .extra_temps = .{ |
| 13662 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20377 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13683,9 +20398,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13683,9 +20398,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13683 | } }, | 20398 | } }, |
| 13684 | }, .{ | 20399 | }, .{ |
| 13685 | .required_features = .{ .lzcnt, .slow_incdec, null, null }, | 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 | .patterns = &.{ | 20402 | .patterns = &.{ |
| 13688 | .{ .src = .{ .to_mem, .none } }, | 20403 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13689 | }, | 20404 | }, |
| 13690 | .extra_temps = .{ | 20405 | .extra_temps = .{ |
| 13691 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20406 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13712,9 +20427,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13712,9 +20427,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13712 | } }, | 20427 | } }, |
| 13713 | }, .{ | 20428 | }, .{ |
| 13714 | .required_features = .{ .lzcnt, null, null, null }, | 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 | .patterns = &.{ | 20431 | .patterns = &.{ |
| 13717 | .{ .src = .{ .to_mem, .none } }, | 20432 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13718 | }, | 20433 | }, |
| 13719 | .extra_temps = .{ | 20434 | .extra_temps = .{ |
| 13720 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13741,9 +20456,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13741,9 +20456,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13741 | } }, | 20456 | } }, |
| 13742 | }, .{ | 20457 | }, .{ |
| 13743 | .required_features = .{ .@"64bit", .lzcnt, .slow_incdec, null }, | 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 | .patterns = &.{ | 20460 | .patterns = &.{ |
| 13746 | .{ .src = .{ .to_mem, .none } }, | 20461 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13747 | }, | 20462 | }, |
| 13748 | .extra_temps = .{ | 20463 | .extra_temps = .{ |
| 13749 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20464 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13770,9 +20485,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13770,9 +20485,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13770 | } }, | 20485 | } }, |
| 13771 | }, .{ | 20486 | }, .{ |
| 13772 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .patterns = &.{ | 20489 | .patterns = &.{ |
| 13775 | .{ .src = .{ .to_mem, .none } }, | 20490 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13776 | }, | 20491 | }, |
| 13777 | .extra_temps = .{ | 20492 | .extra_temps = .{ |
| 13778 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20493 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13799,9 +20514,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13799,9 +20514,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13799 | } }, | 20514 | } }, |
| 13800 | }, .{ | 20515 | }, .{ |
| 13801 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, | 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 | .patterns = &.{ | 20518 | .patterns = &.{ |
| 13804 | .{ .src = .{ .to_mem, .none } }, | 20519 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13805 | }, | 20520 | }, |
| 13806 | .extra_temps = .{ | 20521 | .extra_temps = .{ |
| 13807 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20522 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13831,9 +20546,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13831,9 +20546,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13831 | } }, | 20546 | } }, |
| 13832 | }, .{ | 20547 | }, .{ |
| 13833 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 20550 | .patterns = &.{ |
| 13836 | .{ .src = .{ .to_mem, .none } }, | 20551 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13837 | }, | 20552 | }, |
| 13838 | .extra_temps = .{ | 20553 | .extra_temps = .{ |
| 13839 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20554 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13863,9 +20578,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13863,9 +20578,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13863 | } }, | 20578 | } }, |
| 13864 | }, .{ | 20579 | }, .{ |
| 13865 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, | 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 | .patterns = &.{ | 20582 | .patterns = &.{ |
| 13868 | .{ .src = .{ .to_mem, .none } }, | 20583 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13869 | }, | 20584 | }, |
| 13870 | .extra_temps = .{ | 20585 | .extra_temps = .{ |
| 13871 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20586 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13895,9 +20610,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13895,9 +20610,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13895 | } }, | 20610 | } }, |
| 13896 | }, .{ | 20611 | }, .{ |
| 13897 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 20614 | .patterns = &.{ |
| 13900 | .{ .src = .{ .to_mem, .none } }, | 20615 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13901 | }, | 20616 | }, |
| 13902 | .extra_temps = .{ | 20617 | .extra_temps = .{ |
| 13903 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20618 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13927,9 +20642,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13927,9 +20642,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13927 | } }, | 20642 | } }, |
| 13928 | }, .{ | 20643 | }, .{ |
| 13929 | .required_features = .{ .slow_incdec, null, null, null }, | 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 | .patterns = &.{ | 20646 | .patterns = &.{ |
| 13932 | .{ .src = .{ .to_mem, .none } }, | 20647 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13933 | }, | 20648 | }, |
| 13934 | .extra_temps = .{ | 20649 | .extra_temps = .{ |
| 13935 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20650 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13957,9 +20672,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13957,9 +20672,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13957 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 20676 | .patterns = &.{ |
| 13962 | .{ .src = .{ .to_mem, .none } }, | 20677 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13963 | }, | 20678 | }, |
| 13964 | .extra_temps = .{ | 20679 | .extra_temps = .{ |
| 13965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -13988,9 +20703,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13988,9 +20703,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13988 | } }, | 20703 | } }, |
| 13989 | }, .{ | 20704 | }, .{ |
| 13990 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, | 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 | .patterns = &.{ | 20707 | .patterns = &.{ |
| 13993 | .{ .src = .{ .to_mem, .none } }, | 20708 | .{ .src = .{ .to_mem, .none, .none } }, |
| 13994 | }, | 20709 | }, |
| 13995 | .extra_temps = .{ | 20710 | .extra_temps = .{ |
| 13996 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20711 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14020,9 +20735,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14020,9 +20735,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14020 | } }, | 20735 | } }, |
| 14021 | }, .{ | 20736 | }, .{ |
| 14022 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 20739 | .patterns = &.{ |
| 14025 | .{ .src = .{ .to_mem, .none } }, | 20740 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14026 | }, | 20741 | }, |
| 14027 | .extra_temps = .{ | 20742 | .extra_temps = .{ |
| 14028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20743 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14052,9 +20767,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14052,9 +20767,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14052 | } }, | 20767 | } }, |
| 14053 | }, .{ | 20768 | }, .{ |
| 14054 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, | 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 | .patterns = &.{ | 20771 | .patterns = &.{ |
| 14057 | .{ .src = .{ .to_mem, .none } }, | 20772 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14058 | }, | 20773 | }, |
| 14059 | .extra_temps = .{ | 20774 | .extra_temps = .{ |
| 14060 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20775 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14084,9 +20799,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14084,9 +20799,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14084 | } }, | 20799 | } }, |
| 14085 | }, .{ | 20800 | }, .{ |
| 14086 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 20803 | .patterns = &.{ |
| 14089 | .{ .src = .{ .to_mem, .none } }, | 20804 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14090 | }, | 20805 | }, |
| 14091 | .extra_temps = .{ | 20806 | .extra_temps = .{ |
| 14092 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20807 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14116,9 +20831,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14116,9 +20831,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14116 | } }, | 20831 | } }, |
| 14117 | }, .{ | 20832 | }, .{ |
| 14118 | .required_features = .{ .slow_incdec, null, null, null }, | 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 | .patterns = &.{ | 20835 | .patterns = &.{ |
| 14121 | .{ .src = .{ .to_mem, .none } }, | 20836 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14122 | }, | 20837 | }, |
| 14123 | .extra_temps = .{ | 20838 | .extra_temps = .{ |
| 14124 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20839 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14146,9 +20861,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14146,9 +20861,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14146 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 20865 | .patterns = &.{ |
| 14151 | .{ .src = .{ .to_mem, .none } }, | 20866 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14152 | }, | 20867 | }, |
| 14153 | .extra_temps = .{ | 20868 | .extra_temps = .{ |
| 14154 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14177,9 +20892,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14177,9 +20892,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14177 | } }, | 20892 | } }, |
| 14178 | }, .{ | 20893 | }, .{ |
| 14179 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec, null }, | 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 | .patterns = &.{ | 20896 | .patterns = &.{ |
| 14182 | .{ .src = .{ .to_mem, .none } }, | 20897 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14183 | }, | 20898 | }, |
| 14184 | .extra_temps = .{ | 20899 | .extra_temps = .{ |
| 14185 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20900 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14209,9 +20924,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14209,9 +20924,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14209 | } }, | 20924 | } }, |
| 14210 | }, .{ | 20925 | }, .{ |
| 14211 | .required_features = .{ .cmov, .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 20928 | .patterns = &.{ |
| 14214 | .{ .src = .{ .to_mem, .none } }, | 20929 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14215 | }, | 20930 | }, |
| 14216 | .extra_temps = .{ | 20931 | .extra_temps = .{ |
| 14217 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20932 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14241,9 +20956,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14241,9 +20956,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14241 | } }, | 20956 | } }, |
| 14242 | }, .{ | 20957 | }, .{ |
| 14243 | .required_features = .{ .bsf_bsr_0_clobbers_result, .slow_incdec, null, null }, | 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 | .patterns = &.{ | 20960 | .patterns = &.{ |
| 14246 | .{ .src = .{ .to_mem, .none } }, | 20961 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14247 | }, | 20962 | }, |
| 14248 | .extra_temps = .{ | 20963 | .extra_temps = .{ |
| 14249 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20964 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14273,9 +20988,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14273,9 +20988,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14273 | } }, | 20988 | } }, |
| 14274 | }, .{ | 20989 | }, .{ |
| 14275 | .required_features = .{ .bsf_bsr_0_clobbers_result, null, null, null }, | 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 | .patterns = &.{ | 20992 | .patterns = &.{ |
| 14278 | .{ .src = .{ .to_mem, .none } }, | 20993 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14279 | }, | 20994 | }, |
| 14280 | .extra_temps = .{ | 20995 | .extra_temps = .{ |
| 14281 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 20996 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14305,9 +21020,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14305,9 +21020,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14305 | } }, | 21020 | } }, |
| 14306 | }, .{ | 21021 | }, .{ |
| 14307 | .required_features = .{ .slow_incdec, null, null, null }, | 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 | .patterns = &.{ | 21024 | .patterns = &.{ |
| 14310 | .{ .src = .{ .to_mem, .none } }, | 21025 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14311 | }, | 21026 | }, |
| 14312 | .extra_temps = .{ | 21027 | .extra_temps = .{ |
| 14313 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14335,9 +21050,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14335,9 +21050,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14335 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 21054 | .patterns = &.{ |
| 14340 | .{ .src = .{ .to_mem, .none } }, | 21055 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14341 | }, | 21056 | }, |
| 14342 | .extra_temps = .{ | 21057 | .extra_temps = .{ |
| 14343 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21058 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14366,9 +21081,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14366,9 +21081,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14366 | } }, | 21081 | } }, |
| 14367 | }, .{ | 21082 | }, .{ |
| 14368 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, .slow_incdec }, | 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 | .patterns = &.{ | 21085 | .patterns = &.{ |
| 14371 | .{ .src = .{ .to_mem, .none } }, | 21086 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14372 | }, | 21087 | }, |
| 14373 | .extra_temps = .{ | 21088 | .extra_temps = .{ |
| 14374 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21089 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14398,9 +21113,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14398,9 +21113,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14398 | } }, | 21113 | } }, |
| 14399 | }, .{ | 21114 | }, .{ |
| 14400 | .required_features = .{ .@"64bit", .cmov, .bsf_bsr_0_clobbers_result, null }, | 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 | .patterns = &.{ | 21117 | .patterns = &.{ |
| 14403 | .{ .src = .{ .to_mem, .none } }, | 21118 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14404 | }, | 21119 | }, |
| 14405 | .extra_temps = .{ | 21120 | .extra_temps = .{ |
| 14406 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21121 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14430,9 +21145,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14430,9 +21145,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14430 | } }, | 21145 | } }, |
| 14431 | }, .{ | 21146 | }, .{ |
| 14432 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, .slow_incdec, null }, | 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 | .patterns = &.{ | 21149 | .patterns = &.{ |
| 14435 | .{ .src = .{ .to_mem, .none } }, | 21150 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14436 | }, | 21151 | }, |
| 14437 | .extra_temps = .{ | 21152 | .extra_temps = .{ |
| 14438 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21153 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14462,9 +21177,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14462,9 +21177,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14462 | } }, | 21177 | } }, |
| 14463 | }, .{ | 21178 | }, .{ |
| 14464 | .required_features = .{ .@"64bit", .bsf_bsr_0_clobbers_result, null, null }, | 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 | .patterns = &.{ | 21181 | .patterns = &.{ |
| 14467 | .{ .src = .{ .to_mem, .none } }, | 21182 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14468 | }, | 21183 | }, |
| 14469 | .extra_temps = .{ | 21184 | .extra_temps = .{ |
| 14470 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21185 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14494,9 +21209,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14494,9 +21209,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14494 | } }, | 21209 | } }, |
| 14495 | }, .{ | 21210 | }, .{ |
| 14496 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 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 | .patterns = &.{ | 21213 | .patterns = &.{ |
| 14499 | .{ .src = .{ .to_mem, .none } }, | 21214 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14500 | }, | 21215 | }, |
| 14501 | .extra_temps = .{ | 21216 | .extra_temps = .{ |
| 14502 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21217 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14525,9 +21240,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14525,9 +21240,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14525 | } }, | 21240 | } }, |
| 14526 | }, .{ | 21241 | }, .{ |
| 14527 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 21244 | .patterns = &.{ |
| 14530 | .{ .src = .{ .to_mem, .none } }, | 21245 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14531 | }, | 21246 | }, |
| 14532 | .extra_temps = .{ | 21247 | .extra_temps = .{ |
| 14533 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21248 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14556,10 +21271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14556,10 +21271,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14556 | } }, | 21271 | } }, |
| 14557 | }, .{ | 21272 | }, .{ |
| 14558 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, | 21275 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14561 | .patterns = &.{ | 21276 | .patterns = &.{ |
| 14562 | .{ .src = .{ .to_mem, .none } }, | 21277 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14563 | }, | 21278 | }, |
| 14564 | .extra_temps = .{ | 21279 | .extra_temps = .{ |
| 14565 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21280 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14596,10 +21311,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14596,10 +21311,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14596 | } }, | 21311 | } }, |
| 14597 | }, .{ | 21312 | }, .{ |
| 14598 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, | 21315 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14601 | .patterns = &.{ | 21316 | .patterns = &.{ |
| 14602 | .{ .src = .{ .to_mem, .none } }, | 21317 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14603 | }, | 21318 | }, |
| 14604 | .extra_temps = .{ | 21319 | .extra_temps = .{ |
| 14605 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21320 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14635,10 +21350,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14635,10 +21350,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14635 | } }, | 21350 | } }, |
| 14636 | }, .{ | 21351 | }, .{ |
| 14637 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, | 21354 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14640 | .patterns = &.{ | 21355 | .patterns = &.{ |
| 14641 | .{ .src = .{ .to_mem, .none } }, | 21356 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14642 | }, | 21357 | }, |
| 14643 | .extra_temps = .{ | 21358 | .extra_temps = .{ |
| 14644 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21359 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14674,10 +21389,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14674,10 +21389,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14674 | } }, | 21389 | } }, |
| 14675 | }, .{ | 21390 | }, .{ |
| 14676 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, | 21393 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14679 | .patterns = &.{ | 21394 | .patterns = &.{ |
| 14680 | .{ .src = .{ .to_mem, .none } }, | 21395 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14681 | }, | 21396 | }, |
| 14682 | .extra_temps = .{ | 21397 | .extra_temps = .{ |
| 14683 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21398 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14714,10 +21429,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14714,10 +21429,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14714 | } }, | 21429 | } }, |
| 14715 | }, .{ | 21430 | }, .{ |
| 14716 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, | 21433 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14719 | .patterns = &.{ | 21434 | .patterns = &.{ |
| 14720 | .{ .src = .{ .to_mem, .none } }, | 21435 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14721 | }, | 21436 | }, |
| 14722 | .extra_temps = .{ | 21437 | .extra_temps = .{ |
| 14723 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21438 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14753,10 +21468,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14753,10 +21468,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14753 | } }, | 21468 | } }, |
| 14754 | }, .{ | 21469 | }, .{ |
| 14755 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, | 21472 | .dst_constraints = .{.{ .scalar_int_is = .byte }}, |
| 14758 | .patterns = &.{ | 21473 | .patterns = &.{ |
| 14759 | .{ .src = .{ .to_mem, .none } }, | 21474 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14760 | }, | 21475 | }, |
| 14761 | .extra_temps = .{ | 21476 | .extra_temps = .{ |
| 14762 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21477 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14792,10 +21507,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14792,10 +21507,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14792 | } }, | 21507 | } }, |
| 14793 | }, .{ | 21508 | }, .{ |
| 14794 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .word }}, | 21511 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14797 | .patterns = &.{ | 21512 | .patterns = &.{ |
| 14798 | .{ .src = .{ .to_mem, .none } }, | 21513 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14799 | }, | 21514 | }, |
| 14800 | .extra_temps = .{ | 21515 | .extra_temps = .{ |
| 14801 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21516 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14832,10 +21547,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14832,10 +21547,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14832 | } }, | 21547 | } }, |
| 14833 | }, .{ | 21548 | }, .{ |
| 14834 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .word }}, | 21551 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14837 | .patterns = &.{ | 21552 | .patterns = &.{ |
| 14838 | .{ .src = .{ .to_mem, .none } }, | 21553 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14839 | }, | 21554 | }, |
| 14840 | .extra_temps = .{ | 21555 | .extra_temps = .{ |
| 14841 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14871,10 +21586,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14871,10 +21586,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14871 | } }, | 21586 | } }, |
| 14872 | }, .{ | 21587 | }, .{ |
| 14873 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .word }}, | 21590 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14876 | .patterns = &.{ | 21591 | .patterns = &.{ |
| 14877 | .{ .src = .{ .to_mem, .none } }, | 21592 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14878 | }, | 21593 | }, |
| 14879 | .extra_temps = .{ | 21594 | .extra_temps = .{ |
| 14880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21595 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14910,10 +21625,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14910,10 +21625,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14910 | } }, | 21625 | } }, |
| 14911 | }, .{ | 21626 | }, .{ |
| 14912 | .required_features = .{ .@"64bit", .false_deps_lzcnt_tzcnt, .lzcnt, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .word }}, | 21629 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14915 | .patterns = &.{ | 21630 | .patterns = &.{ |
| 14916 | .{ .src = .{ .to_mem, .none } }, | 21631 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14917 | }, | 21632 | }, |
| 14918 | .extra_temps = .{ | 21633 | .extra_temps = .{ |
| 14919 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21634 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14950,10 +21665,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14950,10 +21665,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14950 | } }, | 21665 | } }, |
| 14951 | }, .{ | 21666 | }, .{ |
| 14952 | .required_features = .{ .@"64bit", .lzcnt, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .word }}, | 21669 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14955 | .patterns = &.{ | 21670 | .patterns = &.{ |
| 14956 | .{ .src = .{ .to_mem, .none } }, | 21671 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14957 | }, | 21672 | }, |
| 14958 | .extra_temps = .{ | 21673 | .extra_temps = .{ |
| 14959 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21674 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -14989,10 +21704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14989,10 +21704,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14989 | } }, | 21704 | } }, |
| 14990 | }, .{ | 21705 | }, .{ |
| 14991 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int_is = .word }}, | 21708 | .dst_constraints = .{.{ .scalar_int_is = .word }}, |
| 14994 | .patterns = &.{ | 21709 | .patterns = &.{ |
| 14995 | .{ .src = .{ .to_mem, .none } }, | 21710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 14996 | }, | 21711 | }, |
| 14997 | .extra_temps = .{ | 21712 | .extra_temps = .{ |
| 14998 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 21713 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15005,50 +21720,2361 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15005,50 +21720,2361 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15005 | .unused, | 21720 | .unused, |
| 15006 | .unused, | 21721 | .unused, |
| 15007 | }, | 21722 | }, |
| 15008 | .dst_temps = .{.mem}, | 21723 | .dst_temps = .{.mem}, |
| 15009 | .clobbers = .{ .eflags = true }, | 21724 | .clobbers = .{ .eflags = true }, |
| 15010 | .each = .{ .once = &.{ | 21725 | .each = .{ .once = &.{ |
| 15011 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, | 21726 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_len), ._, ._ }, |
| 15012 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, | 21727 | .{ ._, ._, .lea, .tmp1q, .mem(.src0), ._, ._ }, |
| 15013 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, | 21728 | .{ .@"0:", ._, .mov, .tmp2d, .sia(-8, .none, .add_src0_elem_size), ._, ._ }, |
| 15014 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, | 21729 | .{ ._, ._, .mov, .tmp3q, .ua(.src0, .add_umax), ._, ._ }, |
| 15015 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ }, | 21730 | .{ .@"1:", ._, .@"and", .tmp3q, .leai(.tmp1q, .tmp2), ._, ._ }, |
| 15016 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, | 21731 | .{ ._, ._r, .bs, .tmp3q, .tmp3q, ._, ._ }, |
| 15017 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, | 21732 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 15018 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, | 21733 | .{ ._, ._, .mov, .tmp3q, .si(-1), ._, ._ }, |
| 15019 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, | 21734 | .{ ._, ._, .sub, .tmp2d, .si(8), ._, ._ }, |
| 15020 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, | 21735 | .{ ._, ._nc, .j, .@"1b", ._, ._, ._ }, |
| 15021 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 21736 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 15022 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, | 21737 | .{ .@"1:", ._, .lea, .tmp3d, .leasiad(.tmp3, .@"8", .tmp2, .sub_src0_bit_size, 1), ._, ._ }, |
| 15023 | .{ ._, ._, .neg, .tmp3d, ._, ._, ._ }, | 21738 | .{ ._, ._, .neg, .tmp3d, ._, ._, ._ }, |
| 15024 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, | 21739 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_2_len), .tmp3w, ._, ._ }, |
| 15025 | .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 21740 | .{ ._, ._, .lea, .tmp1q, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 15026 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 21741 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 15027 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 21742 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 15028 | } }, | 21743 | } }, |
| 15029 | } }) catch |err| switch (err) { | 21744 | } }) catch |err| switch (err) { |
| 15030 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ | 21745 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 15031 | @tagName(air_tag), | 21746 | @tagName(air_tag), |
| 15032 | cg.typeOf(ty_op.operand).fmt(pt), | 21747 | cg.typeOf(ty_op.operand).fmt(pt), |
| 15033 | ops[0].tracking(cg), | 21748 | ops[0].tracking(cg), |
| 15034 | }), | 21749 | }), |
| 15035 | else => |e| return e, | 21750 | else => |e| return e, |
| 15036 | }; | 21751 | }; |
| 15037 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 21752 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 15038 | }, | 21753 | }, |
| 15039 | | 21754 | |
| 15040 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { | 21755 | .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; | 21756 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 15042 | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; | 21757 | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; |
| 15043 | switch (extra.compareOperator()) { | 21758 | switch (extra.compareOperator()) { |
| 15044 | .eq, .neq => {}, | 21759 | .eq, .neq => {}, |
| 15045 | else => break :fallback try cg.airCmpVector(inst), | 21760 | .lt, .lte, .gte, .gt => if (cg.floatBits(cg.typeOf(extra.lhs).childType(zcu)) == null) |
| 15046 | } | 21761 | break :fallback try cg.airCmpVector(inst), |
| 15047 | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); | 21762 | } |
| 15048 | var res: [1]Temp = undefined; | 21763 | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); |
| 15049 | switch (extra.compareOperator()) { | 21764 | var res: [1]Temp = undefined; |
| 15050 | .lt => unreachable, | 21765 | (err: switch (extra.compareOperator()) { |
| 15051 | .lte => unreachable, | 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 | .eq, .neq => |cmp_op| cg.select(&res, &.{ty_pl.ty.toType()}, &ops, switch (@as(Condition, switch (cmp_op) { | 24078 | .eq, .neq => |cmp_op| cg.select(&res, &.{ty_pl.ty.toType()}, &ops, switch (@as(Condition, switch (cmp_op) { |
| 15053 | else => unreachable, | 24079 | else => unreachable, |
| 15054 | .eq => .e, | 24080 | .eq => .e, |
| ... | @@ -15057,11 +24083,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15057,11 +24083,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15057 | else => unreachable, | 24083 | else => unreachable, |
| 15058 | inline .e, .ne => |cc| comptime &.{ .{ | 24084 | inline .e, .ne => |cc| comptime &.{ .{ |
| 15059 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24087 | .patterns = &.{ |
| 15062 | .{ .src = .{ .to_ymm, .mem } }, | 24088 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 15063 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 24089 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 15064 | .{ .src = .{ .to_ymm, .to_ymm } }, | 24090 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15065 | }, | 24091 | }, |
| 15066 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24092 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15067 | .kind = .all, | 24093 | .kind = .all, |
| ... | @@ -15077,11 +24103,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15077,11 +24103,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15077 | } }, | 24103 | } }, |
| 15078 | }, .{ | 24104 | }, .{ |
| 15079 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24107 | .patterns = &.{ |
| 15082 | .{ .src = .{ .to_ymm, .mem } }, | 24108 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 15083 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 24109 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 15084 | .{ .src = .{ .to_ymm, .to_ymm } }, | 24110 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15085 | }, | 24111 | }, |
| 15086 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24112 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15087 | .kind = .all, | 24113 | .kind = .all, |
| ... | @@ -15097,11 +24123,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15097,11 +24123,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15097 | } }, | 24123 | } }, |
| 15098 | }, .{ | 24124 | }, .{ |
| 15099 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24127 | .patterns = &.{ |
| 15102 | .{ .src = .{ .to_ymm, .mem } }, | 24128 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 15103 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 24129 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 15104 | .{ .src = .{ .to_ymm, .to_ymm } }, | 24130 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15105 | }, | 24131 | }, |
| 15106 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24132 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15107 | .kind = .all, | 24133 | .kind = .all, |
| ... | @@ -15117,11 +24143,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15117,11 +24143,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15117 | } }, | 24143 | } }, |
| 15118 | }, .{ | 24144 | }, .{ |
| 15119 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24147 | .patterns = &.{ |
| 15122 | .{ .src = .{ .to_ymm, .mem } }, | 24148 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 15123 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 24149 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 15124 | .{ .src = .{ .to_ymm, .to_ymm } }, | 24150 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 15125 | }, | 24151 | }, |
| 15126 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24152 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15127 | .kind = .all, | 24153 | .kind = .all, |
| ... | @@ -15137,11 +24163,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15137,11 +24163,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15137 | } }, | 24163 | } }, |
| 15138 | }, .{ | 24164 | }, .{ |
| 15139 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24167 | .patterns = &.{ |
| 15142 | .{ .src = .{ .to_xmm, .mem } }, | 24168 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 15143 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, | 24169 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15144 | .{ .src = .{ .to_xmm, .to_xmm } }, | 24170 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15145 | }, | 24171 | }, |
| 15146 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24172 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15147 | .kind = .all, | 24173 | .kind = .all, |
| ... | @@ -15157,11 +24183,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15157,11 +24183,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15157 | } }, | 24183 | } }, |
| 15158 | }, .{ | 24184 | }, .{ |
| 15159 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24187 | .patterns = &.{ |
| 15162 | .{ .src = .{ .to_xmm, .mem } }, | 24188 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 15163 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, | 24189 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15164 | .{ .src = .{ .to_xmm, .to_xmm } }, | 24190 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15165 | }, | 24191 | }, |
| 15166 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24192 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15167 | .kind = .all, | 24193 | .kind = .all, |
| ... | @@ -15177,11 +24203,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15177,11 +24203,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15177 | } }, | 24203 | } }, |
| 15178 | }, .{ | 24204 | }, .{ |
| 15179 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24207 | .patterns = &.{ |
| 15182 | .{ .src = .{ .to_xmm, .mem } }, | 24208 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 15183 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, | 24209 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15184 | .{ .src = .{ .to_xmm, .to_xmm } }, | 24210 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15185 | }, | 24211 | }, |
| 15186 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24212 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15187 | .kind = .all, | 24213 | .kind = .all, |
| ... | @@ -15197,11 +24223,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15197,11 +24223,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15197 | } }, | 24223 | } }, |
| 15198 | }, .{ | 24224 | }, .{ |
| 15199 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24227 | .patterns = &.{ |
| 15202 | .{ .src = .{ .to_xmm, .mem } }, | 24228 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 15203 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, | 24229 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15204 | .{ .src = .{ .to_xmm, .to_xmm } }, | 24230 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 15205 | }, | 24231 | }, |
| 15206 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ | 24232 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 15207 | .kind = .all, | 24233 | .kind = .all, |
| ... | @@ -15217,11 +24243,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15217,11 +24243,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15217 | } }, | 24243 | } }, |
| 15218 | }, .{ | 24244 | }, .{ |
| 15219 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 24247 | .patterns = &.{ |
| 15222 | .{ .src = .{ .to_mut_xmm, .mem } }, | 24248 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 15223 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 24249 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15224 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 24250 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15225 | }, | 24251 | }, |
| 15226 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24252 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15227 | .kind = .all, | 24253 | .kind = .all, |
| ... | @@ -15237,11 +24263,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15237,11 +24263,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15237 | } }, | 24263 | } }, |
| 15238 | }, .{ | 24264 | }, .{ |
| 15239 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 24267 | .patterns = &.{ |
| 15242 | .{ .src = .{ .to_mut_xmm, .mem } }, | 24268 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 15243 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 24269 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15244 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 24270 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15245 | }, | 24271 | }, |
| 15246 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24272 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15247 | .kind = .all, | 24273 | .kind = .all, |
| ... | @@ -15257,11 +24283,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15257,11 +24283,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15257 | } }, | 24283 | } }, |
| 15258 | }, .{ | 24284 | }, .{ |
| 15259 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 24287 | .patterns = &.{ |
| 15262 | .{ .src = .{ .to_mut_xmm, .mem } }, | 24288 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 15263 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 24289 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15264 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 24290 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15265 | }, | 24291 | }, |
| 15266 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24292 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15267 | .kind = .all, | 24293 | .kind = .all, |
| ... | @@ -15277,11 +24303,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15277,11 +24303,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15277 | } }, | 24303 | } }, |
| 15278 | }, .{ | 24304 | }, .{ |
| 15279 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .patterns = &.{ | 24307 | .patterns = &.{ |
| 15282 | .{ .src = .{ .to_mut_xmm, .mem } }, | 24308 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 15283 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 24309 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 15284 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 24310 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 15285 | }, | 24311 | }, |
| 15286 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24312 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15287 | .kind = .all, | 24313 | .kind = .all, |
| ... | @@ -15297,11 +24323,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15297,11 +24323,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15297 | } }, | 24323 | } }, |
| 15298 | }, .{ | 24324 | }, .{ |
| 15299 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 24327 | .patterns = &.{ |
| 15302 | .{ .src = .{ .to_mut_mm, .mem } }, | 24328 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 15303 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, | 24329 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 15304 | .{ .src = .{ .to_mut_mm, .to_mm } }, | 24330 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 15305 | }, | 24331 | }, |
| 15306 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24332 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15307 | .kind = .all, | 24333 | .kind = .all, |
| ... | @@ -15317,11 +24343,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15317,11 +24343,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15317 | } }, | 24343 | } }, |
| 15318 | }, .{ | 24344 | }, .{ |
| 15319 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 24347 | .patterns = &.{ |
| 15322 | .{ .src = .{ .to_mut_mm, .mem } }, | 24348 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 15323 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, | 24349 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 15324 | .{ .src = .{ .to_mut_mm, .to_mm } }, | 24350 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 15325 | }, | 24351 | }, |
| 15326 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24352 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15327 | .kind = .all, | 24353 | .kind = .all, |
| ... | @@ -15337,11 +24363,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15337,11 +24363,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15337 | } }, | 24363 | } }, |
| 15338 | }, .{ | 24364 | }, .{ |
| 15339 | .required_features = .{ .mmx, null, null, null }, | 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 | .patterns = &.{ | 24367 | .patterns = &.{ |
| 15342 | .{ .src = .{ .to_mut_mm, .mem } }, | 24368 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 15343 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, | 24369 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 15344 | .{ .src = .{ .to_mut_mm, .to_mm } }, | 24370 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 15345 | }, | 24371 | }, |
| 15346 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ | 24372 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 15347 | .kind = .all, | 24373 | .kind = .all, |
| ... | @@ -15356,17 +24382,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15356,17 +24382,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15356 | .{ ._, .p_d, .cmpeq, .dst0q, .src1q, ._, ._ }, | 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 | .patterns = &.{ | 24386 | .patterns = &.{ |
| 15361 | .{ .src = .{ .mut_mem, .imm8 } }, | 24387 | .{ .src = .{ .mut_mem, .imm8, .none } }, |
| 15362 | .{ .src = .{ .imm8, .mut_mem }, .commute = .{ 0, 1 } }, | 24388 | .{ .src = .{ .imm8, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15363 | .{ .src = .{ .to_mut_gpr, .imm8 } }, | 24389 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 15364 | .{ .src = .{ .imm8, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24390 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15365 | .{ .src = .{ .mut_mem, .to_gpr } }, | 24391 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 15366 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 24392 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15367 | .{ .src = .{ .to_mut_gpr, .mem } }, | 24393 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 15368 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24394 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15369 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 24395 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15370 | }, | 24396 | }, |
| 15371 | .dst_temps = .{.{ .ref = .src0 }}, | 24397 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15372 | .clobbers = .{ .eflags = true }, | 24398 | .clobbers = .{ .eflags = true }, |
| ... | @@ -15381,17 +24407,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -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 | .patterns = &.{ | 24411 | .patterns = &.{ |
| 15386 | .{ .src = .{ .mut_mem, .imm16 } }, | 24412 | .{ .src = .{ .mut_mem, .imm16, .none } }, |
| 15387 | .{ .src = .{ .imm16, .mut_mem }, .commute = .{ 0, 1 } }, | 24413 | .{ .src = .{ .imm16, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15388 | .{ .src = .{ .to_mut_gpr, .imm16 } }, | 24414 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 15389 | .{ .src = .{ .imm16, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24415 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15390 | .{ .src = .{ .mut_mem, .to_gpr } }, | 24416 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 15391 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 24417 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15392 | .{ .src = .{ .to_mut_gpr, .mem } }, | 24418 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 15393 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24419 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15394 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 24420 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15395 | }, | 24421 | }, |
| 15396 | .dst_temps = .{.{ .ref = .src0 }}, | 24422 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15397 | .clobbers = .{ .eflags = true }, | 24423 | .clobbers = .{ .eflags = true }, |
| ... | @@ -15406,17 +24432,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -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 | .patterns = &.{ | 24436 | .patterns = &.{ |
| 15411 | .{ .src = .{ .mut_mem, .imm32 } }, | 24437 | .{ .src = .{ .mut_mem, .imm32, .none } }, |
| 15412 | .{ .src = .{ .imm32, .mut_mem }, .commute = .{ 0, 1 } }, | 24438 | .{ .src = .{ .imm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15413 | .{ .src = .{ .to_mut_gpr, .imm32 } }, | 24439 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 15414 | .{ .src = .{ .imm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24440 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15415 | .{ .src = .{ .mut_mem, .to_gpr } }, | 24441 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 15416 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 24442 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15417 | .{ .src = .{ .to_mut_gpr, .mem } }, | 24443 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 15418 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24444 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15419 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 24445 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15420 | }, | 24446 | }, |
| 15421 | .dst_temps = .{.{ .ref = .src0 }}, | 24447 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15422 | .clobbers = .{ .eflags = true }, | 24448 | .clobbers = .{ .eflags = true }, |
| ... | @@ -15432,17 +24458,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15432,17 +24458,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15432 | } }, | 24458 | } }, |
| 15433 | }, .{ | 24459 | }, .{ |
| 15434 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 24462 | .patterns = &.{ |
| 15437 | .{ .src = .{ .mut_mem, .simm32 } }, | 24463 | .{ .src = .{ .mut_mem, .simm32, .none } }, |
| 15438 | .{ .src = .{ .simm32, .mut_mem }, .commute = .{ 0, 1 } }, | 24464 | .{ .src = .{ .simm32, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15439 | .{ .src = .{ .to_mut_gpr, .simm32 } }, | 24465 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 15440 | .{ .src = .{ .simm32, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24466 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15441 | .{ .src = .{ .mut_mem, .to_gpr } }, | 24467 | .{ .src = .{ .mut_mem, .to_gpr, .none } }, |
| 15442 | .{ .src = .{ .to_gpr, .mut_mem }, .commute = .{ 0, 1 } }, | 24468 | .{ .src = .{ .to_gpr, .mut_mem, .none }, .commute = .{ 0, 1 } }, |
| 15443 | .{ .src = .{ .to_mut_gpr, .mem } }, | 24469 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 15444 | .{ .src = .{ .mem, .to_mut_gpr }, .commute = .{ 0, 1 } }, | 24470 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 15445 | .{ .src = .{ .to_mut_gpr, .to_gpr } }, | 24471 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 15446 | }, | 24472 | }, |
| 15447 | .dst_temps = .{.{ .ref = .src0 }}, | 24473 | .dst_temps = .{.{ .ref = .src0 }}, |
| 15448 | .clobbers = .{ .eflags = true }, | 24474 | .clobbers = .{ .eflags = true }, |
| ... | @@ -15457,9 +24483,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -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 | .patterns = &.{ | 24487 | .patterns = &.{ |
| 15462 | .{ .src = .{ .to_mem, .to_mem } }, | 24488 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15463 | }, | 24489 | }, |
| 15464 | .extra_temps = .{ | 24490 | .extra_temps = .{ |
| 15465 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24491 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15496,9 +24522,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15496,9 +24522,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15496 | } }, | 24522 | } }, |
| 15497 | }, .{ | 24523 | }, .{ |
| 15498 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24526 | .patterns = &.{ |
| 15501 | .{ .src = .{ .to_mem, .to_mem } }, | 24527 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15502 | }, | 24528 | }, |
| 15503 | .extra_temps = .{ | 24529 | .extra_temps = .{ |
| 15504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15541,9 +24567,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15541,9 +24567,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15541 | } }, | 24567 | } }, |
| 15542 | }, .{ | 24568 | }, .{ |
| 15543 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24571 | .patterns = &.{ |
| 15546 | .{ .src = .{ .to_mem, .to_mem } }, | 24572 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15547 | }, | 24573 | }, |
| 15548 | .extra_temps = .{ | 24574 | .extra_temps = .{ |
| 15549 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15588,9 +24614,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15588,9 +24614,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15588 | } }, | 24614 | } }, |
| 15589 | }, .{ | 24615 | }, .{ |
| 15590 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24618 | .patterns = &.{ |
| 15593 | .{ .src = .{ .to_mem, .to_mem } }, | 24619 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15594 | }, | 24620 | }, |
| 15595 | .extra_temps = .{ | 24621 | .extra_temps = .{ |
| 15596 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15633,9 +24659,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15633,9 +24659,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15633 | } }, | 24659 | } }, |
| 15634 | }, .{ | 24660 | }, .{ |
| 15635 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 24663 | .patterns = &.{ |
| 15638 | .{ .src = .{ .to_mem, .to_mem } }, | 24664 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15639 | }, | 24665 | }, |
| 15640 | .extra_temps = .{ | 24666 | .extra_temps = .{ |
| 15641 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24667 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15702,9 +24728,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15702,9 +24728,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15702 | } }, | 24728 | } }, |
| 15703 | }, .{ | 24729 | }, .{ |
| 15704 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24732 | .patterns = &.{ |
| 15707 | .{ .src = .{ .to_mem, .to_mem } }, | 24733 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15708 | }, | 24734 | }, |
| 15709 | .extra_temps = .{ | 24735 | .extra_temps = .{ |
| 15710 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15747,9 +24773,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15747,9 +24773,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15747 | } }, | 24773 | } }, |
| 15748 | }, .{ | 24774 | }, .{ |
| 15749 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24777 | .patterns = &.{ |
| 15752 | .{ .src = .{ .to_mem, .to_mem } }, | 24778 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15753 | }, | 24779 | }, |
| 15754 | .extra_temps = .{ | 24780 | .extra_temps = .{ |
| 15755 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24781 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15794,9 +24820,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15794,9 +24820,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15794 | } }, | 24820 | } }, |
| 15795 | }, .{ | 24821 | }, .{ |
| 15796 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24824 | .patterns = &.{ |
| 15799 | .{ .src = .{ .to_mem, .to_mem } }, | 24825 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15800 | }, | 24826 | }, |
| 15801 | .extra_temps = .{ | 24827 | .extra_temps = .{ |
| 15802 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24828 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15863,9 +24889,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15863,9 +24889,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15863 | } }, | 24889 | } }, |
| 15864 | }, .{ | 24890 | }, .{ |
| 15865 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 24893 | .patterns = &.{ |
| 15868 | .{ .src = .{ .to_mem, .to_mem } }, | 24894 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15869 | }, | 24895 | }, |
| 15870 | .extra_temps = .{ | 24896 | .extra_temps = .{ |
| 15871 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24897 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15932,9 +24958,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15932,9 +24958,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15932 | } }, | 24958 | } }, |
| 15933 | }, .{ | 24959 | }, .{ |
| 15934 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 24962 | .patterns = &.{ |
| 15937 | .{ .src = .{ .to_mem, .to_mem } }, | 24963 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15938 | }, | 24964 | }, |
| 15939 | .extra_temps = .{ | 24965 | .extra_temps = .{ |
| 15940 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 24966 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -15977,9 +25003,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -15977,9 +25003,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 15977 | } }, | 25003 | } }, |
| 15978 | }, .{ | 25004 | }, .{ |
| 15979 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 25007 | .patterns = &.{ |
| 15982 | .{ .src = .{ .to_mem, .to_mem } }, | 25008 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 15983 | }, | 25009 | }, |
| 15984 | .extra_temps = .{ | 25010 | .extra_temps = .{ |
| 15985 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25011 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16024,9 +25050,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16024,9 +25050,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16024 | } }, | 25050 | } }, |
| 16025 | }, .{ | 25051 | }, .{ |
| 16026 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 25054 | .patterns = &.{ |
| 16029 | .{ .src = .{ .to_mem, .to_mem } }, | 25055 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16030 | }, | 25056 | }, |
| 16031 | .extra_temps = .{ | 25057 | .extra_temps = .{ |
| 16032 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25058 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16093,9 +25119,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16093,9 +25119,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16093 | } }, | 25119 | } }, |
| 16094 | }, .{ | 25120 | }, .{ |
| 16095 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .patterns = &.{ | 25123 | .patterns = &.{ |
| 16098 | .{ .src = .{ .to_mem, .to_mem } }, | 25124 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16099 | }, | 25125 | }, |
| 16100 | .extra_temps = .{ | 25126 | .extra_temps = .{ |
| 16101 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25127 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16162,9 +25188,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16162,9 +25188,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16162 | } }, | 25188 | } }, |
| 16163 | }, .{ | 25189 | }, .{ |
| 16164 | .required_features = .{ .sse, .mmx, null, null }, | 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 | .patterns = &.{ | 25192 | .patterns = &.{ |
| 16167 | .{ .src = .{ .to_mem, .to_mem } }, | 25193 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16168 | }, | 25194 | }, |
| 16169 | .extra_temps = .{ | 25195 | .extra_temps = .{ |
| 16170 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25196 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16207,9 +25233,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16207,9 +25233,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16207 | } }, | 25233 | } }, |
| 16208 | }, .{ | 25234 | }, .{ |
| 16209 | .required_features = .{ .sse, .mmx, null, null }, | 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 | .patterns = &.{ | 25237 | .patterns = &.{ |
| 16212 | .{ .src = .{ .to_mem, .to_mem } }, | 25238 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16213 | }, | 25239 | }, |
| 16214 | .extra_temps = .{ | 25240 | .extra_temps = .{ |
| 16215 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25241 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16280,9 +25306,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16280,9 +25306,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16280 | } }, | 25306 | } }, |
| 16281 | }, .{ | 25307 | }, .{ |
| 16282 | .required_features = .{ .sse, .mmx, null, null }, | 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 | .patterns = &.{ | 25310 | .patterns = &.{ |
| 16285 | .{ .src = .{ .to_mem, .to_mem } }, | 25311 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16286 | }, | 25312 | }, |
| 16287 | .extra_temps = .{ | 25313 | .extra_temps = .{ |
| 16288 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25314 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16354,10 +25380,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -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 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 25384 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16359 | .patterns = &.{ | 25385 | .patterns = &.{ |
| 16360 | .{ .src = .{ .to_mem, .to_mem } }, | 25386 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16361 | }, | 25387 | }, |
| 16362 | .extra_temps = .{ | 25388 | .extra_temps = .{ |
| 16363 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25389 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16386,10 +25412,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16386,10 +25412,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16386 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 25416 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16391 | .patterns = &.{ | 25417 | .patterns = &.{ |
| 16392 | .{ .src = .{ .to_mem, .to_mem } }, | 25418 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16393 | }, | 25419 | }, |
| 16394 | .extra_temps = .{ | 25420 | .extra_temps = .{ |
| 16395 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25421 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16418,10 +25444,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16418,10 +25444,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16418 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 25448 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16423 | .patterns = &.{ | 25449 | .patterns = &.{ |
| 16424 | .{ .src = .{ .to_mem, .to_mem } }, | 25450 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16425 | }, | 25451 | }, |
| 16426 | .extra_temps = .{ | 25452 | .extra_temps = .{ |
| 16427 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25453 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16451,10 +25477,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16451,10 +25477,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16451 | } }, | 25477 | } }, |
| 16452 | }, .{ | 25478 | }, .{ |
| 16453 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 25481 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16456 | .patterns = &.{ | 25482 | .patterns = &.{ |
| 16457 | .{ .src = .{ .to_mem, .to_mem } }, | 25483 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16458 | }, | 25484 | }, |
| 16459 | .extra_temps = .{ | 25485 | .extra_temps = .{ |
| 16460 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25486 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16483,10 +25509,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16483,10 +25509,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16483 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .byte }}, | 25513 | .dst_constraints = .{.{ .bool_vec = .byte }}, |
| 16488 | .patterns = &.{ | 25514 | .patterns = &.{ |
| 16489 | .{ .src = .{ .to_mem, .to_mem } }, | 25515 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16490 | }, | 25516 | }, |
| 16491 | .extra_temps = .{ | 25517 | .extra_temps = .{ |
| 16492 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 25518 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16522,10 +25548,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16522,10 +25548,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16522 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 25552 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16527 | .patterns = &.{ | 25553 | .patterns = &.{ |
| 16528 | .{ .src = .{ .to_mem, .to_mem } }, | 25554 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16529 | }, | 25555 | }, |
| 16530 | .extra_temps = .{ | 25556 | .extra_temps = .{ |
| 16531 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25557 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16555,10 +25581,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16555,10 +25581,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16555 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 25585 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16560 | .patterns = &.{ | 25586 | .patterns = &.{ |
| 16561 | .{ .src = .{ .to_mem, .to_mem } }, | 25587 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16562 | }, | 25588 | }, |
| 16563 | .extra_temps = .{ | 25589 | .extra_temps = .{ |
| 16564 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25590 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16588,10 +25614,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16588,10 +25614,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16588 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 25618 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16593 | .patterns = &.{ | 25619 | .patterns = &.{ |
| 16594 | .{ .src = .{ .to_mem, .to_mem } }, | 25620 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16595 | }, | 25621 | }, |
| 16596 | .extra_temps = .{ | 25622 | .extra_temps = .{ |
| 16597 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25623 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16622,10 +25648,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16622,10 +25648,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16622 | } }, | 25648 | } }, |
| 16623 | }, .{ | 25649 | }, .{ |
| 16624 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 25652 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16627 | .patterns = &.{ | 25653 | .patterns = &.{ |
| 16628 | .{ .src = .{ .to_mem, .to_mem } }, | 25654 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16629 | }, | 25655 | }, |
| 16630 | .extra_temps = .{ | 25656 | .extra_temps = .{ |
| 16631 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25657 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16655,10 +25681,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16655,10 +25681,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16655 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 25685 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 16660 | .patterns = &.{ | 25686 | .patterns = &.{ |
| 16661 | .{ .src = .{ .to_mem, .to_mem } }, | 25687 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16662 | }, | 25688 | }, |
| 16663 | .extra_temps = .{ | 25689 | .extra_temps = .{ |
| 16664 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 25690 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16696,10 +25722,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16696,10 +25722,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16696 | } }, | 25722 | } }, |
| 16697 | }, .{ | 25723 | }, .{ |
| 16698 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 25726 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16701 | .patterns = &.{ | 25727 | .patterns = &.{ |
| 16702 | .{ .src = .{ .to_mem, .to_mem } }, | 25728 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16703 | }, | 25729 | }, |
| 16704 | .extra_temps = .{ | 25730 | .extra_temps = .{ |
| 16705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16730,10 +25756,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16730,10 +25756,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16730 | } }, | 25756 | } }, |
| 16731 | }, .{ | 25757 | }, .{ |
| 16732 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 25760 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16735 | .patterns = &.{ | 25761 | .patterns = &.{ |
| 16736 | .{ .src = .{ .to_mem, .to_mem } }, | 25762 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16737 | }, | 25763 | }, |
| 16738 | .extra_temps = .{ | 25764 | .extra_temps = .{ |
| 16739 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25765 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16763,10 +25789,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16763,10 +25789,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16763 | } }, | 25789 | } }, |
| 16764 | }, .{ | 25790 | }, .{ |
| 16765 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 25793 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16768 | .patterns = &.{ | 25794 | .patterns = &.{ |
| 16769 | .{ .src = .{ .to_mem, .to_mem } }, | 25795 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16770 | }, | 25796 | }, |
| 16771 | .extra_temps = .{ | 25797 | .extra_temps = .{ |
| 16772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25798 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16797,10 +25823,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16797,10 +25823,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16797 | } }, | 25823 | } }, |
| 16798 | }, .{ | 25824 | }, .{ |
| 16799 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 25827 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16802 | .patterns = &.{ | 25828 | .patterns = &.{ |
| 16803 | .{ .src = .{ .to_mem, .to_mem } }, | 25829 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16804 | }, | 25830 | }, |
| 16805 | .extra_temps = .{ | 25831 | .extra_temps = .{ |
| 16806 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25832 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16831,10 +25857,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16831,10 +25857,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16831 | } }, | 25857 | } }, |
| 16832 | }, .{ | 25858 | }, .{ |
| 16833 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .bool_vec = .qword }}, | 25861 | .dst_constraints = .{.{ .bool_vec = .qword }}, |
| 16836 | .patterns = &.{ | 25862 | .patterns = &.{ |
| 16837 | .{ .src = .{ .to_mem, .to_mem } }, | 25863 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16838 | }, | 25864 | }, |
| 16839 | .extra_temps = .{ | 25865 | .extra_temps = .{ |
| 16840 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 25866 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16871,9 +25897,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16871,9 +25897,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16871 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 25901 | .patterns = &.{ |
| 16876 | .{ .src = .{ .to_mem, .to_mem } }, | 25902 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 16877 | }, | 25903 | }, |
| 16878 | .extra_temps = .{ | 25904 | .extra_temps = .{ |
| 16879 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 25905 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -16917,9 +25943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16917,9 +25943,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16917 | .src_constraints = .{ | 25943 | .src_constraints = .{ |
| 16918 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 25944 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| 16919 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 25945 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 25946 | .any, |
| 16920 | }, | 25947 | }, |
| 16921 | .patterns = &.{ | 25948 | .patterns = &.{ |
| 16922 | .{ .src = .{ .to_sse, .to_sse } }, | 25949 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 16923 | }, | 25950 | }, |
| 16924 | .extra_temps = .{ | 25951 | .extra_temps = .{ |
| 16925 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, | 25952 | .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| ... | @@ -16940,7 +25967,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16940,7 +25967,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16940 | .each = .{ .once = &.{ | 25967 | .each = .{ .once = &.{ |
| 16941 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 25968 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 16942 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, | 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 | else => unreachable, | 25971 | else => unreachable, |
| 16945 | .e => .eq, | 25972 | .e => .eq, |
| 16946 | .ne => .neq, | 25973 | .ne => .neq, |
| ... | @@ -16951,12 +25978,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16951,12 +25978,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16951 | .src_constraints = .{ | 25978 | .src_constraints = .{ |
| 16952 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, | 25979 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| 16953 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, | 25980 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 25981 | .any, |
| 16954 | }, | 25982 | }, |
| 16955 | .patterns = &.{ | 25983 | .patterns = &.{ |
| 16956 | .{ .src = .{ .mem, .mem } }, | 25984 | .{ .src = .{ .mem, .mem, .none } }, |
| 16957 | .{ .src = .{ .sse, .mem } }, | 25985 | .{ .src = .{ .sse, .mem, .none } }, |
| 16958 | .{ .src = .{ .mem, .sse } }, | 25986 | .{ .src = .{ .mem, .sse, .none } }, |
| 16959 | .{ .src = .{ .to_sse, .to_sse } }, | 25987 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 16960 | }, | 25988 | }, |
| 16961 | .extra_temps = .{ | 25989 | .extra_temps = .{ |
| 16962 | .{ .kind = .{ .rc = .sse } }, | 25990 | .{ .kind = .{ .rc = .sse } }, |
| ... | @@ -16988,12 +26016,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16988,12 +26016,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16988 | .src_constraints = .{ | 26016 | .src_constraints = .{ |
| 16989 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, | 26017 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| 16990 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, | 26018 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 26019 | .any, |
| 16991 | }, | 26020 | }, |
| 16992 | .patterns = &.{ | 26021 | .patterns = &.{ |
| 16993 | .{ .src = .{ .mem, .mem } }, | 26022 | .{ .src = .{ .mem, .mem, .none } }, |
| 16994 | .{ .src = .{ .to_sse, .mem } }, | 26023 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 16995 | .{ .src = .{ .mem, .to_sse } }, | 26024 | .{ .src = .{ .mem, .to_sse, .none } }, |
| 16996 | .{ .src = .{ .to_sse, .to_sse } }, | 26025 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 16997 | }, | 26026 | }, |
| 16998 | .extra_temps = .{ | 26027 | .extra_temps = .{ |
| 16999 | .{ .kind = .{ .rc = .sse } }, | 26028 | .{ .kind = .{ .rc = .sse } }, |
| ... | @@ -17025,11 +26054,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17025,11 +26054,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17025 | .src_constraints = .{ | 26054 | .src_constraints = .{ |
| 17026 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 26055 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 17027 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 26056 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 26057 | .any, |
| 17028 | }, | 26058 | }, |
| 17029 | .patterns = &.{ | 26059 | .patterns = &.{ |
| 17030 | .{ .src = .{ .to_sse, .mem } }, | 26060 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 17031 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 26061 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 17032 | .{ .src = .{ .to_sse, .to_sse } }, | 26062 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17033 | }, | 26063 | }, |
| 17034 | .dst_temps = .{.{ .mut_rc_mask = .{ | 26064 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17035 | .ref = .src0, | 26065 | .ref = .src0, |
| ... | @@ -17037,7 +26067,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17037,7 +26067,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17037 | .info = .{ .kind = .all, .scalar = .dword }, | 26067 | .info = .{ .kind = .all, .scalar = .dword }, |
| 17038 | } }}, | 26068 | } }}, |
| 17039 | .each = .{ .once = &.{ | 26069 | .each = .{ .once = &.{ |
| 17040 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { | 26070 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { |
| 17041 | else => unreachable, | 26071 | else => unreachable, |
| 17042 | .e => .eq, | 26072 | .e => .eq, |
| 17043 | .ne => .neq, | 26073 | .ne => .neq, |
| ... | @@ -17048,18 +26078,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17048,18 +26078,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17048 | .src_constraints = .{ | 26078 | .src_constraints = .{ |
| 17049 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 26079 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 17050 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, | 26080 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 26081 | .any, |
| 17051 | }, | 26082 | }, |
| 17052 | .patterns = &.{ | 26083 | .patterns = &.{ |
| 17053 | .{ .src = .{ .to_mut_sse, .mem } }, | 26084 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 17054 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 26085 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 17055 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 26086 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17056 | }, | 26087 | }, |
| 17057 | .dst_temps = .{.{ .ref_mask = .{ | 26088 | .dst_temps = .{.{ .ref_mask = .{ |
| 17058 | .ref = .src0, | 26089 | .ref = .src0, |
| 17059 | .info = .{ .kind = .all, .scalar = .dword }, | 26090 | .info = .{ .kind = .all, .scalar = .dword }, |
| 17060 | } }}, | 26091 | } }}, |
| 17061 | .each = .{ .once = &.{ | 26092 | .each = .{ .once = &.{ |
| 17062 | .{ ._, ._ss, .cmp, .dst0x, .src1x, .vp(switch (cc) { | 26093 | .{ ._, ._ss, .cmp, .dst0x, .src1d, .sp(switch (cc) { |
| 17063 | else => unreachable, | 26094 | else => unreachable, |
| 17064 | .e => .eq, | 26095 | .e => .eq, |
| 17065 | .ne => .neq, | 26096 | .ne => .neq, |
| ... | @@ -17070,11 +26101,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17070,11 +26101,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17070 | .src_constraints = .{ | 26101 | .src_constraints = .{ |
| 17071 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 26102 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 17072 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 26103 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 26104 | .any, |
| 17073 | }, | 26105 | }, |
| 17074 | .patterns = &.{ | 26106 | .patterns = &.{ |
| 17075 | .{ .src = .{ .to_sse, .mem } }, | 26107 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 17076 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 26108 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 17077 | .{ .src = .{ .to_sse, .to_sse } }, | 26109 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17078 | }, | 26110 | }, |
| 17079 | .dst_temps = .{.{ .mut_rc_mask = .{ | 26111 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17080 | .ref = .src0, | 26112 | .ref = .src0, |
| ... | @@ -17093,18 +26125,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17093,18 +26125,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17093 | .src_constraints = .{ | 26125 | .src_constraints = .{ |
| 17094 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 26126 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 17095 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, | 26127 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 26128 | .any, |
| 17096 | }, | 26129 | }, |
| 17097 | .patterns = &.{ | 26130 | .patterns = &.{ |
| 17098 | .{ .src = .{ .to_mut_sse, .mem } }, | 26131 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 17099 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 26132 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 17100 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 26133 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17101 | }, | 26134 | }, |
| 17102 | .dst_temps = .{.{ .ref_mask = .{ | 26135 | .dst_temps = .{.{ .ref_mask = .{ |
| 17103 | .ref = .src0, | 26136 | .ref = .src0, |
| 17104 | .info = .{ .kind = .all, .scalar = .dword }, | 26137 | .info = .{ .kind = .all, .scalar = .dword }, |
| 17105 | } }}, | 26138 | } }}, |
| 17106 | .each = .{ .once = &.{ | 26139 | .each = .{ .once = &.{ |
| 17107 | .{ ._, ._ps, .cmp, .dst0x, .src1x, .vp(switch (cc) { | 26140 | .{ ._, ._ps, .cmp, .dst0x, .src1x, .sp(switch (cc) { |
| 17108 | else => unreachable, | 26141 | else => unreachable, |
| 17109 | .e => .eq, | 26142 | .e => .eq, |
| 17110 | .ne => .neq, | 26143 | .ne => .neq, |
| ... | @@ -17115,11 +26148,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17115,11 +26148,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17115 | .src_constraints = .{ | 26148 | .src_constraints = .{ |
| 17116 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, | 26149 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 17117 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, | 26150 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 26151 | .any, |
| 17118 | }, | 26152 | }, |
| 17119 | .patterns = &.{ | 26153 | .patterns = &.{ |
| 17120 | .{ .src = .{ .to_sse, .mem } }, | 26154 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 17121 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 26155 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 17122 | .{ .src = .{ .to_sse, .to_sse } }, | 26156 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17123 | }, | 26157 | }, |
| 17124 | .dst_temps = .{.{ .mut_rc_mask = .{ | 26158 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17125 | .ref = .src0, | 26159 | .ref = .src0, |
| ... | @@ -17138,11 +26172,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17138,11 +26172,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17138 | .src_constraints = .{ | 26172 | .src_constraints = .{ |
| 17139 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 26173 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 17140 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 26174 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 26175 | .any, |
| 17141 | }, | 26176 | }, |
| 17142 | .patterns = &.{ | 26177 | .patterns = &.{ |
| 17143 | .{ .src = .{ .to_sse, .mem } }, | 26178 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 17144 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 26179 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 17145 | .{ .src = .{ .to_sse, .to_sse } }, | 26180 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17146 | }, | 26181 | }, |
| 17147 | .dst_temps = .{.{ .mut_rc_mask = .{ | 26182 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17148 | .ref = .src0, | 26183 | .ref = .src0, |
| ... | @@ -17150,7 +26185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17150,7 +26185,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17150 | .info = .{ .kind = .all, .scalar = .qword }, | 26185 | .info = .{ .kind = .all, .scalar = .qword }, |
| 17151 | } }}, | 26186 | } }}, |
| 17152 | .each = .{ .once = &.{ | 26187 | .each = .{ .once = &.{ |
| 17153 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { | 26188 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { |
| 17154 | else => unreachable, | 26189 | else => unreachable, |
| 17155 | .e => .eq, | 26190 | .e => .eq, |
| 17156 | .ne => .neq, | 26191 | .ne => .neq, |
| ... | @@ -17161,18 +26196,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17161,18 +26196,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17161 | .src_constraints = .{ | 26196 | .src_constraints = .{ |
| 17162 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 26197 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 17163 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, | 26198 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 26199 | .any, |
| 17164 | }, | 26200 | }, |
| 17165 | .patterns = &.{ | 26201 | .patterns = &.{ |
| 17166 | .{ .src = .{ .to_mut_sse, .mem } }, | 26202 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 17167 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 26203 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 17168 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 26204 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17169 | }, | 26205 | }, |
| 17170 | .dst_temps = .{.{ .ref_mask = .{ | 26206 | .dst_temps = .{.{ .ref_mask = .{ |
| 17171 | .ref = .src0, | 26207 | .ref = .src0, |
| 17172 | .info = .{ .kind = .all, .scalar = .qword }, | 26208 | .info = .{ .kind = .all, .scalar = .qword }, |
| 17173 | } }}, | 26209 | } }}, |
| 17174 | .each = .{ .once = &.{ | 26210 | .each = .{ .once = &.{ |
| 17175 | .{ ._, ._sd, .cmp, .dst0x, .src1x, .vp(switch (cc) { | 26211 | .{ ._, ._sd, .cmp, .dst0x, .src1q, .sp(switch (cc) { |
| 17176 | else => unreachable, | 26212 | else => unreachable, |
| 17177 | .e => .eq, | 26213 | .e => .eq, |
| 17178 | .ne => .neq, | 26214 | .ne => .neq, |
| ... | @@ -17183,11 +26219,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17183,11 +26219,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17183 | .src_constraints = .{ | 26219 | .src_constraints = .{ |
| 17184 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 26220 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 17185 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 26221 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 26222 | .any, |
| 17186 | }, | 26223 | }, |
| 17187 | .patterns = &.{ | 26224 | .patterns = &.{ |
| 17188 | .{ .src = .{ .to_sse, .mem } }, | 26225 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 17189 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 26226 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 17190 | .{ .src = .{ .to_sse, .to_sse } }, | 26227 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17191 | }, | 26228 | }, |
| 17192 | .dst_temps = .{.{ .mut_rc_mask = .{ | 26229 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17193 | .ref = .src0, | 26230 | .ref = .src0, |
| ... | @@ -17206,18 +26243,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17206,18 +26243,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17206 | .src_constraints = .{ | 26243 | .src_constraints = .{ |
| 17207 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 26244 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 17208 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, | 26245 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 26246 | .any, |
| 17209 | }, | 26247 | }, |
| 17210 | .patterns = &.{ | 26248 | .patterns = &.{ |
| 17211 | .{ .src = .{ .to_mut_sse, .mem } }, | 26249 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 17212 | .{ .src = .{ .mem, .to_mut_sse }, .commute = .{ 0, 1 } }, | 26250 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 17213 | .{ .src = .{ .to_mut_sse, .to_sse } }, | 26251 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 17214 | }, | 26252 | }, |
| 17215 | .dst_temps = .{.{ .ref_mask = .{ | 26253 | .dst_temps = .{.{ .ref_mask = .{ |
| 17216 | .ref = .src0, | 26254 | .ref = .src0, |
| 17217 | .info = .{ .kind = .all, .scalar = .qword }, | 26255 | .info = .{ .kind = .all, .scalar = .qword }, |
| 17218 | } }}, | 26256 | } }}, |
| 17219 | .each = .{ .once = &.{ | 26257 | .each = .{ .once = &.{ |
| 17220 | .{ ._, ._pd, .cmp, .dst0x, .src1x, .vp(switch (cc) { | 26258 | .{ ._, ._pd, .cmp, .dst0x, .src1x, .sp(switch (cc) { |
| 17221 | else => unreachable, | 26259 | else => unreachable, |
| 17222 | .e => .eq, | 26260 | .e => .eq, |
| 17223 | .ne => .neq, | 26261 | .ne => .neq, |
| ... | @@ -17228,11 +26266,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17228,11 +26266,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17228 | .src_constraints = .{ | 26266 | .src_constraints = .{ |
| 17229 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, | 26267 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 17230 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, | 26268 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 26269 | .any, |
| 17231 | }, | 26270 | }, |
| 17232 | .patterns = &.{ | 26271 | .patterns = &.{ |
| 17233 | .{ .src = .{ .to_sse, .mem } }, | 26272 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 17234 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 26273 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 17235 | .{ .src = .{ .to_sse, .to_sse } }, | 26274 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 17236 | }, | 26275 | }, |
| 17237 | .dst_temps = .{.{ .mut_rc_mask = .{ | 26276 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 17238 | .ref = .src0, | 26277 | .ref = .src0, |
| ... | @@ -17251,15 +26290,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17251,15 +26290,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17251 | .src_constraints = .{ | 26290 | .src_constraints = .{ |
| 17252 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 26291 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 17253 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 26292 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| | 26293 | .any, |
| 17254 | }, | 26294 | }, |
| 17255 | .patterns = &.{ | 26295 | .patterns = &.{ |
| 17256 | .{ .src = .{ .to_mem, .to_mem } }, | 26296 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17257 | }, | 26297 | }, |
| 17258 | .extra_temps = .{ | 26298 | .extra_temps = .{ |
| 17259 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 26299 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 17260 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 26300 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 17261 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 26301 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 17262 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 26302 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 17263 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 26303 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 17264 | .unused, | 26304 | .unused, |
| 17265 | .unused, | 26305 | .unused, |
| ... | @@ -17289,15 +26329,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17289,15 +26329,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17289 | .src_constraints = .{ | 26329 | .src_constraints = .{ |
| 17290 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 26330 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| 17291 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, | 26331 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, |
| | 26332 | .any, |
| 17292 | }, | 26333 | }, |
| 17293 | .patterns = &.{ | 26334 | .patterns = &.{ |
| 17294 | .{ .src = .{ .to_mem, .to_mem } }, | 26335 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17295 | }, | 26336 | }, |
| 17296 | .extra_temps = .{ | 26337 | .extra_temps = .{ |
| 17297 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 26338 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 17298 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 26339 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 17299 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 26340 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 17300 | .{ .type = .vector_8_f16, .kind = .{ .rc = .sse } }, | 26341 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 17301 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 26342 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 17302 | .unused, | 26343 | .unused, |
| 17303 | .unused, | 26344 | .unused, |
| ... | @@ -17327,21 +26368,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17327,21 +26368,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17327 | .src_constraints = .{ | 26368 | .src_constraints = .{ |
| 17328 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26369 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17329 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26370 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26371 | .any, |
| 17330 | }, | 26372 | }, |
| 17331 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 26373 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17332 | .patterns = &.{ | 26374 | .patterns = &.{ |
| 17333 | .{ .src = .{ .to_mem, .to_mem } }, | 26375 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17334 | }, | 26376 | }, |
| 17335 | .call_frame = .{ .alignment = .@"16" }, | 26377 | .call_frame = .{ .alignment = .@"16" }, |
| 17336 | .extra_temps = .{ | 26378 | .extra_temps = .{ |
| 17337 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 26379 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17338 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26380 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17339 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26381 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17340 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26382 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17341 | else => unreachable, | | |
| 17342 | .e => "__eqhf2", | | |
| 17343 | .ne => "__nehf2", | | |
| 17344 | } } } }, | | |
| 17345 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26383 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17346 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26384 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17347 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 26385 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -17372,21 +26410,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17372,21 +26410,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17372 | .src_constraints = .{ | 26410 | .src_constraints = .{ |
| 17373 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26411 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17374 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26412 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26413 | .any, |
| 17375 | }, | 26414 | }, |
| 17376 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 26415 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17377 | .patterns = &.{ | 26416 | .patterns = &.{ |
| 17378 | .{ .src = .{ .to_mem, .to_mem } }, | 26417 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17379 | }, | 26418 | }, |
| 17380 | .call_frame = .{ .alignment = .@"16" }, | 26419 | .call_frame = .{ .alignment = .@"16" }, |
| 17381 | .extra_temps = .{ | 26420 | .extra_temps = .{ |
| 17382 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 26421 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17383 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26422 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17384 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26423 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17385 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26424 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17386 | else => unreachable, | | |
| 17387 | .e => "__eqhf2", | | |
| 17388 | .ne => "__nehf2", | | |
| 17389 | } } } }, | | |
| 17390 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26425 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17391 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26426 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17392 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 26427 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -17417,21 +26452,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17417,21 +26452,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17417 | .src_constraints = .{ | 26452 | .src_constraints = .{ |
| 17418 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26453 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17419 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26454 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26455 | .any, |
| 17420 | }, | 26456 | }, |
| 17421 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 26457 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17422 | .patterns = &.{ | 26458 | .patterns = &.{ |
| 17423 | .{ .src = .{ .to_mem, .to_mem } }, | 26459 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17424 | }, | 26460 | }, |
| 17425 | .call_frame = .{ .alignment = .@"16" }, | 26461 | .call_frame = .{ .alignment = .@"16" }, |
| 17426 | .extra_temps = .{ | 26462 | .extra_temps = .{ |
| 17427 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 26463 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17428 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26464 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17429 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26465 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17430 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26466 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17431 | else => unreachable, | | |
| 17432 | .e => "__eqhf2", | | |
| 17433 | .ne => "__nehf2", | | |
| 17434 | } } } }, | | |
| 17435 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26467 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17436 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26468 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17437 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 26469 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -17463,21 +26495,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17463,21 +26495,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17463 | .src_constraints = .{ | 26495 | .src_constraints = .{ |
| 17464 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26496 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17465 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26497 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26498 | .any, |
| 17466 | }, | 26499 | }, |
| 17467 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 26500 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17468 | .patterns = &.{ | 26501 | .patterns = &.{ |
| 17469 | .{ .src = .{ .to_mem, .to_mem } }, | 26502 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17470 | }, | 26503 | }, |
| 17471 | .call_frame = .{ .alignment = .@"16" }, | 26504 | .call_frame = .{ .alignment = .@"16" }, |
| 17472 | .extra_temps = .{ | 26505 | .extra_temps = .{ |
| 17473 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 26506 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17474 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26507 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17475 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26508 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17476 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26509 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17477 | else => unreachable, | | |
| 17478 | .e => "__eqhf2", | | |
| 17479 | .ne => "__nehf2", | | |
| 17480 | } } } }, | | |
| 17481 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26510 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17482 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26511 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17483 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 26512 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -17509,21 +26538,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17509,21 +26538,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17509 | .src_constraints = .{ | 26538 | .src_constraints = .{ |
| 17510 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26539 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17511 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26540 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26541 | .any, |
| 17512 | }, | 26542 | }, |
| 17513 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 26543 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17514 | .patterns = &.{ | 26544 | .patterns = &.{ |
| 17515 | .{ .src = .{ .to_mem, .to_mem } }, | 26545 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17516 | }, | 26546 | }, |
| 17517 | .call_frame = .{ .alignment = .@"16" }, | 26547 | .call_frame = .{ .alignment = .@"16" }, |
| 17518 | .extra_temps = .{ | 26548 | .extra_temps = .{ |
| 17519 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 26549 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17520 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26550 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17521 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26551 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17522 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26552 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17523 | else => unreachable, | | |
| 17524 | .e => "__eqhf2", | | |
| 17525 | .ne => "__nehf2", | | |
| 17526 | } } } }, | | |
| 17527 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26553 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17528 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26554 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17529 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 26555 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -17557,21 +26583,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17557,21 +26583,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17557 | .src_constraints = .{ | 26583 | .src_constraints = .{ |
| 17558 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26584 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17559 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26585 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26586 | .any, |
| 17560 | }, | 26587 | }, |
| 17561 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 26588 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 17562 | .patterns = &.{ | 26589 | .patterns = &.{ |
| 17563 | .{ .src = .{ .to_mem, .to_mem } }, | 26590 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17564 | }, | 26591 | }, |
| 17565 | .call_frame = .{ .alignment = .@"16" }, | 26592 | .call_frame = .{ .alignment = .@"16" }, |
| 17566 | .extra_temps = .{ | 26593 | .extra_temps = .{ |
| 17567 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 26594 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 17568 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26595 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17569 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26596 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17570 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26597 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17571 | else => unreachable, | | |
| 17572 | .e => "__eqhf2", | | |
| 17573 | .ne => "__nehf2", | | |
| 17574 | } } } }, | | |
| 17575 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26598 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17576 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26599 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17577 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 26600 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -17605,9 +26628,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17605,9 +26628,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17605 | .src_constraints = .{ | 26628 | .src_constraints = .{ |
| 17606 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26629 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17607 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26630 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26631 | .any, |
| 17608 | }, | 26632 | }, |
| 17609 | .patterns = &.{ | 26633 | .patterns = &.{ |
| 17610 | .{ .src = .{ .to_mem, .to_mem } }, | 26634 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17611 | }, | 26635 | }, |
| 17612 | .call_frame = .{ .alignment = .@"16" }, | 26636 | .call_frame = .{ .alignment = .@"16" }, |
| 17613 | .extra_temps = .{ | 26637 | .extra_temps = .{ |
| ... | @@ -17615,11 +26639,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17615,11 +26639,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17615 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 26639 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17616 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26640 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17617 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26641 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17618 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26642 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17619 | else => unreachable, | | |
| 17620 | .e => "__eqhf2", | | |
| 17621 | .ne => "__nehf2", | | |
| 17622 | } } } }, | | |
| 17623 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26643 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17624 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26644 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17625 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 26645 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -17659,9 +26679,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17659,9 +26679,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17659 | .src_constraints = .{ | 26679 | .src_constraints = .{ |
| 17660 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26680 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17661 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26681 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26682 | .any, |
| 17662 | }, | 26683 | }, |
| 17663 | .patterns = &.{ | 26684 | .patterns = &.{ |
| 17664 | .{ .src = .{ .to_mem, .to_mem } }, | 26685 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17665 | }, | 26686 | }, |
| 17666 | .call_frame = .{ .alignment = .@"16" }, | 26687 | .call_frame = .{ .alignment = .@"16" }, |
| 17667 | .extra_temps = .{ | 26688 | .extra_temps = .{ |
| ... | @@ -17669,11 +26690,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17669,11 +26690,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17669 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 26690 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17670 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26691 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17671 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26692 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17672 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26693 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17673 | else => unreachable, | | |
| 17674 | .e => "__eqhf2", | | |
| 17675 | .ne => "__nehf2", | | |
| 17676 | } } } }, | | |
| 17677 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26694 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17678 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26695 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17679 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 26696 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -17713,9 +26730,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17713,9 +26730,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17713 | .src_constraints = .{ | 26730 | .src_constraints = .{ |
| 17714 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26731 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17715 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26732 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26733 | .any, |
| 17716 | }, | 26734 | }, |
| 17717 | .patterns = &.{ | 26735 | .patterns = &.{ |
| 17718 | .{ .src = .{ .to_mem, .to_mem } }, | 26736 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17719 | }, | 26737 | }, |
| 17720 | .call_frame = .{ .alignment = .@"16" }, | 26738 | .call_frame = .{ .alignment = .@"16" }, |
| 17721 | .extra_temps = .{ | 26739 | .extra_temps = .{ |
| ... | @@ -17723,11 +26741,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17723,11 +26741,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17723 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 26741 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17724 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26742 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17725 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26743 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17726 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26744 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17727 | else => unreachable, | | |
| 17728 | .e => "__eqhf2", | | |
| 17729 | .ne => "__nehf2", | | |
| 17730 | } } } }, | | |
| 17731 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26745 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17732 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26746 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17733 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 26747 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -17768,9 +26782,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17768,9 +26782,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17768 | .src_constraints = .{ | 26782 | .src_constraints = .{ |
| 17769 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26783 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17770 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26784 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26785 | .any, |
| 17771 | }, | 26786 | }, |
| 17772 | .patterns = &.{ | 26787 | .patterns = &.{ |
| 17773 | .{ .src = .{ .to_mem, .to_mem } }, | 26788 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17774 | }, | 26789 | }, |
| 17775 | .call_frame = .{ .alignment = .@"16" }, | 26790 | .call_frame = .{ .alignment = .@"16" }, |
| 17776 | .extra_temps = .{ | 26791 | .extra_temps = .{ |
| ... | @@ -17778,11 +26793,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17778,11 +26793,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17778 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 26793 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17779 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26794 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17780 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26795 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17781 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26796 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17782 | else => unreachable, | | |
| 17783 | .e => "__eqhf2", | | |
| 17784 | .ne => "__nehf2", | | |
| 17785 | } } } }, | | |
| 17786 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26797 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17787 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26798 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17788 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 26799 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -17823,9 +26834,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17823,9 +26834,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17823 | .src_constraints = .{ | 26834 | .src_constraints = .{ |
| 17824 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26835 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17825 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26836 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26837 | .any, |
| 17826 | }, | 26838 | }, |
| 17827 | .patterns = &.{ | 26839 | .patterns = &.{ |
| 17828 | .{ .src = .{ .to_mem, .to_mem } }, | 26840 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17829 | }, | 26841 | }, |
| 17830 | .call_frame = .{ .alignment = .@"16" }, | 26842 | .call_frame = .{ .alignment = .@"16" }, |
| 17831 | .extra_temps = .{ | 26843 | .extra_temps = .{ |
| ... | @@ -17833,11 +26845,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17833,11 +26845,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17833 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 26845 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17834 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26846 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17835 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26847 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17836 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26848 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17837 | else => unreachable, | | |
| 17838 | .e => "__eqhf2", | | |
| 17839 | .ne => "__nehf2", | | |
| 17840 | } } } }, | | |
| 17841 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26849 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17842 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26850 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17843 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 26851 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -17880,9 +26888,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17880,9 +26888,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17880 | .src_constraints = .{ | 26888 | .src_constraints = .{ |
| 17881 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26889 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| 17882 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, | 26890 | .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, |
| | 26891 | .any, |
| 17883 | }, | 26892 | }, |
| 17884 | .patterns = &.{ | 26893 | .patterns = &.{ |
| 17885 | .{ .src = .{ .to_mem, .to_mem } }, | 26894 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17886 | }, | 26895 | }, |
| 17887 | .call_frame = .{ .alignment = .@"16" }, | 26896 | .call_frame = .{ .alignment = .@"16" }, |
| 17888 | .extra_temps = .{ | 26897 | .extra_temps = .{ |
| ... | @@ -17890,11 +26899,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17890,11 +26899,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17890 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 26899 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 17891 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 26900 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 17892 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, | 26901 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 17893 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 26902 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmphf2" } } }, |
| 17894 | else => unreachable, | | |
| 17895 | .e => "__eqhf2", | | |
| 17896 | .ne => "__nehf2", | | |
| 17897 | } } } }, | | |
| 17898 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 26903 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 17899 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 26904 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 17900 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 26905 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -17937,9 +26942,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17937,9 +26942,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17937 | .src_constraints = .{ | 26942 | .src_constraints = .{ |
| 17938 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 26943 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 17939 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 26944 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 26945 | .any, |
| 17940 | }, | 26946 | }, |
| 17941 | .patterns = &.{ | 26947 | .patterns = &.{ |
| 17942 | .{ .src = .{ .to_mem, .to_mem } }, | 26948 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17943 | }, | 26949 | }, |
| 17944 | .extra_temps = .{ | 26950 | .extra_temps = .{ |
| 17945 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 26951 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -17974,9 +26980,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -17974,9 +26980,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 17974 | .src_constraints = .{ | 26980 | .src_constraints = .{ |
| 17975 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 26981 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 17976 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 26982 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 26983 | .any, |
| 17977 | }, | 26984 | }, |
| 17978 | .patterns = &.{ | 26985 | .patterns = &.{ |
| 17979 | .{ .src = .{ .to_mem, .to_mem } }, | 26986 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 17980 | }, | 26987 | }, |
| 17981 | .extra_temps = .{ | 26988 | .extra_temps = .{ |
| 17982 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 26989 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18011,9 +27018,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18011,9 +27018,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18011 | .src_constraints = .{ | 27018 | .src_constraints = .{ |
| 18012 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 27019 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 18013 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 27020 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 27021 | .any, |
| 18014 | }, | 27022 | }, |
| 18015 | .patterns = &.{ | 27023 | .patterns = &.{ |
| 18016 | .{ .src = .{ .to_mem, .to_mem } }, | 27024 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18017 | }, | 27025 | }, |
| 18018 | .extra_temps = .{ | 27026 | .extra_temps = .{ |
| 18019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27027 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18033,12 +27041,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18033,12 +27041,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18033 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 27041 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 18034 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 27042 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 18035 | .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, | 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 | else => unreachable, | 27045 | else => unreachable, |
| 18038 | .e => .eq, | 27046 | .e => .eq, |
| 18039 | .ne => .neq, | 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 | else => unreachable, | 27050 | else => unreachable, |
| 18043 | .e => .eq, | 27051 | .e => .eq, |
| 18044 | .ne => .neq, | 27052 | .ne => .neq, |
| ... | @@ -18056,9 +27064,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18056,9 +27064,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18056 | .src_constraints = .{ | 27064 | .src_constraints = .{ |
| 18057 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 27065 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| 18058 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, | 27066 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 27067 | .any, |
| 18059 | }, | 27068 | }, |
| 18060 | .patterns = &.{ | 27069 | .patterns = &.{ |
| 18061 | .{ .src = .{ .to_mem, .to_mem } }, | 27070 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18062 | }, | 27071 | }, |
| 18063 | .extra_temps = .{ | 27072 | .extra_temps = .{ |
| 18064 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18077,14 +27086,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18077,14 +27086,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18077 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 27086 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 18078 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 27087 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 18079 | .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 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 | else => unreachable, | 27090 | else => unreachable, |
| 18082 | .e => .eq, | 27091 | .e => .eq, |
| 18083 | .ne => .neq, | 27092 | .ne => .neq, |
| 18084 | }), ._ }, | 27093 | }), ._ }, |
| 18085 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, | 27094 | .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, |
| 18086 | .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, | 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 | else => unreachable, | 27097 | else => unreachable, |
| 18089 | .e => .eq, | 27098 | .e => .eq, |
| 18090 | .ne => .neq, | 27099 | .ne => .neq, |
| ... | @@ -18102,9 +27111,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18102,9 +27111,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18102 | .src_constraints = .{ | 27111 | .src_constraints = .{ |
| 18103 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 27112 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| 18104 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, | 27113 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, |
| | 27114 | .any, |
| 18105 | }, | 27115 | }, |
| 18106 | .patterns = &.{ | 27116 | .patterns = &.{ |
| 18107 | .{ .src = .{ .to_mem, .to_mem } }, | 27117 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18108 | }, | 27118 | }, |
| 18109 | .extra_temps = .{ | 27119 | .extra_temps = .{ |
| 18110 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27120 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18124,7 +27134,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18124,7 +27134,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18124 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 27134 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 18125 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, | 27135 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, |
| 18126 | .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ }, | 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 | else => unreachable, | 27138 | else => unreachable, |
| 18129 | .e => .eq, | 27139 | .e => .eq, |
| 18130 | .ne => .neq, | 27140 | .ne => .neq, |
| ... | @@ -18135,7 +27145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18135,7 +27145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18135 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, | 27145 | .{ ._, ._, .mov, .lea(.tmp1b), .tmp3b, ._, ._ }, |
| 18136 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, | 27146 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 1), ._, ._ }, |
| 18137 | .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 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 | else => unreachable, | 27149 | else => unreachable, |
| 18140 | .e => .eq, | 27150 | .e => .eq, |
| 18141 | .ne => .neq, | 27151 | .ne => .neq, |
| ... | @@ -18150,9 +27160,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18150,9 +27160,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18150 | .src_constraints = .{ | 27160 | .src_constraints = .{ |
| 18151 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, | 27161 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 18152 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, | 27162 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| | 27163 | .any, |
| 18153 | }, | 27164 | }, |
| 18154 | .patterns = &.{ | 27165 | .patterns = &.{ |
| 18155 | .{ .src = .{ .to_mem, .to_mem } }, | 27166 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18156 | }, | 27167 | }, |
| 18157 | .extra_temps = .{ | 27168 | .extra_temps = .{ |
| 18158 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27169 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18196,9 +27207,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18196,9 +27207,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18196 | .src_constraints = .{ | 27207 | .src_constraints = .{ |
| 18197 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, | 27208 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| 18198 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, | 27209 | .{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }, |
| | 27210 | .any, |
| 18199 | }, | 27211 | }, |
| 18200 | .patterns = &.{ | 27212 | .patterns = &.{ |
| 18201 | .{ .src = .{ .to_mem, .to_mem } }, | 27213 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18202 | }, | 27214 | }, |
| 18203 | .extra_temps = .{ | 27215 | .extra_temps = .{ |
| 18204 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27216 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18242,9 +27254,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18242,9 +27254,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18242 | .src_constraints = .{ | 27254 | .src_constraints = .{ |
| 18243 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, | 27255 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| 18244 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, | 27256 | .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, |
| | 27257 | .any, |
| 18245 | }, | 27258 | }, |
| 18246 | .patterns = &.{ | 27259 | .patterns = &.{ |
| 18247 | .{ .src = .{ .to_mem, .to_mem } }, | 27260 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18248 | }, | 27261 | }, |
| 18249 | .extra_temps = .{ | 27262 | .extra_temps = .{ |
| 18250 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27263 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18291,9 +27304,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18291,9 +27304,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18291 | .src_constraints = .{ | 27304 | .src_constraints = .{ |
| 18292 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, | 27305 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| 18293 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, | 27306 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 27307 | .any, |
| 18294 | }, | 27308 | }, |
| 18295 | .patterns = &.{ | 27309 | .patterns = &.{ |
| 18296 | .{ .src = .{ .to_mem, .to_mem } }, | 27310 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18297 | }, | 27311 | }, |
| 18298 | .extra_temps = .{ | 27312 | .extra_temps = .{ |
| 18299 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27313 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18313,7 +27327,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18313,7 +27327,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18313 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 27327 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 18314 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 27328 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 18315 | .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, | 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 | else => unreachable, | 27331 | else => unreachable, |
| 18318 | .e => .eq, | 27332 | .e => .eq, |
| 18319 | .ne => .neq, | 27333 | .ne => .neq, |
| ... | @@ -18340,9 +27354,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18340,9 +27354,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18340 | .src_constraints = .{ | 27354 | .src_constraints = .{ |
| 18341 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 27355 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 18342 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 27356 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 27357 | .any, |
| 18343 | }, | 27358 | }, |
| 18344 | .patterns = &.{ | 27359 | .patterns = &.{ |
| 18345 | .{ .src = .{ .to_mem, .to_mem } }, | 27360 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18346 | }, | 27361 | }, |
| 18347 | .extra_temps = .{ | 27362 | .extra_temps = .{ |
| 18348 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27363 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18350,8 +27365,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18350,8 +27365,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18350 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27365 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18351 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 27366 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18352 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 27367 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18353 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 27368 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 18354 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 27369 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 18355 | .unused, | 27370 | .unused, |
| 18356 | .unused, | 27371 | .unused, |
| 18357 | }, | 27372 | }, |
| ... | @@ -18399,9 +27414,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18399,9 +27414,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18399 | .src_constraints = .{ | 27414 | .src_constraints = .{ |
| 18400 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 27415 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 18401 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 27416 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 27417 | .any, |
| 18402 | }, | 27418 | }, |
| 18403 | .patterns = &.{ | 27419 | .patterns = &.{ |
| 18404 | .{ .src = .{ .to_mem, .to_mem } }, | 27420 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18405 | }, | 27421 | }, |
| 18406 | .extra_temps = .{ | 27422 | .extra_temps = .{ |
| 18407 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18409,8 +27425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18409,8 +27425,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18409 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27425 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18410 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 27426 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18411 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 27427 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18412 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 27428 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 18413 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 27429 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 18414 | .unused, | 27430 | .unused, |
| 18415 | .unused, | 27431 | .unused, |
| 18416 | }, | 27432 | }, |
| ... | @@ -18458,17 +27474,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18458,17 +27474,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18458 | .src_constraints = .{ | 27474 | .src_constraints = .{ |
| 18459 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 27475 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| 18460 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, | 27476 | .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 27477 | .any, |
| 18461 | }, | 27478 | }, |
| 18462 | .patterns = &.{ | 27479 | .patterns = &.{ |
| 18463 | .{ .src = .{ .to_mem, .to_mem } }, | 27480 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18464 | }, | 27481 | }, |
| 18465 | .extra_temps = .{ | 27482 | .extra_temps = .{ |
| 18466 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27483 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 18467 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, | 27484 | .{ .type = .u32, .kind = .{ .reg = .rcx } }, |
| 18468 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27485 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18469 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 27486 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 18470 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 27487 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 18471 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 27488 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 18472 | .{ .type = .u8, .kind = .{ .reg = .ah } }, | 27489 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 18473 | .unused, | 27490 | .unused, |
| 18474 | .unused, | 27491 | .unused, |
| ... | @@ -18508,9 +27525,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18508,9 +27525,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18508 | .src_constraints = .{ | 27525 | .src_constraints = .{ |
| 18509 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 27526 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 18510 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 27527 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 27528 | .any, |
| 18511 | }, | 27529 | }, |
| 18512 | .patterns = &.{ | 27530 | .patterns = &.{ |
| 18513 | .{ .src = .{ .to_mem, .to_mem } }, | 27531 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18514 | }, | 27532 | }, |
| 18515 | .extra_temps = .{ | 27533 | .extra_temps = .{ |
| 18516 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27534 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18567,9 +27585,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18567,9 +27585,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18567 | .src_constraints = .{ | 27585 | .src_constraints = .{ |
| 18568 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 27586 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 18569 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 27587 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 27588 | .any, |
| 18570 | }, | 27589 | }, |
| 18571 | .patterns = &.{ | 27590 | .patterns = &.{ |
| 18572 | .{ .src = .{ .to_mem, .to_mem } }, | 27591 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18573 | }, | 27592 | }, |
| 18574 | .extra_temps = .{ | 27593 | .extra_temps = .{ |
| 18575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27594 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18626,9 +27645,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18626,9 +27645,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18626 | .src_constraints = .{ | 27645 | .src_constraints = .{ |
| 18627 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 27646 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| 18628 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, | 27647 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 27648 | .any, |
| 18629 | }, | 27649 | }, |
| 18630 | .patterns = &.{ | 27650 | .patterns = &.{ |
| 18631 | .{ .src = .{ .to_mem, .to_mem } }, | 27651 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18632 | }, | 27652 | }, |
| 18633 | .extra_temps = .{ | 27653 | .extra_temps = .{ |
| 18634 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 27654 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -18676,10 +27696,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18676,10 +27696,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18676 | .src_constraints = .{ | 27696 | .src_constraints = .{ |
| 18677 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27697 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18678 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27698 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27699 | .any, |
| 18679 | }, | 27700 | }, |
| 18680 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 27701 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18681 | .patterns = &.{ | 27702 | .patterns = &.{ |
| 18682 | .{ .src = .{ .to_mem, .to_mem } }, | 27703 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18683 | }, | 27704 | }, |
| 18684 | .call_frame = .{ .alignment = .@"16" }, | 27705 | .call_frame = .{ .alignment = .@"16" }, |
| 18685 | .extra_temps = .{ | 27706 | .extra_temps = .{ |
| ... | @@ -18687,11 +27708,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18687,11 +27708,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18687 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27708 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18688 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27709 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18689 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27710 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18690 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27711 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18691 | else => unreachable, | | |
| 18692 | .e => "__eqtf2", | | |
| 18693 | .ne => "__netf2", | | |
| 18694 | } } } }, | | |
| 18695 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27712 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18696 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27713 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18697 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 27714 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -18721,10 +27738,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18721,10 +27738,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18721 | .src_constraints = .{ | 27738 | .src_constraints = .{ |
| 18722 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27739 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18723 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27740 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27741 | .any, |
| 18724 | }, | 27742 | }, |
| 18725 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 27743 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18726 | .patterns = &.{ | 27744 | .patterns = &.{ |
| 18727 | .{ .src = .{ .to_mem, .to_mem } }, | 27745 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18728 | }, | 27746 | }, |
| 18729 | .call_frame = .{ .alignment = .@"16" }, | 27747 | .call_frame = .{ .alignment = .@"16" }, |
| 18730 | .extra_temps = .{ | 27748 | .extra_temps = .{ |
| ... | @@ -18732,11 +27750,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18732,11 +27750,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18732 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27750 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18733 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27751 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18734 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27752 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18735 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27753 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18736 | else => unreachable, | | |
| 18737 | .e => "__eqtf2", | | |
| 18738 | .ne => "__netf2", | | |
| 18739 | } } } }, | | |
| 18740 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27754 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18741 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27755 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18742 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 27756 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -18766,10 +27780,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18766,10 +27780,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18766 | .src_constraints = .{ | 27780 | .src_constraints = .{ |
| 18767 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27781 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18768 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27782 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27783 | .any, |
| 18769 | }, | 27784 | }, |
| 18770 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 27785 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18771 | .patterns = &.{ | 27786 | .patterns = &.{ |
| 18772 | .{ .src = .{ .to_mem, .to_mem } }, | 27787 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18773 | }, | 27788 | }, |
| 18774 | .call_frame = .{ .alignment = .@"16" }, | 27789 | .call_frame = .{ .alignment = .@"16" }, |
| 18775 | .extra_temps = .{ | 27790 | .extra_temps = .{ |
| ... | @@ -18777,11 +27792,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18777,11 +27792,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18777 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27792 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18778 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27793 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18779 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27794 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18780 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27795 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18781 | else => unreachable, | | |
| 18782 | .e => "__eqtf2", | | |
| 18783 | .ne => "__netf2", | | |
| 18784 | } } } }, | | |
| 18785 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27796 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18786 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27797 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18787 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 27798 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -18811,10 +27822,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18811,10 +27822,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18811 | .src_constraints = .{ | 27822 | .src_constraints = .{ |
| 18812 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27823 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18813 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27824 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27825 | .any, |
| 18814 | }, | 27826 | }, |
| 18815 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 27827 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18816 | .patterns = &.{ | 27828 | .patterns = &.{ |
| 18817 | .{ .src = .{ .to_mem, .to_mem } }, | 27829 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18818 | }, | 27830 | }, |
| 18819 | .call_frame = .{ .alignment = .@"16" }, | 27831 | .call_frame = .{ .alignment = .@"16" }, |
| 18820 | .extra_temps = .{ | 27832 | .extra_temps = .{ |
| ... | @@ -18822,11 +27834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18822,11 +27834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18822 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27834 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18823 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27835 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18824 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27836 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18825 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27837 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18826 | else => unreachable, | | |
| 18827 | .e => "__eqtf2", | | |
| 18828 | .ne => "__netf2", | | |
| 18829 | } } } }, | | |
| 18830 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27838 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18831 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27839 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18832 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 27840 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -18856,10 +27864,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18856,10 +27864,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18856 | .src_constraints = .{ | 27864 | .src_constraints = .{ |
| 18857 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27865 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18858 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27866 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27867 | .any, |
| 18859 | }, | 27868 | }, |
| 18860 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 27869 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18861 | .patterns = &.{ | 27870 | .patterns = &.{ |
| 18862 | .{ .src = .{ .to_mem, .to_mem } }, | 27871 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18863 | }, | 27872 | }, |
| 18864 | .call_frame = .{ .alignment = .@"16" }, | 27873 | .call_frame = .{ .alignment = .@"16" }, |
| 18865 | .extra_temps = .{ | 27874 | .extra_temps = .{ |
| ... | @@ -18867,11 +27876,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18867,11 +27876,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18867 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27876 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18868 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27877 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18869 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27878 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18870 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27879 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18871 | else => unreachable, | | |
| 18872 | .e => "__eqtf2", | | |
| 18873 | .ne => "__netf2", | | |
| 18874 | } } } }, | | |
| 18875 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27880 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18876 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27881 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18877 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 27882 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -18901,10 +27906,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18901,10 +27906,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18901 | .src_constraints = .{ | 27906 | .src_constraints = .{ |
| 18902 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27907 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18903 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27908 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27909 | .any, |
| 18904 | }, | 27910 | }, |
| 18905 | .dst_constraints = .{.{ .bool_vec = .dword }}, | 27911 | .dst_constraints = .{.{ .bool_vec = .dword }}, |
| 18906 | .patterns = &.{ | 27912 | .patterns = &.{ |
| 18907 | .{ .src = .{ .to_mem, .to_mem } }, | 27913 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18908 | }, | 27914 | }, |
| 18909 | .call_frame = .{ .alignment = .@"16" }, | 27915 | .call_frame = .{ .alignment = .@"16" }, |
| 18910 | .extra_temps = .{ | 27916 | .extra_temps = .{ |
| ... | @@ -18912,11 +27918,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18912,11 +27918,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18912 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 27918 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 18913 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27919 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18914 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27920 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18915 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27921 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18916 | else => unreachable, | | |
| 18917 | .e => "__eqtf2", | | |
| 18918 | .ne => "__netf2", | | |
| 18919 | } } } }, | | |
| 18920 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27922 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18921 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27923 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18922 | .{ .type = .u32, .kind = .{ .reg = .edx } }, | 27924 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| ... | @@ -18946,9 +27948,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18946,9 +27948,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18946 | .src_constraints = .{ | 27948 | .src_constraints = .{ |
| 18947 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27949 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 18948 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 27950 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 27951 | .any, |
| 18949 | }, | 27952 | }, |
| 18950 | .patterns = &.{ | 27953 | .patterns = &.{ |
| 18951 | .{ .src = .{ .to_mem, .to_mem } }, | 27954 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 18952 | }, | 27955 | }, |
| 18953 | .call_frame = .{ .alignment = .@"16" }, | 27956 | .call_frame = .{ .alignment = .@"16" }, |
| 18954 | .extra_temps = .{ | 27957 | .extra_temps = .{ |
| ... | @@ -18957,11 +27960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -18957,11 +27960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 18957 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 27960 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 18958 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 27961 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 18959 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 27962 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 18960 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 27963 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 18961 | else => unreachable, | | |
| 18962 | .e => "__eqtf2", | | |
| 18963 | .ne => "__netf2", | | |
| 18964 | } } } }, | | |
| 18965 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 27964 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 18966 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 27965 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 18967 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 27966 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -19000,9 +27999,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19000,9 +27999,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19000 | .src_constraints = .{ | 27999 | .src_constraints = .{ |
| 19001 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28000 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19002 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28001 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 28002 | .any, |
| 19003 | }, | 28003 | }, |
| 19004 | .patterns = &.{ | 28004 | .patterns = &.{ |
| 19005 | .{ .src = .{ .to_mem, .to_mem } }, | 28005 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19006 | }, | 28006 | }, |
| 19007 | .call_frame = .{ .alignment = .@"16" }, | 28007 | .call_frame = .{ .alignment = .@"16" }, |
| 19008 | .extra_temps = .{ | 28008 | .extra_temps = .{ |
| ... | @@ -19011,11 +28011,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19011,11 +28011,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19011 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 28011 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19012 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 28012 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19013 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 28013 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19014 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 28014 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19015 | else => unreachable, | | |
| 19016 | .e => "__eqtf2", | | |
| 19017 | .ne => "__netf2", | | |
| 19018 | } } } }, | | |
| 19019 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 28015 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19020 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 28016 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19021 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 28017 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -19054,9 +28050,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19054,9 +28050,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19054 | .src_constraints = .{ | 28050 | .src_constraints = .{ |
| 19055 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28051 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19056 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28052 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 28053 | .any, |
| 19057 | }, | 28054 | }, |
| 19058 | .patterns = &.{ | 28055 | .patterns = &.{ |
| 19059 | .{ .src = .{ .to_mem, .to_mem } }, | 28056 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19060 | }, | 28057 | }, |
| 19061 | .call_frame = .{ .alignment = .@"16" }, | 28058 | .call_frame = .{ .alignment = .@"16" }, |
| 19062 | .extra_temps = .{ | 28059 | .extra_temps = .{ |
| ... | @@ -19065,11 +28062,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19065,11 +28062,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19065 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 28062 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19066 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 28063 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19067 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 28064 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19068 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 28065 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19069 | else => unreachable, | | |
| 19070 | .e => "__eqtf2", | | |
| 19071 | .ne => "__netf2", | | |
| 19072 | } } } }, | | |
| 19073 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 28066 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19074 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 28067 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19075 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 28068 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -19108,9 +28101,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19108,9 +28101,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19108 | .src_constraints = .{ | 28101 | .src_constraints = .{ |
| 19109 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28102 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19110 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28103 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 28104 | .any, |
| 19111 | }, | 28105 | }, |
| 19112 | .patterns = &.{ | 28106 | .patterns = &.{ |
| 19113 | .{ .src = .{ .to_mem, .to_mem } }, | 28107 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19114 | }, | 28108 | }, |
| 19115 | .call_frame = .{ .alignment = .@"16" }, | 28109 | .call_frame = .{ .alignment = .@"16" }, |
| 19116 | .extra_temps = .{ | 28110 | .extra_temps = .{ |
| ... | @@ -19119,11 +28113,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19119,11 +28113,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19119 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 28113 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19120 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 28114 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19121 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 28115 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19122 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 28116 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19123 | else => unreachable, | | |
| 19124 | .e => "__eqtf2", | | |
| 19125 | .ne => "__netf2", | | |
| 19126 | } } } }, | | |
| 19127 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 28117 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19128 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 28118 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19129 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 28119 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -19162,9 +28152,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19162,9 +28152,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19162 | .src_constraints = .{ | 28152 | .src_constraints = .{ |
| 19163 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28153 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19164 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28154 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 28155 | .any, |
| 19165 | }, | 28156 | }, |
| 19166 | .patterns = &.{ | 28157 | .patterns = &.{ |
| 19167 | .{ .src = .{ .to_mem, .to_mem } }, | 28158 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19168 | }, | 28159 | }, |
| 19169 | .call_frame = .{ .alignment = .@"16" }, | 28160 | .call_frame = .{ .alignment = .@"16" }, |
| 19170 | .extra_temps = .{ | 28161 | .extra_temps = .{ |
| ... | @@ -19173,11 +28164,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19173,11 +28164,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19173 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 28164 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19174 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 28165 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19175 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 28166 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19176 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 28167 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19177 | else => unreachable, | | |
| 19178 | .e => "__eqtf2", | | |
| 19179 | .ne => "__netf2", | | |
| 19180 | } } } }, | | |
| 19181 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 28168 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19182 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 28169 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19183 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 28170 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -19216,9 +28203,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19216,9 +28203,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19216 | .src_constraints = .{ | 28203 | .src_constraints = .{ |
| 19217 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28204 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| 19218 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, | 28205 | .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 28206 | .any, |
| 19219 | }, | 28207 | }, |
| 19220 | .patterns = &.{ | 28208 | .patterns = &.{ |
| 19221 | .{ .src = .{ .to_mem, .to_mem } }, | 28209 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 19222 | }, | 28210 | }, |
| 19223 | .call_frame = .{ .alignment = .@"16" }, | 28211 | .call_frame = .{ .alignment = .@"16" }, |
| 19224 | .extra_temps = .{ | 28212 | .extra_temps = .{ |
| ... | @@ -19227,11 +28215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19227,11 +28215,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19227 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 28215 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 19228 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 28216 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 19229 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, | 28217 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 19230 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (cc) { | 28218 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__cmptf2" } } }, |
| 19231 | else => unreachable, | | |
| 19232 | .e => "__eqtf2", | | |
| 19233 | .ne => "__netf2", | | |
| 19234 | } } } }, | | |
| 19235 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 28219 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 19236 | .{ .type = .u8, .kind = .{ .reg = .cl } }, | 28220 | .{ .type = .u8, .kind = .{ .reg = .cl } }, |
| 19237 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, | 28221 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| ... | @@ -19266,31 +28250,1583 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19266,31 +28250,1583 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19266 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, | 28250 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp1), .tmp2q, ._, ._ }, |
| 19267 | } }, | 28251 | } }, |
| 19268 | } }, | 28252 | } }, |
| 19269 | }) catch |err| switch (err) { | 28253 | }), |
| 19270 | error.SelectFailed => return cg.fail("failed to select {s} {s} {} {} {}", .{ | 28254 | }) catch |err| switch (err) { |
| 19271 | @tagName(air_tag), | 28255 | error.SelectFailed => return cg.fail("failed to select {s} {s} {} {} {}", .{ |
| 19272 | @tagName(extra.compareOperator()), | 28256 | @tagName(air_tag), |
| 19273 | cg.typeOf(extra.lhs).fmt(pt), | 28257 | @tagName(extra.compareOperator()), |
| 19274 | ops[0].tracking(cg), | 28258 | cg.typeOf(extra.lhs).fmt(pt), |
| 19275 | ops[1].tracking(cg), | 28259 | ops[0].tracking(cg), |
| 19276 | }), | 28260 | ops[1].tracking(cg), |
| 19277 | else => |e| return e, | 28261 | }), |
| 19278 | }, | 28262 | else => |e| return e, |
| 19279 | .gte => unreachable, | 28263 | }; |
| 19280 | .gt => unreachable, | 28264 | try res[0].finish(inst, &.{ extra.lhs, extra.rhs }, &ops, cg); |
| 19281 | } | 28265 | }, |
| 19282 | try res[0].finish(inst, &.{ extra.lhs, extra.rhs }, &ops, cg); | 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 | .abs => |air_tag| if (use_old) try cg.airAbs(inst) else { | 29821 | .abs => |air_tag| if (use_old) try cg.airAbs(inst) else { |
| 19286 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; | 29822 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 19287 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); | 29823 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 19288 | var res: [1]Temp = undefined; | 29824 | var res: [1]Temp = undefined; |
| 19289 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 29825 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 19290 | .required_features = .{ .cmov, null, null, null }, | 29826 | .required_features = .{ .cmov, null, null, null }, |
| 19291 | .src_constraints = .{ .{ .int = .byte }, .any }, | 29827 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 19292 | .patterns = &.{ | 29828 | .patterns = &.{ |
| 19293 | .{ .src = .{ .to_gpr, .none } }, | 29829 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19294 | }, | 29830 | }, |
| 19295 | .dst_temps = .{.{ .rc = .general_purpose }}, | 29831 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19296 | .clobbers = .{ .eflags = true }, | 29832 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19300,9 +29836,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19300,9 +29836,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19300 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, | 29836 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, |
| 19301 | } }, | 29837 | } }, |
| 19302 | }, .{ | 29838 | }, .{ |
| 19303 | .src_constraints = .{ .{ .int = .byte }, .any }, | 29839 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 19304 | .patterns = &.{ | 29840 | .patterns = &.{ |
| 19305 | .{ .src = .{ .mut_mem, .none } }, | 29841 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19306 | }, | 29842 | }, |
| 19307 | .dst_temps = .{.{ .ref = .src0 }}, | 29843 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19308 | .clobbers = .{ .eflags = true }, | 29844 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19312,9 +29848,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19312,9 +29848,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19312 | .{ ._, ._, .neg, .dst0b, ._, ._, ._ }, | 29848 | .{ ._, ._, .neg, .dst0b, ._, ._, ._ }, |
| 19313 | } }, | 29849 | } }, |
| 19314 | }, .{ | 29850 | }, .{ |
| 19315 | .src_constraints = .{ .{ .int = .byte }, .any }, | 29851 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 19316 | .patterns = &.{ | 29852 | .patterns = &.{ |
| 19317 | .{ .src = .{ .to_mut_gpr, .none } }, | 29853 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19318 | }, | 29854 | }, |
| 19319 | .dst_temps = .{.{ .ref = .src0 }}, | 29855 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19320 | .clobbers = .{ .eflags = true }, | 29856 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19325,9 +29861,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19325,9 +29861,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19325 | } }, | 29861 | } }, |
| 19326 | }, .{ | 29862 | }, .{ |
| 19327 | .required_features = .{ .cmov, null, null, null }, | 29863 | .required_features = .{ .cmov, null, null, null }, |
| 19328 | .src_constraints = .{ .{ .int = .word }, .any }, | 29864 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19329 | .patterns = &.{ | 29865 | .patterns = &.{ |
| 19330 | .{ .src = .{ .mem, .none } }, | 29866 | .{ .src = .{ .mem, .none, .none } }, |
| 19331 | }, | 29867 | }, |
| 19332 | .dst_temps = .{.{ .rc = .general_purpose }}, | 29868 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19333 | .clobbers = .{ .eflags = true }, | 29869 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19338,9 +29874,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19338,9 +29874,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19338 | } }, | 29874 | } }, |
| 19339 | }, .{ | 29875 | }, .{ |
| 19340 | .required_features = .{ .cmov, null, null, null }, | 29876 | .required_features = .{ .cmov, null, null, null }, |
| 19341 | .src_constraints = .{ .{ .int = .word }, .any }, | 29877 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19342 | .patterns = &.{ | 29878 | .patterns = &.{ |
| 19343 | .{ .src = .{ .to_gpr, .none } }, | 29879 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19344 | }, | 29880 | }, |
| 19345 | .dst_temps = .{.{ .rc = .general_purpose }}, | 29881 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19346 | .clobbers = .{ .eflags = true }, | 29882 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19350,9 +29886,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19350,9 +29886,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19350 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, | 29886 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, |
| 19351 | } }, | 29887 | } }, |
| 19352 | }, .{ | 29888 | }, .{ |
| 19353 | .src_constraints = .{ .{ .int = .word }, .any }, | 29889 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19354 | .patterns = &.{ | 29890 | .patterns = &.{ |
| 19355 | .{ .src = .{ .mut_mem, .none } }, | 29891 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19356 | }, | 29892 | }, |
| 19357 | .dst_temps = .{.{ .ref = .src0 }}, | 29893 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19358 | .clobbers = .{ .eflags = true }, | 29894 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19362,9 +29898,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19362,9 +29898,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19362 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, | 29898 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 19363 | } }, | 29899 | } }, |
| 19364 | }, .{ | 29900 | }, .{ |
| 19365 | .src_constraints = .{ .{ .int = .word }, .any }, | 29901 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 19366 | .patterns = &.{ | 29902 | .patterns = &.{ |
| 19367 | .{ .src = .{ .to_mut_gpr, .none } }, | 29903 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19368 | }, | 29904 | }, |
| 19369 | .dst_temps = .{.{ .ref = .src0 }}, | 29905 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19370 | .clobbers = .{ .eflags = true }, | 29906 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19375,10 +29911,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19375,10 +29911,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19375 | } }, | 29911 | } }, |
| 19376 | }, .{ | 29912 | }, .{ |
| 19377 | .required_features = .{ .cmov, null, null, null }, | 29913 | .required_features = .{ .cmov, null, null, null }, |
| 19378 | .src_constraints = .{ .{ .int = .dword }, .any }, | 29914 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 19379 | .patterns = &.{ | 29915 | .patterns = &.{ |
| 19380 | .{ .src = .{ .mem, .none } }, | 29916 | .{ .src = .{ .mem, .none, .none } }, |
| 19381 | .{ .src = .{ .to_gpr, .none } }, | 29917 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19382 | }, | 29918 | }, |
| 19383 | .dst_temps = .{.{ .rc = .general_purpose }}, | 29919 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19384 | .clobbers = .{ .eflags = true }, | 29920 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19388,9 +29924,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19388,9 +29924,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19388 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, | 29924 | .{ ._, ._s, .cmov, .dst0d, .src0d, ._, ._ }, |
| 19389 | } }, | 29925 | } }, |
| 19390 | }, .{ | 29926 | }, .{ |
| 19391 | .src_constraints = .{ .{ .int = .dword }, .any }, | 29927 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 19392 | .patterns = &.{ | 29928 | .patterns = &.{ |
| 19393 | .{ .src = .{ .mut_mem, .none } }, | 29929 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19394 | }, | 29930 | }, |
| 19395 | .dst_temps = .{.{ .ref = .src0 }}, | 29931 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19396 | .clobbers = .{ .eflags = true }, | 29932 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19400,9 +29936,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19400,9 +29936,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19400 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, | 29936 | .{ ._, ._, .neg, .dst0d, ._, ._, ._ }, |
| 19401 | } }, | 29937 | } }, |
| 19402 | }, .{ | 29938 | }, .{ |
| 19403 | .src_constraints = .{ .{ .int = .dword }, .any }, | 29939 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 19404 | .patterns = &.{ | 29940 | .patterns = &.{ |
| 19405 | .{ .src = .{ .to_mut_gpr, .none } }, | 29941 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19406 | }, | 29942 | }, |
| 19407 | .dst_temps = .{.{ .ref = .src0 }}, | 29943 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19408 | .clobbers = .{ .eflags = true }, | 29944 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19413,10 +29949,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19413,10 +29949,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19413 | } }, | 29949 | } }, |
| 19414 | }, .{ | 29950 | }, .{ |
| 19415 | .required_features = .{ .@"64bit", .cmov, null, null }, | 29951 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 19416 | .src_constraints = .{ .{ .int = .qword }, .any }, | 29952 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 19417 | .patterns = &.{ | 29953 | .patterns = &.{ |
| 19418 | .{ .src = .{ .mem, .none } }, | 29954 | .{ .src = .{ .mem, .none, .none } }, |
| 19419 | .{ .src = .{ .to_gpr, .none } }, | 29955 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 19420 | }, | 29956 | }, |
| 19421 | .dst_temps = .{.{ .rc = .general_purpose }}, | 29957 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 19422 | .clobbers = .{ .eflags = true }, | 29958 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19427,9 +29963,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19427,9 +29963,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19427 | } }, | 29963 | } }, |
| 19428 | }, .{ | 29964 | }, .{ |
| 19429 | .required_features = .{ .@"64bit", null, null, null }, | 29965 | .required_features = .{ .@"64bit", null, null, null }, |
| 19430 | .src_constraints = .{ .{ .int = .qword }, .any }, | 29966 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 19431 | .patterns = &.{ | 29967 | .patterns = &.{ |
| 19432 | .{ .src = .{ .mut_mem, .none } }, | 29968 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 19433 | }, | 29969 | }, |
| 19434 | .dst_temps = .{.{ .ref = .src0 }}, | 29970 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19435 | .clobbers = .{ .eflags = true }, | 29971 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19440,9 +29976,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19440,9 +29976,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19440 | } }, | 29976 | } }, |
| 19441 | }, .{ | 29977 | }, .{ |
| 19442 | .required_features = .{ .@"64bit", null, null, null }, | 29978 | .required_features = .{ .@"64bit", null, null, null }, |
| 19443 | .src_constraints = .{ .{ .int = .qword }, .any }, | 29979 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| 19444 | .patterns = &.{ | 29980 | .patterns = &.{ |
| 19445 | .{ .src = .{ .to_mut_gpr, .none } }, | 29981 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 19446 | }, | 29982 | }, |
| 19447 | .dst_temps = .{.{ .ref = .src0 }}, | 29983 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19448 | .clobbers = .{ .eflags = true }, | 29984 | .clobbers = .{ .eflags = true }, |
| ... | @@ -19453,9 +29989,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19453,9 +29989,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19453 | } }, | 29989 | } }, |
| 19454 | }, .{ | 29990 | }, .{ |
| 19455 | .required_features = .{ .@"64bit", null, null, null }, | 29991 | .required_features = .{ .@"64bit", null, null, null }, |
| 19456 | .src_constraints = .{ .any_int, .any }, | 29992 | .src_constraints = .{ .any_int, .any, .any }, |
| 19457 | .patterns = &.{ | 29993 | .patterns = &.{ |
| 19458 | .{ .src = .{ .to_mem, .none } }, | 29994 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19459 | }, | 29995 | }, |
| 19460 | .extra_temps = .{ | 29996 | .extra_temps = .{ |
| 19461 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 29997 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19486,10 +30022,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19486,10 +30022,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19486 | } }, | 30022 | } }, |
| 19487 | }, .{ | 30023 | }, .{ |
| 19488 | .required_features = .{ .mmx, .ssse3, null, null }, | 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 | .patterns = &.{ | 30026 | .patterns = &.{ |
| 19491 | .{ .src = .{ .mem, .none } }, | 30027 | .{ .src = .{ .mem, .none, .none } }, |
| 19492 | .{ .src = .{ .to_mm, .none } }, | 30028 | .{ .src = .{ .to_mm, .none, .none } }, |
| 19493 | }, | 30029 | }, |
| 19494 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, | 30030 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, |
| 19495 | .each = .{ .once = &.{ | 30031 | .each = .{ .once = &.{ |
| ... | @@ -19497,10 +30033,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19497,10 +30033,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19497 | } }, | 30033 | } }, |
| 19498 | }, .{ | 30034 | }, .{ |
| 19499 | .required_features = .{ .mmx, .ssse3, null, null }, | 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 | .patterns = &.{ | 30037 | .patterns = &.{ |
| 19502 | .{ .src = .{ .mem, .none } }, | 30038 | .{ .src = .{ .mem, .none, .none } }, |
| 19503 | .{ .src = .{ .to_mm, .none } }, | 30039 | .{ .src = .{ .to_mm, .none, .none } }, |
| 19504 | }, | 30040 | }, |
| 19505 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, | 30041 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, |
| 19506 | .each = .{ .once = &.{ | 30042 | .each = .{ .once = &.{ |
| ... | @@ -19508,10 +30044,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19508,10 +30044,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19508 | } }, | 30044 | } }, |
| 19509 | }, .{ | 30045 | }, .{ |
| 19510 | .required_features = .{ .mmx, .ssse3, null, null }, | 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 | .patterns = &.{ | 30048 | .patterns = &.{ |
| 19513 | .{ .src = .{ .mem, .none } }, | 30049 | .{ .src = .{ .mem, .none, .none } }, |
| 19514 | .{ .src = .{ .to_mm, .none } }, | 30050 | .{ .src = .{ .to_mm, .none, .none } }, |
| 19515 | }, | 30051 | }, |
| 19516 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, | 30052 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .mmx } }}, |
| 19517 | .each = .{ .once = &.{ | 30053 | .each = .{ .once = &.{ |
| ... | @@ -19519,10 +30055,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19519,10 +30055,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19519 | } }, | 30055 | } }, |
| 19520 | }, .{ | 30056 | }, .{ |
| 19521 | .required_features = .{ .ssse3, null, null, null }, | 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 | .patterns = &.{ | 30059 | .patterns = &.{ |
| 19524 | .{ .src = .{ .mem, .none } }, | 30060 | .{ .src = .{ .mem, .none, .none } }, |
| 19525 | .{ .src = .{ .to_sse, .none } }, | 30061 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19526 | }, | 30062 | }, |
| 19527 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30063 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19528 | .each = .{ .once = &.{ | 30064 | .each = .{ .once = &.{ |
| ... | @@ -19530,10 +30066,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19530,10 +30066,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19530 | } }, | 30066 | } }, |
| 19531 | }, .{ | 30067 | }, .{ |
| 19532 | .required_features = .{ .ssse3, null, null, null }, | 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 | .patterns = &.{ | 30070 | .patterns = &.{ |
| 19535 | .{ .src = .{ .mem, .none } }, | 30071 | .{ .src = .{ .mem, .none, .none } }, |
| 19536 | .{ .src = .{ .to_sse, .none } }, | 30072 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19537 | }, | 30073 | }, |
| 19538 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30074 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19539 | .each = .{ .once = &.{ | 30075 | .each = .{ .once = &.{ |
| ... | @@ -19541,10 +30077,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19541,10 +30077,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19541 | } }, | 30077 | } }, |
| 19542 | }, .{ | 30078 | }, .{ |
| 19543 | .required_features = .{ .ssse3, null, null, null }, | 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 | .patterns = &.{ | 30081 | .patterns = &.{ |
| 19546 | .{ .src = .{ .mem, .none } }, | 30082 | .{ .src = .{ .mem, .none, .none } }, |
| 19547 | .{ .src = .{ .to_sse, .none } }, | 30083 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19548 | }, | 30084 | }, |
| 19549 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30085 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19550 | .each = .{ .once = &.{ | 30086 | .each = .{ .once = &.{ |
| ... | @@ -19552,10 +30088,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19552,10 +30088,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19552 | } }, | 30088 | } }, |
| 19553 | }, .{ | 30089 | }, .{ |
| 19554 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 30092 | .patterns = &.{ |
| 19557 | .{ .src = .{ .mem, .none } }, | 30093 | .{ .src = .{ .mem, .none, .none } }, |
| 19558 | .{ .src = .{ .to_sse, .none } }, | 30094 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19559 | }, | 30095 | }, |
| 19560 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30096 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19561 | .each = .{ .once = &.{ | 30097 | .each = .{ .once = &.{ |
| ... | @@ -19563,10 +30099,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19563,10 +30099,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19563 | } }, | 30099 | } }, |
| 19564 | }, .{ | 30100 | }, .{ |
| 19565 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 30103 | .patterns = &.{ |
| 19568 | .{ .src = .{ .mem, .none } }, | 30104 | .{ .src = .{ .mem, .none, .none } }, |
| 19569 | .{ .src = .{ .to_sse, .none } }, | 30105 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19570 | }, | 30106 | }, |
| 19571 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30107 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19572 | .each = .{ .once = &.{ | 30108 | .each = .{ .once = &.{ |
| ... | @@ -19574,10 +30110,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19574,10 +30110,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19574 | } }, | 30110 | } }, |
| 19575 | }, .{ | 30111 | }, .{ |
| 19576 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 30114 | .patterns = &.{ |
| 19579 | .{ .src = .{ .mem, .none } }, | 30115 | .{ .src = .{ .mem, .none, .none } }, |
| 19580 | .{ .src = .{ .to_sse, .none } }, | 30116 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19581 | }, | 30117 | }, |
| 19582 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30118 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19583 | .each = .{ .once = &.{ | 30119 | .each = .{ .once = &.{ |
| ... | @@ -19585,10 +30121,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19585,10 +30121,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19585 | } }, | 30121 | } }, |
| 19586 | }, .{ | 30122 | }, .{ |
| 19587 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 30125 | .patterns = &.{ |
| 19590 | .{ .src = .{ .mem, .none } }, | 30126 | .{ .src = .{ .mem, .none, .none } }, |
| 19591 | .{ .src = .{ .to_sse, .none } }, | 30127 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19592 | }, | 30128 | }, |
| 19593 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30129 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19594 | .each = .{ .once = &.{ | 30130 | .each = .{ .once = &.{ |
| ... | @@ -19596,10 +30132,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19596,10 +30132,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19596 | } }, | 30132 | } }, |
| 19597 | }, .{ | 30133 | }, .{ |
| 19598 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 30136 | .patterns = &.{ |
| 19601 | .{ .src = .{ .mem, .none } }, | 30137 | .{ .src = .{ .mem, .none, .none } }, |
| 19602 | .{ .src = .{ .to_sse, .none } }, | 30138 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19603 | }, | 30139 | }, |
| 19604 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30140 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19605 | .each = .{ .once = &.{ | 30141 | .each = .{ .once = &.{ |
| ... | @@ -19607,10 +30143,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19607,10 +30143,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19607 | } }, | 30143 | } }, |
| 19608 | }, .{ | 30144 | }, .{ |
| 19609 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 30147 | .patterns = &.{ |
| 19612 | .{ .src = .{ .mem, .none } }, | 30148 | .{ .src = .{ .mem, .none, .none } }, |
| 19613 | .{ .src = .{ .to_sse, .none } }, | 30149 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19614 | }, | 30150 | }, |
| 19615 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 30151 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19616 | .each = .{ .once = &.{ | 30152 | .each = .{ .once = &.{ |
| ... | @@ -19618,9 +30154,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19618,9 +30154,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19618 | } }, | 30154 | } }, |
| 19619 | }, .{ | 30155 | }, .{ |
| 19620 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 30158 | .patterns = &.{ |
| 19623 | .{ .src = .{ .to_mem, .none } }, | 30159 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19624 | }, | 30160 | }, |
| 19625 | .extra_temps = .{ | 30161 | .extra_temps = .{ |
| 19626 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30162 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19644,9 +30180,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19644,9 +30180,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19644 | } }, | 30180 | } }, |
| 19645 | }, .{ | 30181 | }, .{ |
| 19646 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 30184 | .patterns = &.{ |
| 19649 | .{ .src = .{ .to_mem, .none } }, | 30185 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19650 | }, | 30186 | }, |
| 19651 | .extra_temps = .{ | 30187 | .extra_temps = .{ |
| 19652 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30188 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19670,9 +30206,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19670,9 +30206,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19670 | } }, | 30206 | } }, |
| 19671 | }, .{ | 30207 | }, .{ |
| 19672 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 30210 | .patterns = &.{ |
| 19675 | .{ .src = .{ .to_mem, .none } }, | 30211 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19676 | }, | 30212 | }, |
| 19677 | .extra_temps = .{ | 30213 | .extra_temps = .{ |
| 19678 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19696,9 +30232,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19696,9 +30232,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19696 | } }, | 30232 | } }, |
| 19697 | }, .{ | 30233 | }, .{ |
| 19698 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 30236 | .patterns = &.{ |
| 19701 | .{ .src = .{ .to_mem, .none } }, | 30237 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19702 | }, | 30238 | }, |
| 19703 | .extra_temps = .{ | 30239 | .extra_temps = .{ |
| 19704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30240 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19722,9 +30258,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19722,9 +30258,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19722 | } }, | 30258 | } }, |
| 19723 | }, .{ | 30259 | }, .{ |
| 19724 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 30262 | .patterns = &.{ |
| 19727 | .{ .src = .{ .to_mem, .none } }, | 30263 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19728 | }, | 30264 | }, |
| 19729 | .extra_temps = .{ | 30265 | .extra_temps = .{ |
| 19730 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30266 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19748,9 +30284,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19748,9 +30284,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19748 | } }, | 30284 | } }, |
| 19749 | }, .{ | 30285 | }, .{ |
| 19750 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 30288 | .patterns = &.{ |
| 19753 | .{ .src = .{ .to_mem, .none } }, | 30289 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19754 | }, | 30290 | }, |
| 19755 | .extra_temps = .{ | 30291 | .extra_temps = .{ |
| 19756 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30292 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19774,9 +30310,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19774,9 +30310,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19774 | } }, | 30310 | } }, |
| 19775 | }, .{ | 30311 | }, .{ |
| 19776 | .required_features = .{ .ssse3, null, null, null }, | 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 | .patterns = &.{ | 30314 | .patterns = &.{ |
| 19779 | .{ .src = .{ .to_mem, .none } }, | 30315 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19780 | }, | 30316 | }, |
| 19781 | .extra_temps = .{ | 30317 | .extra_temps = .{ |
| 19782 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19800,9 +30336,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19800,9 +30336,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19800 | } }, | 30336 | } }, |
| 19801 | }, .{ | 30337 | }, .{ |
| 19802 | .required_features = .{ .ssse3, null, null, null }, | 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 | .patterns = &.{ | 30340 | .patterns = &.{ |
| 19805 | .{ .src = .{ .to_mem, .none } }, | 30341 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19806 | }, | 30342 | }, |
| 19807 | .extra_temps = .{ | 30343 | .extra_temps = .{ |
| 19808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30344 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19826,9 +30362,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19826,9 +30362,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19826 | } }, | 30362 | } }, |
| 19827 | }, .{ | 30363 | }, .{ |
| 19828 | .required_features = .{ .ssse3, null, null, null }, | 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 | .patterns = &.{ | 30366 | .patterns = &.{ |
| 19831 | .{ .src = .{ .to_mem, .none } }, | 30367 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19832 | }, | 30368 | }, |
| 19833 | .extra_temps = .{ | 30369 | .extra_temps = .{ |
| 19834 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19852,9 +30388,61 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19852,9 +30388,61 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19852 | } }, | 30388 | } }, |
| 19853 | }, .{ | 30389 | }, .{ |
| 19854 | .required_features = .{ .mmx, .ssse3, null, null }, | 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 | .patterns = &.{ | 30444 | .patterns = &.{ |
| 19857 | .{ .src = .{ .to_mem, .none } }, | 30445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 19858 | }, | 30446 | }, |
| 19859 | .extra_temps = .{ | 30447 | .extra_temps = .{ |
| 19860 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -19870,21 +30458,498 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19870,21 +30458,498 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19870 | .dst_temps = .{.mem}, | 30458 | .dst_temps = .{.mem}, |
| 19871 | .clobbers = .{ .eflags = true }, | 30459 | .clobbers = .{ .eflags = true }, |
| 19872 | .each = .{ .once = &.{ | 30460 | .each = .{ .once = &.{ |
| 19873 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 30461 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 19874 | .{ .@"0:", .p_b, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 30462 | .{ .@"0:", .p_d, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 19875 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | 30463 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 19876 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 30464 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 19877 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 30945 | .required_features = .{ .avx, null, null, null }, |
| 19881 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 30946 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 19882 | .patterns = &.{ | 30947 | .patterns = &.{ |
| 19883 | .{ .src = .{ .to_mem, .none } }, | 30948 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19884 | }, | 30949 | }, |
| 19885 | .extra_temps = .{ | 30950 | .extra_temps = .{ |
| 19886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30951 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 19887 | .{ .kind = .{ .rc = .sse } }, | 30952 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 19888 | .unused, | 30953 | .unused, |
| 19889 | .unused, | 30954 | .unused, |
| 19890 | .unused, | 30955 | .unused, |
| ... | @@ -19893,24 +30958,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19893,24 +30958,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19893 | .unused, | 30958 | .unused, |
| 19894 | .unused, | 30959 | .unused, |
| 19895 | }, | 30960 | }, |
| 19896 | .dst_temps = .{.mem}, | 30961 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19897 | .clobbers = .{ .eflags = true }, | | |
| 19898 | .each = .{ .once = &.{ | 30962 | .each = .{ .once = &.{ |
| 19899 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 30963 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 19900 | .{ .@"0:", .p_w, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 30964 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 19901 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | | |
| 19902 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | | |
| 19903 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 19904 | } }, | 30965 | } }, |
| 19905 | }, .{ | 30966 | }, .{ |
| 19906 | .required_features = .{ .mmx, .ssse3, null, null }, | 30967 | .required_features = .{ .sse2, null, null, null }, |
| 19907 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any }, | 30968 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 19908 | .patterns = &.{ | 30969 | .patterns = &.{ |
| 19909 | .{ .src = .{ .to_mem, .none } }, | 30970 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 19910 | }, | 30971 | }, |
| 19911 | .extra_temps = .{ | 30972 | .extra_temps = .{ |
| 19912 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30973 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 19913 | .{ .kind = .{ .rc = .sse } }, | 30974 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 19914 | .unused, | 30975 | .unused, |
| 19915 | .unused, | 30976 | .unused, |
| 19916 | .unused, | 30977 | .unused, |
| ... | @@ -19919,25 +30980,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19919,25 +30980,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19919 | .unused, | 30980 | .unused, |
| 19920 | .unused, | 30981 | .unused, |
| 19921 | }, | 30982 | }, |
| 19922 | .dst_temps = .{.mem}, | 30983 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19923 | .clobbers = .{ .eflags = true }, | | |
| 19924 | .each = .{ .once = &.{ | 30984 | .each = .{ .once = &.{ |
| 19925 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 30985 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 19926 | .{ .@"0:", .p_d, .abs, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 30986 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 19927 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | | |
| 19928 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | | |
| 19929 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 19930 | } }, | 30987 | } }, |
| 19931 | }, .{ | 30988 | }, .{ |
| 19932 | .required_features = .{ .cmov, .slow_incdec, null, null }, | 30989 | .required_features = .{ .sse, null, null, null }, |
| 19933 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 30990 | .src_constraints = .{ .{ .scalar_any_float = .xword }, .any, .any }, |
| 19934 | .patterns = &.{ | 30991 | .patterns = &.{ |
| 19935 | .{ .src = .{ .to_mem, .none } }, | 30992 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 19936 | }, | 30993 | }, |
| 19937 | .extra_temps = .{ | 30994 | .extra_temps = .{ |
| 19938 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 30995 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 19939 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 30996 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 19940 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 30997 | .unused, |
| 19941 | .unused, | 30998 | .unused, |
| 19942 | .unused, | 30999 | .unused, |
| 19943 | .unused, | 31000 | .unused, |
| ... | @@ -19945,28 +31002,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19945,28 +31002,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19945 | .unused, | 31002 | .unused, |
| 19946 | .unused, | 31003 | .unused, |
| 19947 | }, | 31004 | }, |
| 19948 | .dst_temps = .{.mem}, | 31005 | .dst_temps = .{.{ .ref = .src0 }}, |
| 19949 | .clobbers = .{ .eflags = true }, | | |
| 19950 | .each = .{ .once = &.{ | 31006 | .each = .{ .once = &.{ |
| 19951 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31007 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 19952 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 31008 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 19959 | } }, | 31009 | } }, |
| 19960 | }, .{ | 31010 | }, .{ |
| 19961 | .required_features = .{ .cmov, null, null, null }, | 31011 | .required_features = .{ .avx2, null, null, null }, |
| 19962 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 31012 | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any }, |
| 19963 | .patterns = &.{ | 31013 | .patterns = &.{ |
| 19964 | .{ .src = .{ .to_mem, .none } }, | 31014 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19965 | }, | 31015 | }, |
| 19966 | .extra_temps = .{ | 31016 | .extra_temps = .{ |
| 19967 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31017 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 19968 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 31018 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 19969 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 31019 | .unused, |
| 19970 | .unused, | 31020 | .unused, |
| 19971 | .unused, | 31021 | .unused, |
| 19972 | .unused, | 31022 | .unused, |
| ... | @@ -19974,27 +31024,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -19974,27 +31024,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 19974 | .unused, | 31024 | .unused, |
| 19975 | .unused, | 31025 | .unused, |
| 19976 | }, | 31026 | }, |
| 19977 | .dst_temps = .{.mem}, | 31027 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 19978 | .clobbers = .{ .eflags = true }, | | |
| 19979 | .each = .{ .once = &.{ | 31028 | .each = .{ .once = &.{ |
| 19980 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31029 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 19981 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 31030 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 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", ._, ._, ._ }, | | |
| 19988 | } }, | 31031 | } }, |
| 19989 | }, .{ | 31032 | }, .{ |
| 19990 | .required_features = .{ .slow_incdec, null, null, null }, | 31033 | .required_features = .{ .avx, null, null, null }, |
| 19991 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 31034 | .src_constraints = .{ .{ .scalar_any_float = .yword }, .any, .any }, |
| 19992 | .patterns = &.{ | 31035 | .patterns = &.{ |
| 19993 | .{ .src = .{ .to_mem, .none } }, | 31036 | .{ .src = .{ .to_sse, .none, .none } }, |
| 19994 | }, | 31037 | }, |
| 19995 | .extra_temps = .{ | 31038 | .extra_temps = .{ |
| 19996 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31039 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 19997 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 31040 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 19998 | .unused, | 31041 | .unused, |
| 19999 | .unused, | 31042 | .unused, |
| 20000 | .unused, | 31043 | .unused, |
| ... | @@ -20003,28 +31046,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20003,28 +31046,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20003 | .unused, | 31046 | .unused, |
| 20004 | .unused, | 31047 | .unused, |
| 20005 | }, | 31048 | }, |
| 20006 | .dst_temps = .{.mem}, | 31049 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20007 | .clobbers = .{ .eflags = true }, | | |
| 20008 | .each = .{ .once = &.{ | 31050 | .each = .{ .once = &.{ |
| 20009 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31051 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20010 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 31052 | .{ ._, .v_pd, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 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", ._, ._, ._ }, | | |
| 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 | .patterns = &.{ | 31057 | .patterns = &.{ |
| 20021 | .{ .src = .{ .to_mem, .none } }, | 31058 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20022 | }, | 31059 | }, |
| 20023 | .extra_temps = .{ | 31060 | .extra_temps = .{ |
| 20024 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31061 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20025 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 31062 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20026 | .unused, | 31063 | .{ .kind = .{ .rc = .sse } }, |
| 20027 | .unused, | 31064 | .{ .kind = .{ .rc = .sse } }, |
| 20028 | .unused, | 31065 | .unused, |
| 20029 | .unused, | 31066 | .unused, |
| 20030 | .unused, | 31067 | .unused, |
| ... | @@ -20032,28 +31069,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20032,28 +31069,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20032 | .unused, | 31069 | .unused, |
| 20033 | }, | 31070 | }, |
| 20034 | .dst_temps = .{.mem}, | 31071 | .dst_temps = .{.mem}, |
| 20035 | .clobbers = .{ .eflags = true }, | | |
| 20036 | .each = .{ .once = &.{ | 31072 | .each = .{ .once = &.{ |
| | 31073 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31074 | .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20037 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31075 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20038 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_size), ._, ._ }, | 31076 | .{ .@"0:", .v_ps, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20039 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, | 31077 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20040 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 31078 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20041 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, | 31079 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20042 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_size), .tmp1b, ._, ._ }, | | |
| 20043 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | | |
| 20044 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 20045 | } }, | 31080 | } }, |
| 20046 | }, .{ | 31081 | }, .{ |
| 20047 | .required_features = .{ .cmov, null, null, null }, | 31082 | .required_features = .{ .sse, null, null, null }, |
| 20048 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 31083 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 20049 | .patterns = &.{ | 31084 | .patterns = &.{ |
| 20050 | .{ .src = .{ .to_mem, .none } }, | 31085 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20051 | }, | 31086 | }, |
| 20052 | .extra_temps = .{ | 31087 | .extra_temps = .{ |
| 20053 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31088 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20054 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 31089 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20055 | .unused, | 31090 | .{ .kind = .{ .rc = .sse } }, |
| 20056 | .unused, | 31091 | .{ .kind = .{ .rc = .sse } }, |
| 20057 | .unused, | 31092 | .unused, |
| 20058 | .unused, | 31093 | .unused, |
| 20059 | .unused, | 31094 | .unused, |
| ... | @@ -20061,26 +31096,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20061,26 +31096,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20061 | .unused, | 31096 | .unused, |
| 20062 | }, | 31097 | }, |
| 20063 | .dst_temps = .{.mem}, | 31098 | .dst_temps = .{.mem}, |
| 20064 | .clobbers = .{ .eflags = true }, | | |
| 20065 | .each = .{ .once = &.{ | 31099 | .each = .{ .once = &.{ |
| | 31100 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31101 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20066 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31102 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20067 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 31103 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 20068 | .{ ._, ._, .sub, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 31104 | .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20069 | .{ ._, ._s, .cmov, .tmp1w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 31105 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20070 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, | 31106 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20071 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 20072 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 31112 | .patterns = &.{ |
| 20077 | .{ .src = .{ .to_mem, .none } }, | 31113 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20078 | }, | 31114 | }, |
| 20079 | .extra_temps = .{ | 31115 | .extra_temps = .{ |
| 20080 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31116 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20081 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 31117 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20082 | .unused, | 31118 | .{ .kind = .{ .rc = .sse } }, |
| 20083 | .unused, | 31119 | .{ .kind = .{ .rc = .sse } }, |
| 20084 | .unused, | 31120 | .unused, |
| 20085 | .unused, | 31121 | .unused, |
| 20086 | .unused, | 31122 | .unused, |
| ... | @@ -20088,28 +31124,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20088,28 +31124,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20088 | .unused, | 31124 | .unused, |
| 20089 | }, | 31125 | }, |
| 20090 | .dst_temps = .{.mem}, | 31126 | .dst_temps = .{.mem}, |
| 20091 | .clobbers = .{ .eflags = true }, | | |
| 20092 | .each = .{ .once = &.{ | 31127 | .each = .{ .once = &.{ |
| | 31128 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31129 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20093 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31130 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20094 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_size), ._, ._ }, | 31131 | .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20095 | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, | 31132 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20096 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 31133 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20097 | .{ ._, ._, .neg, .tmp1d, ._, ._, ._ }, | | |
| 20098 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_size), .tmp1w, ._, ._ }, | | |
| 20099 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 20100 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 31134 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20101 | } }, | 31135 | } }, |
| 20102 | }, .{ | 31136 | }, .{ |
| 20103 | .required_features = .{ .cmov, null, null, null }, | 31137 | .required_features = .{ .sse2, null, null, null }, |
| 20104 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 31138 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 20105 | .patterns = &.{ | 31139 | .patterns = &.{ |
| 20106 | .{ .src = .{ .to_mem, .none } }, | 31140 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20107 | }, | 31141 | }, |
| 20108 | .extra_temps = .{ | 31142 | .extra_temps = .{ |
| 20109 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20110 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 31144 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20111 | .unused, | 31145 | .{ .kind = .{ .rc = .sse } }, |
| 20112 | .unused, | 31146 | .{ .kind = .{ .rc = .sse } }, |
| 20113 | .unused, | 31147 | .unused, |
| 20114 | .unused, | 31148 | .unused, |
| 20115 | .unused, | 31149 | .unused, |
| ... | @@ -20117,26 +31151,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20117,26 +31151,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20117 | .unused, | 31151 | .unused, |
| 20118 | }, | 31152 | }, |
| 20119 | .dst_temps = .{.mem}, | 31153 | .dst_temps = .{.mem}, |
| 20120 | .clobbers = .{ .eflags = true }, | | |
| 20121 | .each = .{ .once = &.{ | 31154 | .each = .{ .once = &.{ |
| | 31155 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31156 | .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20122 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31157 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20123 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 31158 | .{ .@"0:", ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 20124 | .{ ._, ._, .sub, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 31159 | .{ ._, ._pd, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20125 | .{ ._, ._s, .cmov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 31160 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20126 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, | 31161 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20127 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | | |
| 20128 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .patterns = &.{ | 31167 | .patterns = &.{ |
| 20133 | .{ .src = .{ .to_mem, .none } }, | 31168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20134 | }, | 31169 | }, |
| 20135 | .extra_temps = .{ | 31170 | .extra_temps = .{ |
| 20136 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31171 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20137 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 31172 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20138 | .unused, | 31173 | .{ .kind = .{ .rc = .sse } }, |
| 20139 | .unused, | 31174 | .{ .kind = .{ .rc = .sse } }, |
| 20140 | .unused, | 31175 | .unused, |
| 20141 | .unused, | 31176 | .unused, |
| 20142 | .unused, | 31177 | .unused, |
| ... | @@ -20144,28 +31179,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20144,28 +31179,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20144 | .unused, | 31179 | .unused, |
| 20145 | }, | 31180 | }, |
| 20146 | .dst_temps = .{.mem}, | 31181 | .dst_temps = .{.mem}, |
| 20147 | .clobbers = .{ .eflags = true }, | | |
| 20148 | .each = .{ .once = &.{ | 31182 | .each = .{ .once = &.{ |
| | 31183 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31184 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20149 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31185 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20150 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, | 31186 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20151 | .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, | 31187 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20152 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 31188 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20153 | .{ ._, ._, .neg, .tmp1d, ._, ._, ._ }, | | |
| 20154 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_size), .tmp1d, ._, ._ }, | | |
| 20155 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | | |
| 20156 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 31189 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20157 | } }, | 31190 | } }, |
| 20158 | }, .{ | 31191 | }, .{ |
| 20159 | .required_features = .{ .@"64bit", .cmov, null, null }, | 31192 | .required_features = .{ .avx, null, null, null }, |
| 20160 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 31193 | .src_constraints = .{ .{ .multiple_scalar_any_float = .yword }, .any, .any }, |
| 20161 | .patterns = &.{ | 31194 | .patterns = &.{ |
| 20162 | .{ .src = .{ .to_mem, .none } }, | 31195 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20163 | }, | 31196 | }, |
| 20164 | .extra_temps = .{ | 31197 | .extra_temps = .{ |
| 20165 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31198 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20166 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 31199 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| 20167 | .unused, | 31200 | .{ .kind = .{ .rc = .sse } }, |
| 20168 | .unused, | 31201 | .{ .kind = .{ .rc = .sse } }, |
| 20169 | .unused, | 31202 | .unused, |
| 20170 | .unused, | 31203 | .unused, |
| 20171 | .unused, | 31204 | .unused, |
| ... | @@ -20173,27 +31206,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20173,27 +31206,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20173 | .unused, | 31206 | .unused, |
| 20174 | }, | 31207 | }, |
| 20175 | .dst_temps = .{.mem}, | 31208 | .dst_temps = .{.mem}, |
| 20176 | .clobbers = .{ .eflags = true }, | | |
| 20177 | .each = .{ .once = &.{ | 31209 | .each = .{ .once = &.{ |
| | 31210 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31211 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20178 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31212 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20179 | .{ .@"0:", ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 31213 | .{ .@"0:", .v_pd, .@"and", .tmp3y, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._ }, |
| 20180 | .{ ._, ._, .sub, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 31214 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20181 | .{ ._, ._s, .cmov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 31215 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20182 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | | |
| 20183 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | | |
| 20184 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 31216 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20185 | } }, | 31217 | } }, |
| 20186 | }, .{ | 31218 | }, .{ |
| 20187 | .required_features = .{ .@"64bit", null, null, null }, | 31219 | .required_features = .{ .sse2, null, null, null }, |
| 20188 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 31220 | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any }, |
| 20189 | .patterns = &.{ | 31221 | .patterns = &.{ |
| 20190 | .{ .src = .{ .to_mem, .none } }, | 31222 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20191 | }, | 31223 | }, |
| 20192 | .extra_temps = .{ | 31224 | .extra_temps = .{ |
| 20193 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31225 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20194 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 31226 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20195 | .unused, | 31227 | .{ .kind = .{ .rc = .sse } }, |
| 20196 | .unused, | 31228 | .{ .kind = .{ .rc = .sse } }, |
| 20197 | .unused, | 31229 | .unused, |
| 20198 | .unused, | 31230 | .unused, |
| 20199 | .unused, | 31231 | .unused, |
| ... | @@ -20201,63 +31233,1137 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20201,63 +31233,1137 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20201 | .unused, | 31233 | .unused, |
| 20202 | }, | 31234 | }, |
| 20203 | .dst_temps = .{.mem}, | 31235 | .dst_temps = .{.mem}, |
| 20204 | .clobbers = .{ .eflags = true }, | | |
| 20205 | .each = .{ .once = &.{ | 31236 | .each = .{ .once = &.{ |
| | 31237 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 31238 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20206 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 31239 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20207 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 31240 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 20208 | .{ ._, ._, .@"test", .tmp1q, .tmp1q, ._, ._ }, | 31241 | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20209 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 31242 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20210 | .{ ._, ._, .neg, .tmp1q, ._, ._, ._ }, | 31243 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20211 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_size), .tmp1q, ._, ._ }, | | |
| 20212 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | | |
| 20213 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 31244 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20214 | } }, | 31245 | } }, |
| 20215 | }, .{ | 31246 | }, .{ |
| 20216 | .required_features = .{ .@"64bit", null, null, null }, | 31247 | .required_features = .{ .sse, null, null, null }, |
| 20217 | .src_constraints = .{ .any_scalar_int, .any }, | 31248 | .src_constraints = .{ .{ .multiple_scalar_any_float = .xword }, .any, .any }, |
| 20218 | .patterns = &.{ | 31249 | .patterns = &.{ |
| 20219 | .{ .src = .{ .to_mem, .none } }, | 31250 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20220 | }, | 31251 | }, |
| 20221 | .extra_temps = .{ | 31252 | .extra_temps = .{ |
| 20222 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | | |
| 20223 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 31253 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 20224 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 31254 | .{ .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| 20225 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 31255 | .{ .kind = .{ .rc = .sse } }, |
| 20226 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 31256 | .{ .kind = .{ .rc = .sse } }, |
| | 31257 | .unused, |
| 20227 | .unused, | 31258 | .unused, |
| 20228 | .unused, | 31259 | .unused, |
| 20229 | .unused, | 31260 | .unused, |
| 20230 | .unused, | 31261 | .unused, |
| 20231 | }, | 31262 | }, |
| 20232 | .dst_temps = .{.mem}, | 31263 | .dst_temps = .{.mem}, |
| 20233 | .clobbers = .{ .eflags = true }, | | |
| 20234 | .each = .{ .once = &.{ | 31264 | .each = .{ .once = &.{ |
| 20235 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 31265 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20236 | .{ .@"0:", ._, .mov, .tmp1d, .sa(.none, .add_src0_elem_size), ._, ._ }, | 31266 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20237 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_src0_elem_size, -8), ._, ._ }, | 31267 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20238 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, | 31268 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 20239 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 31269 | .{ ._, ._ps, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, |
| 20240 | .{ .@"1:", ._, .mov, .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, | 31270 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20241 | .{ ._, ._, .xor, .tmp4q, .tmp2q, ._, ._ }, | 31271 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20242 | .{ ._, ._r, .sh, .tmp3b, .ui(1), ._, ._ }, | 31272 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20243 | .{ ._, ._, .sbb, .tmp4q, .tmp2q, ._, ._ }, | 31273 | } }, |
| 20244 | .{ ._, ._c, .set, .tmp3b, ._, ._, ._ }, | 31274 | } }) catch |err| switch (err) { |
| 20245 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, | 31275 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 20246 | .{ ._, ._, .lea, .tmp0d, .lead(.tmp0, 8), ._, ._ }, | 31276 | @tagName(air_tag), |
| 20247 | .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, | 31277 | cg.typeOf(ty_op.operand).fmt(pt), |
| 20248 | .{ ._, ._a, .j, .@"1b", ._, ._, ._ }, | 31278 | ops[0].tracking(cg), |
| 20249 | .{ ._, ._, .cmp, .tmp0d, .sa(.src0, .add_unaligned_size), ._, ._ }, | 31279 | }), |
| 20250 | .{ ._, ._b, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32361 | .patterns = &.{ |
| 20256 | .{ .src = .{ .to_sse, .none } }, | 32362 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20257 | }, | 32363 | }, |
| 20258 | .extra_temps = .{ | 32364 | .extra_temps = .{ |
| 20259 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32367 | .unused, |
| 20262 | .unused, | 32368 | .unused, |
| 20263 | .unused, | 32369 | .unused, |
| ... | @@ -20269,17 +32375,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20269,17 +32375,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20269 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32375 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20270 | .each = .{ .once = &.{ | 32376 | .each = .{ .once = &.{ |
| 20271 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 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 | .required_features = .{ .sse, null, null, null }, | 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 | .patterns = &.{ | 32383 | .patterns = &.{ |
| 20278 | .{ .src = .{ .to_mut_sse, .none } }, | 32384 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20279 | }, | 32385 | }, |
| 20280 | .extra_temps = .{ | 32386 | .extra_temps = .{ |
| 20281 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32389 | .unused, |
| 20284 | .unused, | 32390 | .unused, |
| 20285 | .unused, | 32391 | .unused, |
| ... | @@ -20291,17 +32397,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20291,17 +32397,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20291 | .dst_temps = .{.{ .ref = .src0 }}, | 32397 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20292 | .each = .{ .once = &.{ | 32398 | .each = .{ .once = &.{ |
| 20293 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32399 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20294 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 32400 | .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20295 | } }, | 32401 | } }, |
| 20296 | }, .{ | 32402 | }, .{ |
| 20297 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32405 | .patterns = &.{ |
| 20300 | .{ .src = .{ .to_sse, .none } }, | 32406 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20301 | }, | 32407 | }, |
| 20302 | .extra_temps = .{ | 32408 | .extra_temps = .{ |
| 20303 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32411 | .unused, |
| 20306 | .unused, | 32412 | .unused, |
| 20307 | .unused, | 32413 | .unused, |
| ... | @@ -20313,17 +32419,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20313,17 +32419,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20313 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32419 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20314 | .each = .{ .once = &.{ | 32420 | .each = .{ .once = &.{ |
| 20315 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32427 | .patterns = &.{ |
| 20322 | .{ .src = .{ .to_sse, .none } }, | 32428 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20323 | }, | 32429 | }, |
| 20324 | .extra_temps = .{ | 32430 | .extra_temps = .{ |
| 20325 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32433 | .unused, |
| 20328 | .unused, | 32434 | .unused, |
| 20329 | .unused, | 32435 | .unused, |
| ... | @@ -20335,17 +32441,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20335,17 +32441,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20335 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32441 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20336 | .each = .{ .once = &.{ | 32442 | .each = .{ .once = &.{ |
| 20337 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 32449 | .patterns = &.{ |
| 20344 | .{ .src = .{ .to_mut_sse, .none } }, | 32450 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20345 | }, | 32451 | }, |
| 20346 | .extra_temps = .{ | 32452 | .extra_temps = .{ |
| 20347 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32455 | .unused, |
| 20350 | .unused, | 32456 | .unused, |
| 20351 | .unused, | 32457 | .unused, |
| ... | @@ -20357,17 +32463,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20357,17 +32463,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20357 | .dst_temps = .{.{ .ref = .src0 }}, | 32463 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20358 | .each = .{ .once = &.{ | 32464 | .each = .{ .once = &.{ |
| 20359 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32465 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20360 | .{ ._, ._pd, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 32466 | .{ ._, ._pd, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20361 | } }, | 32467 | } }, |
| 20362 | }, .{ | 32468 | }, .{ |
| 20363 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32471 | .patterns = &.{ |
| 20366 | .{ .src = .{ .to_sse, .none } }, | 32472 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20367 | }, | 32473 | }, |
| 20368 | .extra_temps = .{ | 32474 | .extra_temps = .{ |
| 20369 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32477 | .unused, |
| 20372 | .unused, | 32478 | .unused, |
| 20373 | .unused, | 32479 | .unused, |
| ... | @@ -20379,14 +32485,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20379,14 +32485,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20379 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32485 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20380 | .each = .{ .once = &.{ | 32486 | .each = .{ .once = &.{ |
| 20381 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 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 | .required_features = .{ .x87, null, null, null }, | 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 | .patterns = &.{ | 32493 | .patterns = &.{ |
| 20388 | .{ .src = .{ .mem, .none } }, | 32494 | .{ .src = .{ .mem, .none, .none } }, |
| 20389 | .{ .src = .{ .to_x87, .none } }, | 32495 | .{ .src = .{ .to_x87, .none, .none } }, |
| 20390 | }, | 32496 | }, |
| 20391 | .extra_temps = .{ | 32497 | .extra_temps = .{ |
| 20392 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 32498 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | @@ -20402,18 +32508,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20402,18 +32508,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20402 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }}, | 32508 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .x87 } }}, |
| 20403 | .each = .{ .once = &.{ | 32509 | .each = .{ .once = &.{ |
| 20404 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 32510 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 20405 | .{ ._, .f_, .abs, ._, ._, ._, ._ }, | 32511 | .{ ._, .f_, .chs, ._, ._, ._, ._ }, |
| 20406 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 32512 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 20407 | } }, | 32513 | } }, |
| 20408 | }, .{ | 32514 | }, .{ |
| 20409 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32517 | .patterns = &.{ |
| 20412 | .{ .src = .{ .to_sse, .none } }, | 32518 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20413 | }, | 32519 | }, |
| 20414 | .extra_temps = .{ | 32520 | .extra_temps = .{ |
| 20415 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32523 | .unused, |
| 20418 | .unused, | 32524 | .unused, |
| 20419 | .unused, | 32525 | .unused, |
| ... | @@ -20425,17 +32531,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20425,17 +32531,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20425 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32531 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20426 | .each = .{ .once = &.{ | 32532 | .each = .{ .once = &.{ |
| 20427 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32533 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20428 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, | 32534 | .{ ._, .vp_, .xor, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 20429 | } }, | 32535 | } }, |
| 20430 | }, .{ | 32536 | }, .{ |
| 20431 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 32539 | .patterns = &.{ |
| 20434 | .{ .src = .{ .to_mut_sse, .none } }, | 32540 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20435 | }, | 32541 | }, |
| 20436 | .extra_temps = .{ | 32542 | .extra_temps = .{ |
| 20437 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32545 | .unused, |
| 20440 | .unused, | 32546 | .unused, |
| 20441 | .unused, | 32547 | .unused, |
| ... | @@ -20447,17 +32553,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20447,17 +32553,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20447 | .dst_temps = .{.{ .ref = .src0 }}, | 32553 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20448 | .each = .{ .once = &.{ | 32554 | .each = .{ .once = &.{ |
| 20449 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32555 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20450 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 32556 | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20451 | } }, | 32557 | } }, |
| 20452 | }, .{ | 32558 | }, .{ |
| 20453 | .required_features = .{ .sse, null, null, null }, | 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 | .patterns = &.{ | 32561 | .patterns = &.{ |
| 20456 | .{ .src = .{ .to_mut_sse, .none } }, | 32562 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 20457 | }, | 32563 | }, |
| 20458 | .extra_temps = .{ | 32564 | .extra_temps = .{ |
| 20459 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32567 | .unused, |
| 20462 | .unused, | 32568 | .unused, |
| 20463 | .unused, | 32569 | .unused, |
| ... | @@ -20469,17 +32575,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20469,17 +32575,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20469 | .dst_temps = .{.{ .ref = .src0 }}, | 32575 | .dst_temps = .{.{ .ref = .src0 }}, |
| 20470 | .each = .{ .once = &.{ | 32576 | .each = .{ .once = &.{ |
| 20471 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32577 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20472 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 32578 | .{ ._, ._ps, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 20473 | } }, | 32579 | } }, |
| 20474 | }, .{ | 32580 | }, .{ |
| 20475 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 32583 | .patterns = &.{ |
| 20478 | .{ .src = .{ .to_sse, .none } }, | 32584 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20479 | }, | 32585 | }, |
| 20480 | .extra_temps = .{ | 32586 | .extra_temps = .{ |
| 20481 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32589 | .unused, |
| 20484 | .unused, | 32590 | .unused, |
| 20485 | .unused, | 32591 | .unused, |
| ... | @@ -20491,17 +32597,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20491,17 +32597,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20491 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32597 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20492 | .each = .{ .once = &.{ | 32598 | .each = .{ .once = &.{ |
| 20493 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32599 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20494 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, | 32600 | .{ ._, .vp_, .xor, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 20495 | } }, | 32601 | } }, |
| 20496 | }, .{ | 32602 | }, .{ |
| 20497 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32605 | .patterns = &.{ |
| 20500 | .{ .src = .{ .to_sse, .none } }, | 32606 | .{ .src = .{ .to_sse, .none, .none } }, |
| 20501 | }, | 32607 | }, |
| 20502 | .extra_temps = .{ | 32608 | .extra_temps = .{ |
| 20503 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 32611 | .unused, |
| 20506 | .unused, | 32612 | .unused, |
| 20507 | .unused, | 32613 | .unused, |
| ... | @@ -20513,17 +32619,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20513,17 +32619,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20513 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 32619 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 20514 | .each = .{ .once = &.{ | 32620 | .each = .{ .once = &.{ |
| 20515 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32627 | .patterns = &.{ |
| 20522 | .{ .src = .{ .to_mem, .none } }, | 32628 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20523 | }, | 32629 | }, |
| 20524 | .extra_temps = .{ | 32630 | .extra_temps = .{ |
| 20525 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32633 | .{ .kind = .{ .rc = .sse } }, |
| 20528 | .{ .kind = .{ .rc = .sse } }, | 32634 | .{ .kind = .{ .rc = .sse } }, |
| 20529 | .unused, | 32635 | .unused, |
| ... | @@ -20537,20 +32643,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20537,20 +32643,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20537 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32643 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20538 | .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, | 32644 | .{ ._, .v_ps, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20539 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 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 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, | 32647 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20542 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 32648 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20543 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32649 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20544 | } }, | 32650 | } }, |
| 20545 | }, .{ | 32651 | }, .{ |
| 20546 | .required_features = .{ .sse, null, null, null }, | 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 | .patterns = &.{ | 32654 | .patterns = &.{ |
| 20549 | .{ .src = .{ .to_mem, .none } }, | 32655 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20550 | }, | 32656 | }, |
| 20551 | .extra_temps = .{ | 32657 | .extra_temps = .{ |
| 20552 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32660 | .{ .kind = .{ .rc = .sse } }, |
| 20555 | .{ .kind = .{ .rc = .sse } }, | 32661 | .{ .kind = .{ .rc = .sse } }, |
| 20556 | .unused, | 32662 | .unused, |
| ... | @@ -20565,20 +32671,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20565,20 +32671,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20565 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, | 32671 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20566 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 32672 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20567 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 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 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | 32675 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20570 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 32676 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20571 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20572 | } }, | 32678 | } }, |
| 20573 | }, .{ | 32679 | }, .{ |
| 20574 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32682 | .patterns = &.{ |
| 20577 | .{ .src = .{ .to_mem, .none } }, | 32683 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20578 | }, | 32684 | }, |
| 20579 | .extra_temps = .{ | 32685 | .extra_temps = .{ |
| 20580 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32688 | .{ .kind = .{ .rc = .sse } }, |
| 20583 | .{ .kind = .{ .rc = .sse } }, | 32689 | .{ .kind = .{ .rc = .sse } }, |
| 20584 | .unused, | 32690 | .unused, |
| ... | @@ -20592,20 +32698,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20592,20 +32698,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20592 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32698 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20593 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, | 32699 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20594 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 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 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, | 32702 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20597 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 32703 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20598 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32704 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20599 | } }, | 32705 | } }, |
| 20600 | }, .{ | 32706 | }, .{ |
| 20601 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 32709 | .patterns = &.{ |
| 20604 | .{ .src = .{ .to_mem, .none } }, | 32710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20605 | }, | 32711 | }, |
| 20606 | .extra_temps = .{ | 32712 | .extra_temps = .{ |
| 20607 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32715 | .{ .kind = .{ .rc = .sse } }, |
| 20610 | .{ .kind = .{ .rc = .sse } }, | 32716 | .{ .kind = .{ .rc = .sse } }, |
| 20611 | .unused, | 32717 | .unused, |
| ... | @@ -20620,20 +32726,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20620,20 +32726,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20620 | .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, | 32726 | .{ ._, ._pd, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20621 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 32727 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20622 | .{ .@"0:", ._pd, .mova, .tmp3x, .tmp2x, ._, ._ }, | 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 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | 32730 | .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20625 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 32731 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20626 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32732 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20627 | } }, | 32733 | } }, |
| 20628 | }, .{ | 32734 | }, .{ |
| 20629 | .required_features = .{ .avx2, null, null, null }, | 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 | .patterns = &.{ | 32737 | .patterns = &.{ |
| 20632 | .{ .src = .{ .to_mem, .none } }, | 32738 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20633 | }, | 32739 | }, |
| 20634 | .extra_temps = .{ | 32740 | .extra_temps = .{ |
| 20635 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32743 | .{ .kind = .{ .rc = .sse } }, |
| 20638 | .{ .kind = .{ .rc = .sse } }, | 32744 | .{ .kind = .{ .rc = .sse } }, |
| 20639 | .unused, | 32745 | .unused, |
| ... | @@ -20647,20 +32753,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20647,20 +32753,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20647 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32753 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20648 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, | 32754 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20649 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 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 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, | 32757 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20652 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 32758 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20653 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32759 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20654 | } }, | 32760 | } }, |
| 20655 | }, .{ | 32761 | }, .{ |
| 20656 | .required_features = .{ .avx, null, null, null }, | 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 | .patterns = &.{ | 32764 | .patterns = &.{ |
| 20659 | .{ .src = .{ .to_mem, .none } }, | 32765 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20660 | }, | 32766 | }, |
| 20661 | .extra_temps = .{ | 32767 | .extra_temps = .{ |
| 20662 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32770 | .{ .kind = .{ .rc = .sse } }, |
| 20665 | .{ .kind = .{ .rc = .sse } }, | 32771 | .{ .kind = .{ .rc = .sse } }, |
| 20666 | .unused, | 32772 | .unused, |
| ... | @@ -20674,20 +32780,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20674,20 +32780,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20674 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 32780 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 20675 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, | 32781 | .{ ._, .v_pd, .mova, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 20676 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 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 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, | 32784 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_size), .tmp3y, ._, ._ }, |
| 20679 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 32785 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 20680 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32786 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20681 | } }, | 32787 | } }, |
| 20682 | }, .{ | 32788 | }, .{ |
| 20683 | .required_features = .{ .sse2, null, null, null }, | 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 | .patterns = &.{ | 32791 | .patterns = &.{ |
| 20686 | .{ .src = .{ .to_mem, .none } }, | 32792 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20687 | }, | 32793 | }, |
| 20688 | .extra_temps = .{ | 32794 | .extra_temps = .{ |
| 20689 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32797 | .{ .kind = .{ .rc = .sse } }, |
| 20692 | .{ .kind = .{ .rc = .sse } }, | 32798 | .{ .kind = .{ .rc = .sse } }, |
| 20693 | .unused, | 32799 | .unused, |
| ... | @@ -20702,20 +32808,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20702,20 +32808,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20702 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, | 32808 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20703 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 32809 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20704 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, | 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 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | 32812 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20707 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 32813 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32814 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 20709 | } }, | 32815 | } }, |
| 20710 | }, .{ | 32816 | }, .{ |
| 20711 | .required_features = .{ .sse, null, null, null }, | 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 | .patterns = &.{ | 32819 | .patterns = &.{ |
| 20714 | .{ .src = .{ .to_mem, .none } }, | 32820 | .{ .src = .{ .to_mem, .none, .none } }, |
| 20715 | }, | 32821 | }, |
| 20716 | .extra_temps = .{ | 32822 | .extra_temps = .{ |
| 20717 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .kind = .{ .rc = .sse } }, | 32825 | .{ .kind = .{ .rc = .sse } }, |
| 20720 | .{ .kind = .{ .rc = .sse } }, | 32826 | .{ .kind = .{ .rc = .sse } }, |
| 20721 | .unused, | 32827 | .unused, |
| ... | @@ -20730,7 +32836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20730,7 +32836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20730 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, | 32836 | .{ ._, ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 20731 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 32837 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 20732 | .{ .@"0:", ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 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 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, | 32840 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_size), .tmp3x, ._, ._ }, |
| 20735 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 32841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 20736 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 32842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| ... | @@ -20738,12 +32844,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20738,12 +32844,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20738 | } }) catch |err| switch (err) { | 32844 | } }) catch |err| switch (err) { |
| 20739 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ | 32845 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| 20740 | @tagName(air_tag), | 32846 | @tagName(air_tag), |
| 20741 | cg.typeOf(ty_op.operand).fmt(pt), | 32847 | cg.typeOf(un_op).fmt(pt), |
| 20742 | ops[0].tracking(cg), | 32848 | ops[0].tracking(cg), |
| 20743 | }), | 32849 | }), |
| 20744 | else => |e| return e, | 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 | .cmp_lt, | 32855 | .cmp_lt, |
| ... | @@ -20772,9 +32878,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20772,9 +32878,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20772 | }) { | 32878 | }) { |
| 20773 | inline false, true => |strict| comptime &.{ .{ | 32879 | inline false, true => |strict| comptime &.{ .{ |
| 20774 | .required_features = .{ .f16c, null, null, null }, | 32880 | .required_features = .{ .f16c, null, null, null }, |
| 20775 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, | 32881 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 20776 | .patterns = &.{ | 32882 | .patterns = &.{ |
| 20777 | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, | 32883 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20778 | }, | 32884 | }, |
| 20779 | .extra_temps = .{ | 32885 | .extra_temps = .{ |
| 20780 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 32886 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| ... | @@ -20799,9 +32905,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20799,9 +32905,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20799 | } }, | 32905 | } }, |
| 20800 | }, .{ | 32906 | }, .{ |
| 20801 | .required_features = .{ .sse, null, null, null }, | 32907 | .required_features = .{ .sse, null, null, null }, |
| 20802 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, | 32908 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 20803 | .patterns = &.{ | 32909 | .patterns = &.{ |
| 20804 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 32910 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 20805 | }, | 32911 | }, |
| 20806 | .call_frame = .{ .alignment = .@"16" }, | 32912 | .call_frame = .{ .alignment = .@"16" }, |
| 20807 | .extra_temps = .{ | 32913 | .extra_temps = .{ |
| ... | @@ -20826,10 +32932,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20826,10 +32932,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20826 | } }, | 32932 | } }, |
| 20827 | }, .{ | 32933 | }, .{ |
| 20828 | .required_features = .{ .avx, null, null, null }, | 32934 | .required_features = .{ .avx, null, null, null }, |
| 20829 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, | 32935 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 20830 | .patterns = &.{ | 32936 | .patterns = &.{ |
| 20831 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 32937 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20832 | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, | 32938 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20833 | }, | 32939 | }, |
| 20834 | .dst_temps = .{.{ .cc = switch (strict) { | 32940 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20835 | true => .a, | 32941 | true => .a, |
| ... | @@ -20841,10 +32947,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20841,10 +32947,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20841 | } }, | 32947 | } }, |
| 20842 | }, .{ | 32948 | }, .{ |
| 20843 | .required_features = .{ .sse, null, null, null }, | 32949 | .required_features = .{ .sse, null, null, null }, |
| 20844 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, | 32950 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 20845 | .patterns = &.{ | 32951 | .patterns = &.{ |
| 20846 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 32952 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20847 | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, | 32953 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20848 | }, | 32954 | }, |
| 20849 | .dst_temps = .{.{ .cc = switch (strict) { | 32955 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20850 | true => .a, | 32956 | true => .a, |
| ... | @@ -20856,10 +32962,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20856,10 +32962,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20856 | } }, | 32962 | } }, |
| 20857 | }, .{ | 32963 | }, .{ |
| 20858 | .required_features = .{ .avx, null, null, null }, | 32964 | .required_features = .{ .avx, null, null, null }, |
| 20859 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 32965 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20860 | .patterns = &.{ | 32966 | .patterns = &.{ |
| 20861 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 32967 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20862 | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, | 32968 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20863 | }, | 32969 | }, |
| 20864 | .dst_temps = .{.{ .cc = switch (strict) { | 32970 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20865 | true => .a, | 32971 | true => .a, |
| ... | @@ -20871,10 +32977,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20871,10 +32977,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20871 | } }, | 32977 | } }, |
| 20872 | }, .{ | 32978 | }, .{ |
| 20873 | .required_features = .{ .sse2, null, null, null }, | 32979 | .required_features = .{ .sse2, null, null, null }, |
| 20874 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 32980 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20875 | .patterns = &.{ | 32981 | .patterns = &.{ |
| 20876 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 32982 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20877 | .{ .src = .{ .to_sse, .to_sse }, .commute = .{ 0, 1 } }, | 32983 | .{ .src = .{ .to_sse, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 20878 | }, | 32984 | }, |
| 20879 | .dst_temps = .{.{ .cc = switch (strict) { | 32985 | .dst_temps = .{.{ .cc = switch (strict) { |
| 20880 | true => .a, | 32986 | true => .a, |
| ... | @@ -20886,13 +32992,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20886,13 +32992,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20886 | } }, | 32992 | } }, |
| 20887 | }, .{ | 32993 | }, .{ |
| 20888 | .required_features = .{ .x87, .cmov, null, null }, | 32994 | .required_features = .{ .x87, .cmov, null, null }, |
| 20889 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 32995 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20890 | .patterns = &.{ | 32996 | .patterns = &.{ |
| 20891 | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, | 32997 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 20892 | }, | 32998 | }, |
| 20893 | .extra_temps = .{ | 32999 | .extra_temps = .{ |
| 20894 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33000 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 20895 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33001 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 20896 | .unused, | 33002 | .unused, |
| 20897 | .unused, | 33003 | .unused, |
| 20898 | .unused, | 33004 | .unused, |
| ... | @@ -20914,13 +33020,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20914,13 +33020,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20914 | } }, | 33020 | } }, |
| 20915 | }, .{ | 33021 | }, .{ |
| 20916 | .required_features = .{ .sahf, .x87, null, null }, | 33022 | .required_features = .{ .sahf, .x87, null, null }, |
| 20917 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33023 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20918 | .patterns = &.{ | 33024 | .patterns = &.{ |
| 20919 | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, | 33025 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 20920 | }, | 33026 | }, |
| 20921 | .extra_temps = .{ | 33027 | .extra_temps = .{ |
| 20922 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33028 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 20923 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33029 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 20924 | .{ .type = .u8, .kind = .{ .reg = .ah } }, | 33030 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 20925 | .unused, | 33031 | .unused, |
| 20926 | .unused, | 33032 | .unused, |
| ... | @@ -20943,13 +33049,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20943,13 +33049,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20943 | } }, | 33049 | } }, |
| 20944 | }, .{ | 33050 | }, .{ |
| 20945 | .required_features = .{ .x87, null, null, null }, | 33051 | .required_features = .{ .x87, null, null, null }, |
| 20946 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33052 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 20947 | .patterns = &.{ | 33053 | .patterns = &.{ |
| 20948 | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, | 33054 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 20949 | }, | 33055 | }, |
| 20950 | .extra_temps = .{ | 33056 | .extra_temps = .{ |
| 20951 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33057 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 20952 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33058 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 20953 | .{ .type = .u8, .kind = .{ .reg = .ah } }, | 33059 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 20954 | .unused, | 33060 | .unused, |
| 20955 | .unused, | 33061 | .unused, |
| ... | @@ -20975,10 +33081,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -20975,10 +33081,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 20975 | } }, | 33081 | } }, |
| 20976 | }, .{ | 33082 | }, .{ |
| 20977 | .required_features = .{ .x87, .cmov, null, null }, | 33083 | .required_features = .{ .x87, .cmov, null, null }, |
| 20978 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33084 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 20979 | .patterns = &.{ | 33085 | .patterns = &.{ |
| 20980 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 33086 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 20981 | .{ .src = .{ .to_x87, .to_x87 }, .commute = .{ 0, 1 } }, | 33087 | .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } }, |
| 20982 | }, | 33088 | }, |
| 20983 | .extra_temps = .{ | 33089 | .extra_temps = .{ |
| 20984 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33090 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | @@ -21002,9 +33108,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21002,9 +33108,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21002 | } }, | 33108 | } }, |
| 21003 | }, .{ | 33109 | }, .{ |
| 21004 | .required_features = .{ .sahf, .x87, null, null }, | 33110 | .required_features = .{ .sahf, .x87, null, null }, |
| 21005 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33111 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21006 | .patterns = &.{ | 33112 | .patterns = &.{ |
| 21007 | .{ .src = .{ .mem, .mem }, .commute = .{ 0, 1 } }, | 33113 | .{ .src = .{ .mem, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21008 | }, | 33114 | }, |
| 21009 | .extra_temps = .{ | 33115 | .extra_temps = .{ |
| 21010 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33116 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21031,10 +33137,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21031,10 +33137,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21031 | } }, | 33137 | } }, |
| 21032 | }, .{ | 33138 | }, .{ |
| 21033 | .required_features = .{ .sahf, .x87, null, null }, | 33139 | .required_features = .{ .sahf, .x87, null, null }, |
| 21034 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33140 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21035 | .patterns = &.{ | 33141 | .patterns = &.{ |
| 21036 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 33142 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21037 | .{ .src = .{ .to_x87, .to_x87 }, .commute = .{ 0, 1 } }, | 33143 | .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } }, |
| 21038 | }, | 33144 | }, |
| 21039 | .extra_temps = .{ | 33145 | .extra_temps = .{ |
| 21040 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33146 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21060,9 +33166,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21060,9 +33166,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21060 | } }, | 33166 | } }, |
| 21061 | }, .{ | 33167 | }, .{ |
| 21062 | .required_features = .{ .x87, null, null, null }, | 33168 | .required_features = .{ .x87, null, null, null }, |
| 21063 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33169 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21064 | .patterns = &.{ | 33170 | .patterns = &.{ |
| 21065 | .{ .src = .{ .mem, .mem }, .commute = .{ 0, 1 } }, | 33171 | .{ .src = .{ .mem, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21066 | }, | 33172 | }, |
| 21067 | .extra_temps = .{ | 33173 | .extra_temps = .{ |
| 21068 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33174 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21092,10 +33198,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21092,10 +33198,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21092 | } }, | 33198 | } }, |
| 21093 | }, .{ | 33199 | }, .{ |
| 21094 | .required_features = .{ .x87, null, null, null }, | 33200 | .required_features = .{ .x87, null, null, null }, |
| 21095 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33201 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21096 | .patterns = &.{ | 33202 | .patterns = &.{ |
| 21097 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 33203 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21098 | .{ .src = .{ .to_x87, .to_x87 }, .commute = .{ 0, 1 } }, | 33204 | .{ .src = .{ .to_x87, .to_x87, .none }, .commute = .{ 0, 1 } }, |
| 21099 | }, | 33205 | }, |
| 21100 | .extra_temps = .{ | 33206 | .extra_temps = .{ |
| 21101 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33207 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21124,9 +33230,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21124,9 +33230,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21124 | } }, | 33230 | } }, |
| 21125 | }, .{ | 33231 | }, .{ |
| 21126 | .required_features = .{ .sse, null, null, null }, | 33232 | .required_features = .{ .sse, null, null, null }, |
| 21127 | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword } }, | 33233 | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any }, |
| 21128 | .patterns = &.{ | 33234 | .patterns = &.{ |
| 21129 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 33235 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 21130 | }, | 33236 | }, |
| 21131 | .call_frame = .{ .alignment = .@"16" }, | 33237 | .call_frame = .{ .alignment = .@"16" }, |
| 21132 | .extra_temps = .{ | 33238 | .extra_temps = .{ |
| ... | @@ -21204,15 +33310,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21204,15 +33310,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21204 | switch (Condition.fromCompareOperatorUnsigned(cmp_op)) { | 33310 | switch (Condition.fromCompareOperatorUnsigned(cmp_op)) { |
| 21205 | else => unreachable, | 33311 | else => unreachable, |
| 21206 | inline .e, .ne => |cc| comptime &.{.{ | 33312 | inline .e, .ne => |cc| comptime &.{.{ |
| 21207 | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte } }, | 33313 | .src_constraints = .{ .{ .size = .byte }, .{ .size = .byte }, .any }, |
| 21208 | .patterns = &.{ | 33314 | .patterns = &.{ |
| 21209 | .{ .src = .{ .mem, .imm8 } }, | 33315 | .{ .src = .{ .mem, .imm8, .none } }, |
| 21210 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, | 33316 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21211 | .{ .src = .{ .to_gpr, .imm8 } }, | 33317 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 21212 | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, | 33318 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 21213 | .{ .src = .{ .mem, .to_gpr } }, | 33319 | .{ .src = .{ .mem, .to_gpr, .none } }, |
| 21214 | .{ .src = .{ .to_gpr, .mem }, .commute = .{ 0, 1 } }, | 33320 | .{ .src = .{ .to_gpr, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21215 | .{ .src = .{ .to_gpr, .to_gpr } }, | 33321 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 21216 | }, | 33322 | }, |
| 21217 | .dst_temps = .{.{ .rc = .general_purpose }}, | 33323 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 21218 | .clobbers = .{ .eflags = true }, | 33324 | .clobbers = .{ .eflags = true }, |
| ... | @@ -21254,9 +33360,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21254,9 +33360,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21254 | }) { | 33360 | }) { |
| 21255 | inline false, true => |optimized| comptime &.{ .{ | 33361 | inline false, true => |optimized| comptime &.{ .{ |
| 21256 | .required_features = .{ .f16c, null, null, null }, | 33362 | .required_features = .{ .f16c, null, null, null }, |
| 21257 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, | 33363 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 21258 | .patterns = &.{ | 33364 | .patterns = &.{ |
| 21259 | .{ .src = .{ .to_sse, .to_sse } }, | 33365 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21260 | }, | 33366 | }, |
| 21261 | .extra_temps = .{ | 33367 | .extra_temps = .{ |
| 21262 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 33368 | .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| ... | @@ -21277,13 +33383,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21277,13 +33383,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21277 | .each = .{ .once = &.{ | 33383 | .each = .{ .once = &.{ |
| 21278 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, | 33384 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 21279 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ }, | 33385 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src1q, ._, ._ }, |
| 21280 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, | 33386 | .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1d, ._, ._ }, |
| 21281 | } }, | 33387 | } }, |
| 21282 | }, .{ | 33388 | }, .{ |
| 21283 | .required_features = .{ .sse, null, null, null }, | 33389 | .required_features = .{ .sse, null, null, null }, |
| 21284 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word } }, | 33390 | .src_constraints = .{ .{ .float = .word }, .{ .float = .word }, .any }, |
| 21285 | .patterns = &.{ | 33391 | .patterns = &.{ |
| 21286 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 33392 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 21287 | }, | 33393 | }, |
| 21288 | .call_frame = .{ .alignment = .@"16" }, | 33394 | .call_frame = .{ .alignment = .@"16" }, |
| 21289 | .extra_temps = .{ | 33395 | .extra_temps = .{ |
| ... | @@ -21305,11 +33411,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21305,11 +33411,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21305 | } }, | 33411 | } }, |
| 21306 | }, .{ | 33412 | }, .{ |
| 21307 | .required_features = .{ .avx, null, null, null }, | 33413 | .required_features = .{ .avx, null, null, null }, |
| 21308 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, | 33414 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 21309 | .patterns = &.{ | 33415 | .patterns = &.{ |
| 21310 | .{ .src = .{ .to_sse, .mem } }, | 33416 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21311 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 33417 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21312 | .{ .src = .{ .to_sse, .to_sse } }, | 33418 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21313 | }, | 33419 | }, |
| 21314 | .dst_temps = .{.{ .cc = switch (optimized) { | 33420 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21315 | false => .z_and_np, | 33421 | false => .z_and_np, |
| ... | @@ -21321,11 +33427,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21321,11 +33427,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21321 | } }, | 33427 | } }, |
| 21322 | }, .{ | 33428 | }, .{ |
| 21323 | .required_features = .{ .sse, null, null, null }, | 33429 | .required_features = .{ .sse, null, null, null }, |
| 21324 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword } }, | 33430 | .src_constraints = .{ .{ .float = .dword }, .{ .float = .dword }, .any }, |
| 21325 | .patterns = &.{ | 33431 | .patterns = &.{ |
| 21326 | .{ .src = .{ .to_sse, .mem } }, | 33432 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21327 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 33433 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21328 | .{ .src = .{ .to_sse, .to_sse } }, | 33434 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21329 | }, | 33435 | }, |
| 21330 | .dst_temps = .{.{ .cc = switch (optimized) { | 33436 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21331 | false => .z_and_np, | 33437 | false => .z_and_np, |
| ... | @@ -21337,11 +33443,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21337,11 +33443,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21337 | } }, | 33443 | } }, |
| 21338 | }, .{ | 33444 | }, .{ |
| 21339 | .required_features = .{ .avx, null, null, null }, | 33445 | .required_features = .{ .avx, null, null, null }, |
| 21340 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33446 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21341 | .patterns = &.{ | 33447 | .patterns = &.{ |
| 21342 | .{ .src = .{ .to_sse, .mem } }, | 33448 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21343 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 33449 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21344 | .{ .src = .{ .to_sse, .to_sse } }, | 33450 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21345 | }, | 33451 | }, |
| 21346 | .dst_temps = .{.{ .cc = switch (optimized) { | 33452 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21347 | false => .z_and_np, | 33453 | false => .z_and_np, |
| ... | @@ -21353,11 +33459,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21353,11 +33459,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21353 | } }, | 33459 | } }, |
| 21354 | }, .{ | 33460 | }, .{ |
| 21355 | .required_features = .{ .sse2, null, null, null }, | 33461 | .required_features = .{ .sse2, null, null, null }, |
| 21356 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33462 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21357 | .patterns = &.{ | 33463 | .patterns = &.{ |
| 21358 | .{ .src = .{ .to_sse, .mem } }, | 33464 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 21359 | .{ .src = .{ .mem, .to_sse }, .commute = .{ 0, 1 } }, | 33465 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 21360 | .{ .src = .{ .to_sse, .to_sse } }, | 33466 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 21361 | }, | 33467 | }, |
| 21362 | .dst_temps = .{.{ .cc = switch (optimized) { | 33468 | .dst_temps = .{.{ .cc = switch (optimized) { |
| 21363 | false => .z_and_np, | 33469 | false => .z_and_np, |
| ... | @@ -21369,13 +33475,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21369,13 +33475,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21369 | } }, | 33475 | } }, |
| 21370 | }, .{ | 33476 | }, .{ |
| 21371 | .required_features = .{ .x87, .cmov, null, null }, | 33477 | .required_features = .{ .x87, .cmov, null, null }, |
| 21372 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33478 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21373 | .patterns = &.{ | 33479 | .patterns = &.{ |
| 21374 | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, | 33480 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 21375 | }, | 33481 | }, |
| 21376 | .extra_temps = .{ | 33482 | .extra_temps = .{ |
| 21377 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33483 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 21378 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33484 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 21379 | .unused, | 33485 | .unused, |
| 21380 | .unused, | 33486 | .unused, |
| 21381 | .unused, | 33487 | .unused, |
| ... | @@ -21397,13 +33503,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21397,13 +33503,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21397 | } }, | 33503 | } }, |
| 21398 | }, .{ | 33504 | }, .{ |
| 21399 | .required_features = .{ .sahf, .x87, null, null }, | 33505 | .required_features = .{ .sahf, .x87, null, null }, |
| 21400 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33506 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21401 | .patterns = &.{ | 33507 | .patterns = &.{ |
| 21402 | .{ .src = .{ .to_mem, .to_mem }, .commute = .{ 0, 1 } }, | 33508 | .{ .src = .{ .to_mem, .to_mem, .none }, .commute = .{ 0, 1 } }, |
| 21403 | }, | 33509 | }, |
| 21404 | .extra_temps = .{ | 33510 | .extra_temps = .{ |
| 21405 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33511 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 21406 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33512 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 21407 | .{ .type = .u8, .kind = .{ .reg = .ah } }, | 33513 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 21408 | .unused, | 33514 | .unused, |
| 21409 | .unused, | 33515 | .unused, |
| ... | @@ -21426,13 +33532,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21426,13 +33532,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21426 | } }, | 33532 | } }, |
| 21427 | }, .{ | 33533 | }, .{ |
| 21428 | .required_features = .{ .x87, null, null, null }, | 33534 | .required_features = .{ .x87, null, null, null }, |
| 21429 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword } }, | 33535 | .src_constraints = .{ .{ .float = .qword }, .{ .float = .qword }, .any }, |
| 21430 | .patterns = &.{ | 33536 | .patterns = &.{ |
| 21431 | .{ .src = .{ .to_mem, .to_mem } }, | 33537 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 21432 | }, | 33538 | }, |
| 21433 | .extra_temps = .{ | 33539 | .extra_temps = .{ |
| 21434 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33540 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 21435 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33541 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 21436 | .{ .type = .u8, .kind = .{ .reg = .ah } }, | 33542 | .{ .type = .u8, .kind = .{ .reg = .ah } }, |
| 21437 | .unused, | 33543 | .unused, |
| 21438 | .unused, | 33544 | .unused, |
| ... | @@ -21465,11 +33571,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21465,11 +33571,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21465 | } }, | 33571 | } }, |
| 21466 | }, .{ | 33572 | }, .{ |
| 21467 | .required_features = .{ .x87, .cmov, null, null }, | 33573 | .required_features = .{ .x87, .cmov, null, null }, |
| 21468 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33574 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21469 | .patterns = &.{ | 33575 | .patterns = &.{ |
| 21470 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 33576 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21471 | .{ .src = .{ .mem, .to_x87 } }, | 33577 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 21472 | .{ .src = .{ .to_x87, .to_x87 } }, | 33578 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 21473 | }, | 33579 | }, |
| 21474 | .extra_temps = .{ | 33580 | .extra_temps = .{ |
| 21475 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 33581 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| ... | @@ -21493,9 +33599,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21493,9 +33599,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21493 | } }, | 33599 | } }, |
| 21494 | }, .{ | 33600 | }, .{ |
| 21495 | .required_features = .{ .sahf, .x87, null, null }, | 33601 | .required_features = .{ .sahf, .x87, null, null }, |
| 21496 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33602 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21497 | .patterns = &.{ | 33603 | .patterns = &.{ |
| 21498 | .{ .src = .{ .mem, .mem } }, | 33604 | .{ .src = .{ .mem, .mem, .none } }, |
| 21499 | }, | 33605 | }, |
| 21500 | .extra_temps = .{ | 33606 | .extra_temps = .{ |
| 21501 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33607 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21522,11 +33628,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21522,11 +33628,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21522 | } }, | 33628 | } }, |
| 21523 | }, .{ | 33629 | }, .{ |
| 21524 | .required_features = .{ .sahf, .x87, null, null }, | 33630 | .required_features = .{ .sahf, .x87, null, null }, |
| 21525 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33631 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21526 | .patterns = &.{ | 33632 | .patterns = &.{ |
| 21527 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 33633 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21528 | .{ .src = .{ .mem, .to_x87 } }, | 33634 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 21529 | .{ .src = .{ .to_x87, .to_x87 } }, | 33635 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 21530 | }, | 33636 | }, |
| 21531 | .extra_temps = .{ | 33637 | .extra_temps = .{ |
| 21532 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33638 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21552,9 +33658,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21552,9 +33658,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21552 | } }, | 33658 | } }, |
| 21553 | }, .{ | 33659 | }, .{ |
| 21554 | .required_features = .{ .x87, null, null, null }, | 33660 | .required_features = .{ .x87, null, null, null }, |
| 21555 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33661 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21556 | .patterns = &.{ | 33662 | .patterns = &.{ |
| 21557 | .{ .src = .{ .mem, .mem } }, | 33663 | .{ .src = .{ .mem, .mem, .none } }, |
| 21558 | }, | 33664 | }, |
| 21559 | .extra_temps = .{ | 33665 | .extra_temps = .{ |
| 21560 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33666 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21591,11 +33697,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21591,11 +33697,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21591 | } }, | 33697 | } }, |
| 21592 | }, .{ | 33698 | }, .{ |
| 21593 | .required_features = .{ .x87, null, null, null }, | 33699 | .required_features = .{ .x87, null, null, null }, |
| 21594 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, | 33700 | .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte }, .any }, |
| 21595 | .patterns = &.{ | 33701 | .patterns = &.{ |
| 21596 | .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, | 33702 | .{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } }, |
| 21597 | .{ .src = .{ .mem, .to_x87 } }, | 33703 | .{ .src = .{ .mem, .to_x87, .none } }, |
| 21598 | .{ .src = .{ .to_x87, .to_x87 } }, | 33704 | .{ .src = .{ .to_x87, .to_x87, .none } }, |
| 21599 | }, | 33705 | }, |
| 21600 | .extra_temps = .{ | 33706 | .extra_temps = .{ |
| 21601 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, | 33707 | .{ .type = .f80, .kind = .{ .reg = .st6 } }, |
| ... | @@ -21630,9 +33736,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21630,9 +33736,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21630 | } }, | 33736 | } }, |
| 21631 | }, .{ | 33737 | }, .{ |
| 21632 | .required_features = .{ .sse, null, null, null }, | 33738 | .required_features = .{ .sse, null, null, null }, |
| 21633 | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword } }, | 33739 | .src_constraints = .{ .{ .float = .xword }, .{ .float = .xword }, .any }, |
| 21634 | .patterns = &.{ | 33740 | .patterns = &.{ |
| 21635 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, | 33741 | .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } }, |
| 21636 | }, | 33742 | }, |
| 21637 | .call_frame = .{ .alignment = .@"16" }, | 33743 | .call_frame = .{ .alignment = .@"16" }, |
| 21638 | .extra_temps = .{ | 33744 | .extra_temps = .{ |
| ... | @@ -21663,278 +33769,1020 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -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, | 33772 | .int => res[0] = ops[0].cmpInts(cmp_op, &ops[1], cg) catch |err| break :err err, |
| 21667 | }) catch |err| switch (err) { | 33773 | }) catch |err| switch (err) { |
| 21668 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 33774 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 21669 | @tagName(air_tag), | 33775 | @tagName(air_tag), |
| 21670 | cg.typeOf(bin_op.lhs).fmt(pt), | 33776 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 21671 | ops[0].tracking(cg), | 33777 | ops[0].tracking(cg), |
| 21672 | ops[1].tracking(cg), | 33778 | ops[1].tracking(cg), |
| 21673 | }), | 33779 | }), |
| 21674 | else => |e| return e, | 33780 | else => |e| return e, |
| 21675 | }; | 33781 | }; |
| 21676 | if (opt_info) |*oi| { | 33782 | if (opt_info) |*oi| { |
| 21677 | for (ops) |op| for (res) |r| { | 33783 | for (ops) |op| for (res) |r| { |
| 21678 | if (op.index == r.index) break; | 33784 | if (op.index == r.index) break; |
| 21679 | } else try op.die(cg); | 33785 | } else try op.die(cg); |
| 21680 | try cg.genCopy(.bool, oi.res[0].tracking(cg).short, res[0].tracking(cg).short, .{}); | 33786 | try cg.genCopy(.bool, oi.res[0].tracking(cg).short, res[0].tracking(cg).short, .{}); |
| 21681 | try res[0].die(cg); | 33787 | try res[0].die(cg); |
| 21682 | res[0] = oi.res[0]; | 33788 | res[0] = oi.res[0]; |
| 21683 | try cg.restoreState(oi.state, &oi.deaths, .{ | 33789 | try cg.restoreState(oi.state, &oi.deaths, .{ |
| 21684 | .emit_instructions = true, | 33790 | .emit_instructions = true, |
| 21685 | .update_tracking = true, | 33791 | .update_tracking = true, |
| 21686 | .resurrect = true, | 33792 | .resurrect = true, |
| 21687 | .close_scope = true, | 33793 | .close_scope = true, |
| 21688 | }); | 33794 | }); |
| 21689 | cg.performReloc(oi.reloc); | 33795 | cg.performReloc(oi.reloc); |
| 21690 | @memset(&ops, res[0]); | 33796 | @memset(&ops, res[0]); |
| 21691 | } | 33797 | } |
| 21692 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 33798 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 21693 | }, | 33799 | }, |
| 21694 | | 33800 | |
| 21695 | .cond_br => try cg.airCondBr(inst), | 33801 | .cond_br => try cg.airCondBr(inst), |
| 21696 | .switch_br => try cg.airSwitchBr(inst), | 33802 | .switch_br => try cg.airSwitchBr(inst), |
| 21697 | .loop_switch_br => try cg.airLoopSwitchBr(inst), | 33803 | .loop_switch_br => try cg.airLoopSwitchBr(inst), |
| 21698 | .switch_dispatch => try cg.airSwitchDispatch(inst), | 33804 | .switch_dispatch => try cg.airSwitchDispatch(inst), |
| 21699 | .@"try", .try_cold => try cg.airTry(inst), | 33805 | .@"try", .try_cold => try cg.airTry(inst), |
| 21700 | .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), | 33806 | .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), |
| 21701 | .dbg_stmt => if (cg.debug_output != .none) { | 33807 | .dbg_stmt => if (cg.debug_output != .none) { |
| 21702 | const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; | 33808 | const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; |
| 21703 | _ = try cg.addInst(.{ | 33809 | _ = try cg.addInst(.{ |
| 21704 | .tag = .pseudo, | 33810 | .tag = .pseudo, |
| 21705 | .ops = .pseudo_dbg_line_stmt_line_column, | 33811 | .ops = .pseudo_dbg_line_stmt_line_column, |
| 21706 | .data = .{ .line_column = .{ | 33812 | .data = .{ .line_column = .{ |
| 21707 | .line = dbg_stmt.line, | 33813 | .line = dbg_stmt.line, |
| 21708 | .column = dbg_stmt.column, | 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 | }); | 34407 | }, .{ |
| 21711 | }, | 34408 | .required_features = .{ .avx, null, null, null }, |
| 21712 | .dbg_empty_stmt => if (cg.debug_output != .none) { | 34409 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 21713 | if (cg.mir_instructions.len > 0) { | 34410 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, |
| 21714 | const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1]; | 34411 | .patterns = &.{ |
| 21715 | if (prev_mir_op.* == .pseudo_dbg_line_line_column) | 34412 | .{ .src = .{ .mem, .none, .none } }, |
| 21716 | prev_mir_op.* = .pseudo_dbg_line_stmt_line_column; | 34413 | .{ .src = .{ .to_sse, .none, .none } }, |
| 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 | }, | | |
| 21755 | }, | 34414 | }, |
| 21756 | } | 34415 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 21757 | try cg.genLocalDebugInfo(inst, ops[0].tracking(cg).short); | 34416 | .each = .{ .once = &.{ |
| 21758 | try ops[0].die(cg); | 34417 | .{ ._, .v_ps, .cvtpd2, .dst0x, .src0x, ._, ._ }, |
| 21759 | }, | 34418 | } }, |
| 21760 | .is_null_ptr => if (use_old) try cg.airIsNullPtr(inst) else { | 34419 | }, .{ |
| 21761 | const un_op = air_datas[@intFromEnum(inst)].un_op; | 34420 | .required_features = .{ .sse2, null, null, null }, |
| 21762 | const opt_ty = cg.typeOf(un_op).childType(zcu); | 34421 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 21763 | const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); | 34422 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, |
| 21764 | const opt_child_ty = opt_ty.optionalChild(zcu); | 34423 | .patterns = &.{ |
| 21765 | const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu)); | 34424 | .{ .src = .{ .mem, .none, .none } }, |
| 21766 | var ops = try cg.tempsFromOperands(inst, .{un_op}); | 34425 | .{ .src = .{ .to_sse, .none, .none } }, |
| 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)), | | |
| 21852 | }, | 34426 | }, |
| 21853 | }, cg); | 34427 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 21854 | try res.finish(inst, &.{ty_op.operand}, &ops, cg); | 34428 | .each = .{ .once = &.{ |
| 21855 | }, | 34429 | .{ ._, ._ps, .cvtpd2, .dst0x, .src0x, ._, ._ }, |
| 21856 | .ret => try cg.airRet(inst, false), | 34430 | } }, |
| 21857 | .ret_safe => try cg.airRet(inst, true), | 34431 | }, .{ |
| 21858 | .ret_load => try cg.airRetLoad(inst), | 34432 | .required_features = .{ .avx, null, null, null }, |
| 21859 | .store, .store_safe => |air_tag| if (use_old) try cg.airStore(inst, switch (air_tag) { | 34433 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 21860 | else => unreachable, | 34434 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 21861 | .store => false, | 34435 | .patterns = &.{ |
| 21862 | .store_safe => true, | 34436 | .{ .src = .{ .mem, .none, .none } }, |
| 21863 | }) else fallback: { | 34437 | .{ .src = .{ .to_sse, .none, .none } }, |
| 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)), | | |
| 21881 | }, | 34438 | }, |
| 21882 | .safe = switch (air_tag) { | 34439 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 21883 | else => unreachable, | 34440 | .each = .{ .once = &.{ |
| 21884 | .store => false, | 34441 | .{ ._, .v_ps, .cvtpd2, .dst0x, .src0y, ._, ._ }, |
| 21885 | .store_safe => true, | 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); | 34450 | .extra_temps = .{ |
| 21888 | for (ops) |op| try op.die(cg); | 34451 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 21889 | }, | 34452 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, |
| 21890 | .unreach => {}, | 34453 | .unused, |
| 21891 | .fptrunc => |air_tag| if (use_old) try cg.airFptrunc(inst) else { | 34454 | .unused, |
| 21892 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; | 34455 | .unused, |
| 21893 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); | 34456 | .unused, |
| 21894 | var res: [1]Temp = undefined; | 34457 | .unused, |
| 21895 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 34458 | .unused, |
| 21896 | .required_features = .{ .f16c, null, null, null }, | 34459 | .unused, |
| 21897 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 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 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 34527 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, |
| 21899 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 }, | 34726 | .required_features = .{ .x87, null, null, null }, |
| 21908 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 34727 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 21909 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, | 34728 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 21910 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 }, | 34750 | .required_features = .{ .x87, null, null, null }, |
| 21919 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any }, | 34751 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 21920 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, | 34752 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 21921 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 }, | 34777 | .required_features = .{ .x87, null, null, null }, |
| 21930 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 34778 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 21931 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 34779 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 21932 | .patterns = &.{ | 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 | .extra_temps = .{ | 34784 | .extra_temps = .{ |
| 21937 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, | 34785 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 21938 | .unused, | 34786 | .unused, |
| 21939 | .unused, | 34787 | .unused, |
| 21940 | .unused, | 34788 | .unused, |
| ... | @@ -21944,21 +34792,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21944,21 +34792,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21944 | .unused, | 34792 | .unused, |
| 21945 | .unused, | 34793 | .unused, |
| 21946 | }, | 34794 | }, |
| 21947 | .dst_temps = .{.{ .ref = .src0 }}, | 34795 | .dst_temps = .{.mem}, |
| 21948 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 21949 | .each = .{ .once = &.{ | 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 }, | 34801 | .required_features = .{ .x87, null, null, null }, |
| 21954 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any }, | 34802 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 21955 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, | 34803 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 21956 | .patterns = &.{ | 34804 | .patterns = &.{ |
| 21957 | .{ .src = .{ .to_mem, .none } }, | 34805 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21958 | }, | 34806 | }, |
| 21959 | .extra_temps = .{ | 34807 | .extra_temps = .{ |
| 21960 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 34808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 21961 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, | 34809 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 21962 | .unused, | 34810 | .unused, |
| 21963 | .unused, | 34811 | .unused, |
| 21964 | .unused, | 34812 | .unused, |
| ... | @@ -21971,23 +34819,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21971,23 +34819,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21971 | .clobbers = .{ .eflags = true }, | 34819 | .clobbers = .{ .eflags = true }, |
| 21972 | .each = .{ .once = &.{ | 34820 | .each = .{ .once = &.{ |
| 21973 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 34821 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 21974 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 34822 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 21975 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, | 34823 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 21976 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 34824 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 21977 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 34854 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 21983 | .patterns = &.{ | 34855 | .patterns = &.{ |
| 21984 | .{ .src = .{ .to_mem, .none } }, | 34856 | .{ .src = .{ .to_mem, .none, .none } }, |
| 21985 | }, | 34857 | }, |
| 21986 | .call_frame = .{ .alignment = .@"16" }, | 34858 | .call_frame = .{ .alignment = .@"16" }, |
| 21987 | .extra_temps = .{ | 34859 | .extra_temps = .{ |
| 21988 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 34860 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 21989 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, | 34861 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 21990 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, | 34862 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 21991 | .unused, | 34863 | .unused, |
| 21992 | .unused, | 34864 | .unused, |
| 21993 | .unused, | 34865 | .unused, |
| ... | @@ -21999,7 +34871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -21999,7 +34871,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 21999 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 34871 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22000 | .each = .{ .once = &.{ | 34872 | .each = .{ .once = &.{ |
| 22001 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 34875 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22004 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 34876 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22005 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 34877 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| ... | @@ -22007,16 +34879,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22007,16 +34879,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22007 | } }, | 34879 | } }, |
| 22008 | }, .{ | 34880 | }, .{ |
| 22009 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 34883 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 22012 | .patterns = &.{ | 34884 | .patterns = &.{ |
| 22013 | .{ .src = .{ .to_mem, .none } }, | 34885 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22014 | }, | 34886 | }, |
| 22015 | .call_frame = .{ .alignment = .@"16" }, | 34887 | .call_frame = .{ .alignment = .@"16" }, |
| 22016 | .extra_temps = .{ | 34888 | .extra_temps = .{ |
| 22017 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 34889 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22018 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, | 34890 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22019 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, | 34891 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22020 | .unused, | 34892 | .unused, |
| 22021 | .unused, | 34893 | .unused, |
| 22022 | .unused, | 34894 | .unused, |
| ... | @@ -22028,7 +34900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22028,7 +34900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22028 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 34900 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22029 | .each = .{ .once = &.{ | 34901 | .each = .{ .once = &.{ |
| 22030 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 34904 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22033 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 34905 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 22034 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 34906 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| ... | @@ -22036,16 +34908,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22036,16 +34908,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22036 | } }, | 34908 | } }, |
| 22037 | }, .{ | 34909 | }, .{ |
| 22038 | .required_features = .{ .sse2, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 34912 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 22041 | .patterns = &.{ | 34913 | .patterns = &.{ |
| 22042 | .{ .src = .{ .to_mem, .none } }, | 34914 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22043 | }, | 34915 | }, |
| 22044 | .call_frame = .{ .alignment = .@"16" }, | 34916 | .call_frame = .{ .alignment = .@"16" }, |
| 22045 | .extra_temps = .{ | 34917 | .extra_temps = .{ |
| 22046 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 34918 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22047 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, | 34919 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22048 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, | 34920 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22049 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 34921 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 22050 | .unused, | 34922 | .unused, |
| 22051 | .unused, | 34923 | .unused, |
| ... | @@ -22057,7 +34929,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22057,7 +34929,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22057 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 34929 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22058 | .each = .{ .once = &.{ | 34930 | .each = .{ .once = &.{ |
| 22059 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 34933 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22062 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, | 34934 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, |
| 22063 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, | 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,16 +34938,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22066 | } }, | 34938 | } }, |
| 22067 | }, .{ | 34939 | }, .{ |
| 22068 | .required_features = .{ .sse, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 34942 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 22071 | .patterns = &.{ | 34943 | .patterns = &.{ |
| 22072 | .{ .src = .{ .to_mem, .none } }, | 34944 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22073 | }, | 34945 | }, |
| 22074 | .call_frame = .{ .alignment = .@"16" }, | 34946 | .call_frame = .{ .alignment = .@"16" }, |
| 22075 | .extra_temps = .{ | 34947 | .extra_temps = .{ |
| 22076 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 34948 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22077 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 34949 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 22078 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncsfhf2" } } }, | 34950 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, |
| 22079 | .{ .type = .f32, .kind = .mem }, | 34951 | .{ .type = .f32, .kind = .mem }, |
| 22080 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 34952 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 22081 | .unused, | 34953 | .unused, |
| ... | @@ -22087,7 +34959,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22087,7 +34959,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22087 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 34959 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22088 | .each = .{ .once = &.{ | 34960 | .each = .{ .once = &.{ |
| 22089 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 34963 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22092 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, | 34964 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, |
| 22093 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, | 34965 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, |
| ... | @@ -22097,14 +34969,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22097,14 +34969,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22097 | } }, | 34969 | } }, |
| 22098 | }, .{ | 34970 | }, .{ |
| 22099 | .required_features = .{ .sse, null, null, null }, | 34971 | .required_features = .{ .sse, null, null, null }, |
| 22100 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 34972 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22101 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 34973 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22102 | .patterns = &.{ | 34974 | .patterns = &.{ |
| 22103 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 34975 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22104 | }, | 34976 | }, |
| 22105 | .call_frame = .{ .alignment = .@"16" }, | 34977 | .call_frame = .{ .alignment = .@"16" }, |
| 22106 | .extra_temps = .{ | 34978 | .extra_temps = .{ |
| 22107 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, | 34979 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 22108 | .unused, | 34980 | .unused, |
| 22109 | .unused, | 34981 | .unused, |
| 22110 | .unused, | 34982 | .unused, |
| ... | @@ -22121,16 +34993,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22121,16 +34993,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22121 | } }, | 34993 | } }, |
| 22122 | }, .{ | 34994 | }, .{ |
| 22123 | .required_features = .{ .avx, null, null, null }, | 34995 | .required_features = .{ .avx, null, null, null }, |
| 22124 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 34996 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22125 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 34997 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22126 | .patterns = &.{ | 34998 | .patterns = &.{ |
| 22127 | .{ .src = .{ .to_mem, .none } }, | 34999 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22128 | }, | 35000 | }, |
| 22129 | .call_frame = .{ .alignment = .@"16" }, | 35001 | .call_frame = .{ .alignment = .@"16" }, |
| 22130 | .extra_temps = .{ | 35002 | .extra_temps = .{ |
| 22131 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35003 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22132 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 35004 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22133 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, | 35005 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 22134 | .unused, | 35006 | .unused, |
| 22135 | .unused, | 35007 | .unused, |
| 22136 | .unused, | 35008 | .unused, |
| ... | @@ -22142,24 +35014,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22142,24 +35014,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22142 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35014 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22143 | .each = .{ .once = &.{ | 35015 | .each = .{ .once = &.{ |
| 22144 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 35018 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22147 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 35019 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22148 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 35020 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22149 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35021 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22150 | } }, | 35022 | } }, |
| 22151 | }, .{ | 35023 | }, .{ |
| 22152 | .required_features = .{ .sse4_1, null, null, null }, | 35024 | .required_features = .{ .sse2, null, null, null }, |
| 22153 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 35025 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22154 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35026 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22155 | .patterns = &.{ | 35027 | .patterns = &.{ |
| 22156 | .{ .src = .{ .to_mem, .none } }, | 35028 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22157 | }, | 35029 | }, |
| 22158 | .call_frame = .{ .alignment = .@"16" }, | 35030 | .call_frame = .{ .alignment = .@"16" }, |
| 22159 | .extra_temps = .{ | 35031 | .extra_temps = .{ |
| 22160 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35032 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22161 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 35033 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22162 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, | 35034 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, |
| 22163 | .unused, | 35035 | .unused, |
| 22164 | .unused, | 35036 | .unused, |
| 22165 | .unused, | 35037 | .unused, |
| ... | @@ -22171,25 +35043,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22171,25 +35043,107 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22171 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35043 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22172 | .each = .{ .once = &.{ | 35044 | .each = .{ .once = &.{ |
| 22173 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 35047 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22176 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 35048 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22177 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35132 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22179 | } }, | 35133 | } }, |
| 22180 | }, .{ | 35134 | }, .{ |
| 22181 | .required_features = .{ .sse2, null, null, null }, | 35135 | .required_features = .{ .sse2, null, null, null }, |
| 22182 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 35136 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22183 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35137 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22184 | .patterns = &.{ | 35138 | .patterns = &.{ |
| 22185 | .{ .src = .{ .to_mem, .none } }, | 35139 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22186 | }, | 35140 | }, |
| 22187 | .call_frame = .{ .alignment = .@"16" }, | 35141 | .call_frame = .{ .alignment = .@"16" }, |
| 22188 | .extra_temps = .{ | 35142 | .extra_temps = .{ |
| 22189 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22190 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 35144 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22191 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, | 35145 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 22192 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 35146 | .unused, |
| 22193 | .unused, | 35147 | .unused, |
| 22194 | .unused, | 35148 | .unused, |
| 22195 | .unused, | 35149 | .unused, |
| ... | @@ -22200,27 +35154,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22200,27 +35154,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22200 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35154 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22201 | .each = .{ .once = &.{ | 35155 | .each = .{ .once = &.{ |
| 22202 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 35158 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22205 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, | 35159 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22206 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, | 35160 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22207 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 22208 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35161 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22209 | } }, | 35162 | } }, |
| 22210 | }, .{ | 35163 | }, .{ |
| 22211 | .required_features = .{ .sse, null, null, null }, | 35164 | .required_features = .{ .sse, null, null, null }, |
| 22212 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 35165 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22213 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35166 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22214 | .patterns = &.{ | 35167 | .patterns = &.{ |
| 22215 | .{ .src = .{ .to_mem, .none } }, | 35168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22216 | }, | 35169 | }, |
| 22217 | .call_frame = .{ .alignment = .@"16" }, | 35170 | .call_frame = .{ .alignment = .@"16" }, |
| 22218 | .extra_temps = .{ | 35171 | .extra_temps = .{ |
| 22219 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35172 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22220 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 35173 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 22221 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncdfhf2" } } }, | 35174 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, |
| 22222 | .{ .type = .f32, .kind = .mem }, | 35175 | .unused, |
| 22223 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 35176 | .unused, |
| 22224 | .unused, | 35177 | .unused, |
| 22225 | .unused, | 35178 | .unused, |
| 22226 | .unused, | 35179 | .unused, |
| ... | @@ -22230,60 +35183,186 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22230,60 +35183,186 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22230 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35183 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22231 | .each = .{ .once = &.{ | 35184 | .each = .{ .once = &.{ |
| 22232 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35185 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 22233 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, | 35186 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 22234 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | | |
| 22235 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 35187 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22236 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, | 35188 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22237 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, | 35189 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22238 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, | | |
| 22239 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 22240 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35190 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22241 | } }, | 35191 | } }, |
| 22242 | }, .{ | 35192 | }, .{ |
| 22243 | .required_features = .{ .avx, null, null, null }, | 35193 | .required_features = .{ .sse, .x87, null, null }, |
| 22244 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 35194 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22245 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | 35195 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22246 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 35213 | .each = .{ .once = &.{ |
| 22251 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 35214 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 22252 | .{ ._, .v_ss, .cvtsd2, .dst0x, .dst0x, .src0q, ._ }, | | |
| 22253 | } }, | 35215 | } }, |
| 22254 | }, .{ | 35216 | }, .{ |
| 22255 | .required_features = .{ .avx, null, null, null }, | 35217 | .required_features = .{ .avx, null, null, null }, |
| 22256 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 35218 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 22257 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | 35219 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22258 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | 35324 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22269 | .patterns = &.{ | 35325 | .patterns = &.{ |
| 22270 | .{ .src = .{ .mem, .none } }, | 35326 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22271 | .{ .src = .{ .to_sse, .none } }, | | |
| 22272 | }, | 35327 | }, |
| 22273 | .dst_temps = .{.{ .rc = .sse }}, | 35328 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22274 | .each = .{ .once = &.{ | 35329 | .each = .{ .once = &.{ |
| 22275 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 35330 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 22276 | .{ ._, ._ss, .cvtsd2, .dst0x, .src0q, ._, ._ }, | | |
| 22277 | } }, | 35331 | } }, |
| 22278 | }, .{ | 35332 | }, .{ |
| 22279 | .required_features = .{ .x87, null, null, null }, | 35333 | .required_features = .{ .f16c, null, null, null }, |
| 22280 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 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 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | 35359 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 22282 | .patterns = &.{ | 35360 | .patterns = &.{ |
| 22283 | .{ .src = .{ .to_mem, .none } }, | 35361 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22284 | }, | 35362 | }, |
| | 35363 | .call_frame = .{ .alignment = .@"16" }, |
| 22285 | .extra_temps = .{ | 35364 | .extra_temps = .{ |
| 22286 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 35365 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, |
| 22287 | .unused, | 35366 | .unused, |
| 22288 | .unused, | 35367 | .unused, |
| 22289 | .unused, | 35368 | .unused, |
| ... | @@ -22293,57 +35372,178 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22293,57 +35372,178 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22293 | .unused, | 35372 | .unused, |
| 22294 | .unused, | 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 | .dst_temps = .{.mem}, | 35398 | .dst_temps = .{.mem}, |
| | 35399 | .clobbers = .{ .eflags = true }, |
| 22297 | .each = .{ .once = &.{ | 35400 | .each = .{ .once = &.{ |
| 22298 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 35401 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22299 | .{ ._, .f_p, .st, .dst0d, ._, ._, ._ }, | 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 }, | 35499 | .required_features = .{ .f16c, null, null, null }, |
| 22303 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, | 35500 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22304 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, | 35501 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22305 | .patterns = &.{ | 35502 | .patterns = &.{ |
| 22306 | .{ .src = .{ .mem, .none } }, | 35503 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22307 | .{ .src = .{ .to_sse, .none } }, | | |
| 22308 | }, | 35504 | }, |
| 22309 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 35505 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22310 | .each = .{ .once = &.{ | 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 }, | 35511 | .required_features = .{ .f16c, null, null, null }, |
| 22315 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, | 35512 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 22316 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .dword } }}, | 35513 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 22317 | .patterns = &.{ | 35514 | .patterns = &.{ |
| 22318 | .{ .src = .{ .mem, .none } }, | 35515 | .{ .src = .{ .mem, .none, .none } }, |
| 22319 | .{ .src = .{ .to_sse, .none } }, | 35516 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22320 | }, | 35517 | }, |
| 22321 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 35518 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22322 | .each = .{ .once = &.{ | 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 }, | 35524 | .required_features = .{ .f16c, null, null, null }, |
| 22327 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any }, | 35525 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 22328 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, | 35526 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 22329 | .patterns = &.{ | 35527 | .patterns = &.{ |
| 22330 | .{ .src = .{ .mem, .none } }, | 35528 | .{ .src = .{ .mem, .none, .none } }, |
| 22331 | .{ .src = .{ .to_sse, .none } }, | 35529 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22332 | }, | 35530 | }, |
| 22333 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 35531 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 22334 | .each = .{ .once = &.{ | 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 }, | 35537 | .required_features = .{ .f16c, null, null, null }, |
| 22339 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any }, | 35538 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 22340 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, | 35539 | .dst_constraints = .{.{ .scalar_float = .{ .of = .zword, .is = .qword } }}, |
| 22341 | .patterns = &.{ | 35540 | .patterns = &.{ |
| 22342 | .{ .src = .{ .to_mem, .none } }, | 35541 | .{ .src = .{ .mem, .none, .none } }, |
| | 35542 | .{ .src = .{ .to_sse, .none, .none } }, |
| 22343 | }, | 35543 | }, |
| 22344 | .extra_temps = .{ | 35544 | .extra_temps = .{ |
| 22345 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35545 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22346 | .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, | 35546 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 22347 | .unused, | 35547 | .unused, |
| 22348 | .unused, | 35548 | .unused, |
| 22349 | .unused, | 35549 | .unused, |
| ... | @@ -22353,24 +35553,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22353,24 +35553,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22353 | .unused, | 35553 | .unused, |
| 22354 | }, | 35554 | }, |
| 22355 | .dst_temps = .{.mem}, | 35555 | .dst_temps = .{.mem}, |
| 22356 | .clobbers = .{ .eflags = true }, | | |
| 22357 | .each = .{ .once = &.{ | 35556 | .each = .{ .once = &.{ |
| 22358 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35557 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src0x, ._, ._ }, |
| 22359 | .{ .@"0:", .v_ps, .cvtpd2, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 35558 | .{ ._, .v_pd, .cvtps2, .tmp1y, .tmp0x, ._, ._ }, |
| 22360 | .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 35559 | .{ ._, .v_f128, .extract, .tmp0x, .tmp0y, .ui(1), ._ }, |
| 22361 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 35560 | .{ ._, .v_pd, .mova, .mem(.dst0y), .tmp1y, ._, ._ }, |
| 22362 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 35565 | .required_features = .{ .sse, null, null, null }, |
| 22366 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any }, | 35566 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22367 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, | 35567 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22368 | .patterns = &.{ | 35568 | .patterns = &.{ |
| 22369 | .{ .src = .{ .to_mem, .none } }, | 35569 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22370 | }, | 35570 | }, |
| | 35571 | .call_frame = .{ .alignment = .@"16" }, |
| 22371 | .extra_temps = .{ | 35572 | .extra_temps = .{ |
| 22372 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35573 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 22373 | .{ .type = .vector_2_f32, .kind = .{ .rc = .sse } }, | 35574 | .unused, |
| 22374 | .unused, | 35575 | .unused, |
| 22375 | .unused, | 35576 | .unused, |
| 22376 | .unused, | 35577 | .unused, |
| ... | @@ -22379,26 +35580,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22379,26 +35580,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22379 | .unused, | 35580 | .unused, |
| 22380 | .unused, | 35581 | .unused, |
| 22381 | }, | 35582 | }, |
| 22382 | .dst_temps = .{.mem}, | 35583 | .dst_temps = .{.{ .ref = .src0 }}, |
| 22383 | .clobbers = .{ .eflags = true }, | 35584 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22384 | .each = .{ .once = &.{ | 35585 | .each = .{ .once = &.{ |
| 22385 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35586 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 22390 | } }, | 35587 | } }, |
| 22391 | }, .{ | 35588 | }, .{ |
| 22392 | .required_features = .{ .x87, null, null, null }, | 35589 | .required_features = .{ .f16c, null, null, null }, |
| 22393 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 35590 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 22394 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | 35591 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }}, |
| 22395 | .patterns = &.{ | 35592 | .patterns = &.{ |
| 22396 | .{ .src = .{ .to_mem, .none } }, | 35593 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22397 | }, | 35594 | }, |
| 22398 | .extra_temps = .{ | 35595 | .extra_temps = .{ |
| 22399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35596 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22400 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 35597 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 22401 | .unused, | 35598 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 22402 | .unused, | 35599 | .unused, |
| 22403 | .unused, | 35600 | .unused, |
| 22404 | .unused, | 35601 | .unused, |
| ... | @@ -22409,24 +35606,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22409,24 +35606,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22409 | .dst_temps = .{.mem}, | 35606 | .dst_temps = .{.mem}, |
| 22410 | .clobbers = .{ .eflags = true }, | 35607 | .clobbers = .{ .eflags = true }, |
| 22411 | .each = .{ .once = &.{ | 35608 | .each = .{ .once = &.{ |
| 22412 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35609 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22413 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, | 35610 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22414 | .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 35611 | .{ ._, .v_pd, .cvtps2, .tmp2y, .tmp1x, ._, ._ }, |
| 22415 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35617 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22417 | } }, | 35618 | } }, |
| 22418 | }, .{ | 35619 | }, .{ |
| 22419 | .required_features = .{ .avx, null, null, null }, | 35620 | .required_features = .{ .avx, null, null, null }, |
| 22420 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35621 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22421 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 35622 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22422 | .patterns = &.{ | 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 | .extra_temps = .{ | 35627 | .extra_temps = .{ |
| 22427 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 35628 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22428 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, | 35629 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22429 | .unused, | 35630 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 22430 | .unused, | 35631 | .unused, |
| 22431 | .unused, | 35632 | .unused, |
| 22432 | .unused, | 35633 | .unused, |
| ... | @@ -22434,25 +35635,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22434,25 +35635,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22434 | .unused, | 35635 | .unused, |
| 22435 | .unused, | 35636 | .unused, |
| 22436 | }, | 35637 | }, |
| 22437 | .dst_temps = .{.{ .reg = .xmm0 }}, | 35638 | .dst_temps = .{.mem}, |
| 22438 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35639 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22439 | .each = .{ .once = &.{ | 35640 | .each = .{ .once = &.{ |
| 22440 | .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, | 35641 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22441 | .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, | 35642 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 22442 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 35650 | .required_features = .{ .sse2, null, null, null }, |
| 22446 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35651 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22447 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 35652 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22448 | .patterns = &.{ | 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 | .extra_temps = .{ | 35657 | .extra_temps = .{ |
| 22453 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 35658 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22454 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, | 35659 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22455 | .unused, | 35660 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, |
| 22456 | .unused, | 35661 | .unused, |
| 22457 | .unused, | 35662 | .unused, |
| 22458 | .unused, | 35663 | .unused, |
| ... | @@ -22460,25 +35665,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22460,25 +35665,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22460 | .unused, | 35665 | .unused, |
| 22461 | .unused, | 35666 | .unused, |
| 22462 | }, | 35667 | }, |
| 22463 | .dst_temps = .{.{ .reg = .xmm0 }}, | 35668 | .dst_temps = .{.mem}, |
| 22464 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35669 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22465 | .each = .{ .once = &.{ | 35670 | .each = .{ .once = &.{ |
| 22466 | .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, | 35671 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22467 | .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, | 35672 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 22468 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 | .required_features = .{ .sse, null, null, null }, | 35680 | .required_features = .{ .sse, null, null, null }, |
| 22472 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35681 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22473 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 35682 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22474 | .patterns = &.{ | 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 | .extra_temps = .{ | 35687 | .extra_temps = .{ |
| 22479 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 35688 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22480 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, | 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 | .unused, | 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 | .unused, | 35721 | .unused, |
| 22483 | .unused, | 35722 | .unused, |
| 22484 | .unused, | 35723 | .unused, |
| ... | @@ -22486,56 +35725,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22486,56 +35725,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22486 | .unused, | 35725 | .unused, |
| 22487 | .unused, | 35726 | .unused, |
| 22488 | }, | 35727 | }, |
| 22489 | .dst_temps = .{.{ .reg = .xmm0 }}, | 35728 | .dst_temps = .{.{ .rc = .x87 }}, |
| 22490 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 22491 | .each = .{ .once = &.{ | 35729 | .each = .{ .once = &.{ |
| 22492 | .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, | 35730 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, |
| 22493 | .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ }, | 35731 | .{ ._, .v_ss, .mov, .mem(.tmp1d), .tmp0x, ._, ._ }, |
| 22494 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 35732 | .{ ._, .f_, .ld, .mem(.tmp1d), ._, ._, ._ }, |
| | 35733 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 22495 | } }, | 35734 | } }, |
| 22496 | }, .{ | 35735 | }, .{ |
| 22497 | .required_features = .{ .avx, null, null, null }, | 35736 | .required_features = .{ .sse, .x87, null, null }, |
| 22498 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35737 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22499 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35738 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22500 | .patterns = &.{ | 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 | .extra_temps = .{ | 35743 | .extra_temps = .{ |
| 22505 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35744 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 22506 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 35745 | .unused, |
| 22507 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 35746 | .unused, |
| 22508 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, | 35747 | .unused, |
| 22509 | .unused, | 35748 | .unused, |
| 22510 | .unused, | 35749 | .unused, |
| 22511 | .unused, | 35750 | .unused, |
| 22512 | .unused, | 35751 | .unused, |
| 22513 | .unused, | 35752 | .unused, |
| 22514 | }, | 35753 | }, |
| 22515 | .dst_temps = .{.mem}, | 35754 | .dst_temps = .{.{ .reg = .st0 }}, |
| 22516 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35755 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22517 | .each = .{ .once = &.{ | 35756 | .each = .{ .once = &.{ |
| 22518 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35757 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 22525 | } }, | 35758 | } }, |
| 22526 | }, .{ | 35759 | }, .{ |
| 22527 | .required_features = .{ .sse4_1, null, null, null }, | 35760 | .required_features = .{ .avx, null, null, null }, |
| 22528 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35761 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22529 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35762 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22530 | .patterns = &.{ | 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 | .extra_temps = .{ | 35767 | .extra_temps = .{ |
| 22535 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35768 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22536 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 35769 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22537 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 35770 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 22538 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, | 35771 | .unused, |
| 22539 | .unused, | 35772 | .unused, |
| 22540 | .unused, | 35773 | .unused, |
| 22541 | .unused, | 35774 | .unused, |
| ... | @@ -22545,28 +35778,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22545,28 +35778,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22545 | .dst_temps = .{.mem}, | 35778 | .dst_temps = .{.mem}, |
| 22546 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35779 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22547 | .each = .{ .once = &.{ | 35780 | .each = .{ .once = &.{ |
| 22548 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35781 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22549 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 35782 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 22550 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, | 35783 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 22551 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 35784 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22552 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 35785 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| | 35786 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22553 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 35787 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22554 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35788 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22555 | } }, | 35789 | } }, |
| 22556 | }, .{ | 35790 | }, .{ |
| 22557 | .required_features = .{ .sse2, null, null, null }, | 35791 | .required_features = .{ .sse2, null, null, null }, |
| 22558 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35792 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22559 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35793 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22560 | .patterns = &.{ | 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 | .extra_temps = .{ | 35798 | .extra_temps = .{ |
| 22565 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35799 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22566 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 35800 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22567 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 35801 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, |
| 22568 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncxfhf2" } } }, | 35802 | .unused, |
| 22569 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 35803 | .unused, |
| 22570 | .unused, | 35804 | .unused, |
| 22571 | .unused, | 35805 | .unused, |
| 22572 | .unused, | 35806 | .unused, |
| ... | @@ -22575,29 +35809,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22575,29 +35809,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22575 | .dst_temps = .{.mem}, | 35809 | .dst_temps = .{.mem}, |
| 22576 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35810 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22577 | .each = .{ .once = &.{ | 35811 | .each = .{ .once = &.{ |
| 22578 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35812 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22579 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 35813 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 22580 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, | 35814 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 22581 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 35815 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 22582 | .{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ }, | 35816 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 22583 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, | 35817 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22584 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 35818 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22585 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35819 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22586 | } }, | 35820 | } }, |
| 22587 | }, .{ | 35821 | }, .{ |
| 22588 | .required_features = .{ .sse, null, null, null }, | 35822 | .required_features = .{ .sse, null, null, null }, |
| 22589 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35823 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22590 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 35824 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22591 | .patterns = &.{ | 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 | .extra_temps = .{ | 35829 | .extra_temps = .{ |
| 22596 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 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 | .unused, | 35835 | .unused, |
| 22602 | .unused, | 35836 | .unused, |
| 22603 | .unused, | 35837 | .unused, |
| ... | @@ -22606,26 +35840,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22606,26 +35840,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22606 | .dst_temps = .{.mem}, | 35840 | .dst_temps = .{.mem}, |
| 22607 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 35841 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22608 | .each = .{ .once = &.{ | 35842 | .each = .{ .once = &.{ |
| 22609 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35843 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22610 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 35844 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22611 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, | 35845 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 22612 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 35846 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 22613 | .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp1x, ._, ._ }, | 35847 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 22614 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp2d), ._, ._ }, | 35848 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 22615 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, | 35849 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22616 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 35850 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22617 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35851 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22618 | } }, | 35852 | } }, |
| 22619 | }, .{ | 35853 | }, .{ |
| 22620 | .required_features = .{ .x87, null, null, null }, | 35854 | .required_features = .{ .sse, null, null, null }, |
| 22621 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35855 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22622 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | 35856 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22623 | .patterns = &.{ | 35857 | .patterns = &.{ |
| 22624 | .{ .src = .{ .mem, .none } }, | 35858 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22625 | .{ .src = .{ .to_x87, .none } }, | | |
| 22626 | }, | 35859 | }, |
| | 35860 | .call_frame = .{ .alignment = .@"16" }, |
| 22627 | .extra_temps = .{ | 35861 | .extra_temps = .{ |
| 22628 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 35862 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22629 | .unused, | 35863 | .unused, |
| 22630 | .unused, | 35864 | .unused, |
| 22631 | .unused, | 35865 | .unused, |
| ... | @@ -22635,22 +35869,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22635,22 +35869,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22635 | .unused, | 35869 | .unused, |
| 22636 | .unused, | 35870 | .unused, |
| 22637 | }, | 35871 | }, |
| 22638 | .dst_temps = .{.mem}, | 35872 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 35873 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22639 | .each = .{ .once = &.{ | 35874 | .each = .{ .once = &.{ |
| 22640 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 35875 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 22641 | .{ ._, .f_p, .st, .dst0d, ._, ._, ._ }, | | |
| 22642 | } }, | 35876 | } }, |
| 22643 | }, .{ | 35877 | }, .{ |
| 22644 | .required_features = .{ .x87, null, null, null }, | 35878 | .required_features = .{ .avx, null, null, null }, |
| 22645 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35879 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22646 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | 35880 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22647 | .patterns = &.{ | 35881 | .patterns = &.{ |
| 22648 | .{ .src = .{ .to_mem, .none } }, | 35882 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22649 | }, | 35883 | }, |
| | 35884 | .call_frame = .{ .alignment = .@"16" }, |
| 22650 | .extra_temps = .{ | 35885 | .extra_temps = .{ |
| 22651 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22652 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 35887 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22653 | .unused, | 35888 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22654 | .unused, | 35889 | .unused, |
| 22655 | .unused, | 35890 | .unused, |
| 22656 | .unused, | 35891 | .unused, |
| ... | @@ -22659,26 +35894,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22659,26 +35894,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22659 | .unused, | 35894 | .unused, |
| 22660 | }, | 35895 | }, |
| 22661 | .dst_temps = .{.mem}, | 35896 | .dst_temps = .{.mem}, |
| 22662 | .clobbers = .{ .eflags = true }, | 35897 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22663 | .each = .{ .once = &.{ | 35898 | .each = .{ .once = &.{ |
| 22664 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35899 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22665 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, | 35900 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 22666 | .{ ._, .f_p, .st, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 35901 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 22667 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 35902 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| | 35903 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 35904 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 22668 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35905 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22669 | } }, | 35906 | } }, |
| 22670 | }, .{ | 35907 | }, .{ |
| 22671 | .required_features = .{ .x87, null, null, null }, | 35908 | .required_features = .{ .sse2, null, null, null }, |
| 22672 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35909 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22673 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 35910 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22674 | .patterns = &.{ | 35911 | .patterns = &.{ |
| 22675 | .{ .src = .{ .mem, .none } }, | 35912 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22676 | .{ .src = .{ .to_x87, .none } }, | | |
| 22677 | }, | 35913 | }, |
| | 35914 | .call_frame = .{ .alignment = .@"16" }, |
| 22678 | .extra_temps = .{ | 35915 | .extra_temps = .{ |
| 22679 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 35916 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22680 | .unused, | 35917 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22681 | .unused, | 35918 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22682 | .unused, | 35919 | .unused, |
| 22683 | .unused, | 35920 | .unused, |
| 22684 | .unused, | 35921 | .unused, |
| ... | @@ -22687,47 +35924,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22687,47 +35924,92 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22687 | .unused, | 35924 | .unused, |
| 22688 | }, | 35925 | }, |
| 22689 | .dst_temps = .{.mem}, | 35926 | .dst_temps = .{.mem}, |
| | 35927 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22690 | .each = .{ .once = &.{ | 35928 | .each = .{ .once = &.{ |
| 22691 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 35929 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22692 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 35938 | .required_features = .{ .sse, null, null, null }, |
| 22696 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 35939 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 22697 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | 35940 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22698 | .patterns = &.{ | 35941 | .patterns = &.{ |
| 22699 | .{ .src = .{ .to_mem, .none } }, | 35942 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22700 | }, | 35943 | }, |
| | 35944 | .call_frame = .{ .alignment = .@"16" }, |
| 22701 | .extra_temps = .{ | 35945 | .extra_temps = .{ |
| 22702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 35946 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22703 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 35947 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 22704 | .unused, | 35948 | .{ .type = .f32, .kind = .mem }, |
| 22705 | .unused, | 35949 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 22706 | .unused, | 35950 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, |
| 22707 | .unused, | 35951 | .unused, |
| 22708 | .unused, | 35952 | .unused, |
| 22709 | .unused, | 35953 | .unused, |
| 22710 | .unused, | 35954 | .unused, |
| 22711 | }, | 35955 | }, |
| 22712 | .dst_temps = .{.mem}, | 35956 | .dst_temps = .{.mem}, |
| 22713 | .clobbers = .{ .eflags = true }, | 35957 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22714 | .each = .{ .once = &.{ | 35958 | .each = .{ .once = &.{ |
| 22715 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 35959 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22716 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, | 35960 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22717 | .{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 35961 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 22718 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 35966 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22720 | } }, | 35967 | } }, |
| 22721 | }, .{ | 35968 | }, .{ |
| 22722 | .required_features = .{ .sse, null, null, null }, | 35969 | .required_features = .{ .avx, null, null, null }, |
| 22723 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 35970 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22724 | .dst_constraints = .{.{ .scalar_float = .{ .of = .word, .is = .word } }}, | 35971 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22725 | .patterns = &.{ | 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 | .extra_temps = .{ | 36011 | .extra_temps = .{ |
| 22730 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, | 36012 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 22731 | .unused, | 36013 | .unused, |
| 22732 | .unused, | 36014 | .unused, |
| 22733 | .unused, | 36015 | .unused, |
| ... | @@ -22737,23 +36019,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22737,23 +36019,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22737 | .unused, | 36019 | .unused, |
| 22738 | .unused, | 36020 | .unused, |
| 22739 | }, | 36021 | }, |
| 22740 | .dst_temps = .{.{ .ref = .src0 }}, | 36022 | .dst_temps = .{.mem}, |
| 22741 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 22742 | .each = .{ .once = &.{ | 36023 | .each = .{ .once = &.{ |
| 22743 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 36024 | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, |
| | 36025 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 22744 | } }, | 36026 | } }, |
| 22745 | }, .{ | 36027 | }, .{ |
| 22746 | .required_features = .{ .avx, null, null, null }, | 36028 | .required_features = .{ .avx, null, null, null }, |
| 22747 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36029 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 22748 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 36030 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 22749 | .patterns = &.{ | 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 | .extra_temps = .{ | 36070 | .extra_temps = .{ |
| 22754 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36071 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22755 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36072 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, |
| 22756 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, | 36073 | .unused, |
| 22757 | .unused, | 36074 | .unused, |
| 22758 | .unused, | 36075 | .unused, |
| 22759 | .unused, | 36076 | .unused, |
| ... | @@ -22762,27 +36079,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22762,27 +36079,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22762 | .unused, | 36079 | .unused, |
| 22763 | }, | 36080 | }, |
| 22764 | .dst_temps = .{.mem}, | 36081 | .dst_temps = .{.mem}, |
| 22765 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36082 | .clobbers = .{ .eflags = true }, |
| 22766 | .each = .{ .once = &.{ | 36083 | .each = .{ .once = &.{ |
| 22767 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36084 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22768 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 36085 | .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22769 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36086 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 22770 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 36087 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 22771 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 22772 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36088 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22773 | } }, | 36089 | } }, |
| 22774 | }, .{ | 36090 | }, .{ |
| 22775 | .required_features = .{ .sse4_1, null, null, null }, | 36091 | .required_features = .{ .sse2, null, null, null }, |
| 22776 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36092 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 22777 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 36093 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 22778 | .patterns = &.{ | 36094 | .patterns = &.{ |
| 22779 | .{ .src = .{ .to_mem, .none } }, | 36095 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22780 | }, | 36096 | }, |
| 22781 | .call_frame = .{ .alignment = .@"16" }, | | |
| 22782 | .extra_temps = .{ | 36097 | .extra_temps = .{ |
| 22783 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36098 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22784 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36099 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 22785 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, | 36100 | .unused, |
| 22786 | .unused, | 36101 | .unused, |
| 22787 | .unused, | 36102 | .unused, |
| 22788 | .unused, | 36103 | .unused, |
| ... | @@ -22791,28 +36106,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22791,28 +36106,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22791 | .unused, | 36106 | .unused, |
| 22792 | }, | 36107 | }, |
| 22793 | .dst_temps = .{.mem}, | 36108 | .dst_temps = .{.mem}, |
| 22794 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36109 | .clobbers = .{ .eflags = true }, |
| 22795 | .each = .{ .once = &.{ | 36110 | .each = .{ .once = &.{ |
| 22796 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36111 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22797 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 36112 | .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22798 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36113 | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 22799 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, | 36114 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 22800 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 22801 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36115 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22802 | } }, | 36116 | } }, |
| 22803 | }, .{ | 36117 | }, .{ |
| 22804 | .required_features = .{ .sse2, null, null, null }, | 36118 | .required_features = .{ .x87, null, null, null }, |
| 22805 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36119 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22806 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 36120 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 22807 | .patterns = &.{ | 36121 | .patterns = &.{ |
| 22808 | .{ .src = .{ .to_mem, .none } }, | 36122 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22809 | }, | 36123 | }, |
| 22810 | .call_frame = .{ .alignment = .@"16" }, | | |
| 22811 | .extra_temps = .{ | 36124 | .extra_temps = .{ |
| 22812 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22813 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36126 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 22814 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, | 36127 | .unused, |
| 22815 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 36128 | .unused, |
| 22816 | .unused, | 36129 | .unused, |
| 22817 | .unused, | 36130 | .unused, |
| 22818 | .unused, | 36131 | .unused, |
| ... | @@ -22820,57 +36133,74 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22820,57 +36133,74 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22820 | .unused, | 36133 | .unused, |
| 22821 | }, | 36134 | }, |
| 22822 | .dst_temps = .{.mem}, | 36135 | .dst_temps = .{.mem}, |
| 22823 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36136 | .clobbers = .{ .eflags = true }, |
| 22824 | .each = .{ .once = &.{ | 36137 | .each = .{ .once = &.{ |
| 22825 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22826 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 36139 | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22827 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36140 | .{ ._, .f_p, .st, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 22828 | .{ ._, .p_w, .extr, .tmp3d, .tmp1x, .ui(0), ._ }, | 36141 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22829 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, | | |
| 22830 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 22831 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22832 | } }, | 36143 | } }, |
| 22833 | }, .{ | 36144 | }, .{ |
| 22834 | .required_features = .{ .sse, null, null, null }, | 36145 | .required_features = .{ .x87, null, null, null }, |
| 22835 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36146 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22836 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, | 36147 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 22837 | .patterns = &.{ | 36148 | .patterns = &.{ |
| 22838 | .{ .src = .{ .to_mem, .none } }, | 36149 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22839 | }, | 36150 | }, |
| 22840 | .call_frame = .{ .alignment = .@"16" }, | | |
| 22841 | .extra_temps = .{ | 36151 | .extra_temps = .{ |
| 22842 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36152 | .{ .type = .f32, .kind = .{ .reg = .st7 } }, |
| 22843 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 36153 | .unused, |
| 22844 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfhf2" } } }, | 36154 | .unused, |
| 22845 | .{ .type = .f32, .kind = .mem }, | 36155 | .unused, |
| 22846 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 36156 | .unused, |
| 22847 | .unused, | 36157 | .unused, |
| 22848 | .unused, | 36158 | .unused, |
| 22849 | .unused, | 36159 | .unused, |
| 22850 | .unused, | 36160 | .unused, |
| 22851 | }, | 36161 | }, |
| 22852 | .dst_temps = .{.mem}, | 36162 | .dst_temps = .{.mem}, |
| 22853 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 22854 | .each = .{ .once = &.{ | 36163 | .each = .{ .once = &.{ |
| 22855 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36164 | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, |
| 22856 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 36165 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 22857 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36166 | } }, |
| 22858 | .{ ._, ._ss, .mov, .mem(.tmp3d), .tmp1x, ._, ._ }, | 36167 | }, .{ |
| 22859 | .{ ._, ._, .mov, .tmp4d, .mem(.tmp3d), ._, ._ }, | 36168 | .required_features = .{ .x87, null, null, null }, |
| 22860 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ }, | 36169 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22861 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36192 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22863 | } }, | 36193 | } }, |
| 22864 | }, .{ | 36194 | }, .{ |
| 22865 | .required_features = .{ .sse, null, null, null }, | 36195 | .required_features = .{ .sse, null, null, null }, |
| 22866 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36196 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22867 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | 36197 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22868 | .patterns = &.{ | 36198 | .patterns = &.{ |
| 22869 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 36199 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22870 | }, | 36200 | }, |
| 22871 | .call_frame = .{ .alignment = .@"16" }, | 36201 | .call_frame = .{ .alignment = .@"16" }, |
| 22872 | .extra_temps = .{ | 36202 | .extra_temps = .{ |
| 22873 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, | 36203 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22874 | .unused, | 36204 | .unused, |
| 22875 | .unused, | 36205 | .unused, |
| 22876 | .unused, | 36206 | .unused, |
| ... | @@ -22887,16 +36217,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22887,16 +36217,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22887 | } }, | 36217 | } }, |
| 22888 | }, .{ | 36218 | }, .{ |
| 22889 | .required_features = .{ .avx, null, null, null }, | 36219 | .required_features = .{ .avx, null, null, null }, |
| 22890 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36220 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22891 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | 36221 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22892 | .patterns = &.{ | 36222 | .patterns = &.{ |
| 22893 | .{ .src = .{ .to_mem, .none } }, | 36223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22894 | }, | 36224 | }, |
| 22895 | .call_frame = .{ .alignment = .@"16" }, | 36225 | .call_frame = .{ .alignment = .@"16" }, |
| 22896 | .extra_temps = .{ | 36226 | .extra_temps = .{ |
| 22897 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36227 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22898 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36228 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 22899 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, | 36229 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22900 | .unused, | 36230 | .unused, |
| 22901 | .unused, | 36231 | .unused, |
| 22902 | .unused, | 36232 | .unused, |
| ... | @@ -22907,25 +36237,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22907,25 +36237,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22907 | .dst_temps = .{.mem}, | 36237 | .dst_temps = .{.mem}, |
| 22908 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36238 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22909 | .each = .{ .once = &.{ | 36239 | .each = .{ .once = &.{ |
| 22910 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36240 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22911 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 36241 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22912 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 36244 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22915 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36245 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22916 | } }, | 36246 | } }, |
| 22917 | }, .{ | 36247 | }, .{ |
| 22918 | .required_features = .{ .sse2, null, null, null }, | 36248 | .required_features = .{ .sse2, null, null, null }, |
| 22919 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36249 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22920 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | 36250 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22921 | .patterns = &.{ | 36251 | .patterns = &.{ |
| 22922 | .{ .src = .{ .to_mem, .none } }, | 36252 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22923 | }, | 36253 | }, |
| 22924 | .call_frame = .{ .alignment = .@"16" }, | 36254 | .call_frame = .{ .alignment = .@"16" }, |
| 22925 | .extra_temps = .{ | 36255 | .extra_temps = .{ |
| 22926 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36256 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22927 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36257 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 22928 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, | 36258 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22929 | .unused, | 36259 | .unused, |
| 22930 | .unused, | 36260 | .unused, |
| 22931 | .unused, | 36261 | .unused, |
| ... | @@ -22936,25 +36266,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22936,25 +36266,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22936 | .dst_temps = .{.mem}, | 36266 | .dst_temps = .{.mem}, |
| 22937 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36267 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22938 | .each = .{ .once = &.{ | 36268 | .each = .{ .once = &.{ |
| 22939 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36269 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22940 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 36270 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22941 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 36273 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22944 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36274 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 22945 | } }, | 36275 | } }, |
| 22946 | }, .{ | 36276 | }, .{ |
| 22947 | .required_features = .{ .sse, null, null, null }, | 36277 | .required_features = .{ .sse, null, null, null }, |
| 22948 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36278 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 22949 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | 36279 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22950 | .patterns = &.{ | 36280 | .patterns = &.{ |
| 22951 | .{ .src = .{ .to_mem, .none } }, | 36281 | .{ .src = .{ .to_mem, .none, .none } }, |
| 22952 | }, | 36282 | }, |
| 22953 | .call_frame = .{ .alignment = .@"16" }, | 36283 | .call_frame = .{ .alignment = .@"16" }, |
| 22954 | .extra_temps = .{ | 36284 | .extra_temps = .{ |
| 22955 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36285 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 22956 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36286 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 22957 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfsf2" } } }, | 36287 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, |
| 22958 | .unused, | 36288 | .unused, |
| 22959 | .unused, | 36289 | .unused, |
| 22960 | .unused, | 36290 | .unused, |
| ... | @@ -22965,23 +36295,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22965,23 +36295,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22965 | .dst_temps = .{.mem}, | 36295 | .dst_temps = .{.mem}, |
| 22966 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36296 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 22967 | .each = .{ .once = &.{ | 36297 | .each = .{ .once = &.{ |
| 22968 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36298 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 22969 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 36299 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 22970 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 36302 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 22973 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .sse, null, null, null }, | 36356 | .required_features = .{ .sse, null, null, null }, |
| 22977 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36357 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 22978 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 36358 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 22979 | .patterns = &.{ | 36359 | .patterns = &.{ |
| 22980 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 36360 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 22981 | }, | 36361 | }, |
| 22982 | .call_frame = .{ .alignment = .@"16" }, | 36362 | .call_frame = .{ .alignment = .@"16" }, |
| 22983 | .extra_temps = .{ | 36363 | .extra_temps = .{ |
| 22984 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, | 36364 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 22985 | .unused, | 36365 | .unused, |
| 22986 | .unused, | 36366 | .unused, |
| 22987 | .unused, | 36367 | .unused, |
| ... | @@ -22998,16 +36378,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -22998,16 +36378,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 22998 | } }, | 36378 | } }, |
| 22999 | }, .{ | 36379 | }, .{ |
| 23000 | .required_features = .{ .avx, null, null, null }, | 36380 | .required_features = .{ .avx, null, null, null }, |
| 23001 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36381 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 23002 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | 36382 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23003 | .patterns = &.{ | 36383 | .patterns = &.{ |
| 23004 | .{ .src = .{ .to_mem, .none } }, | 36384 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23005 | }, | 36385 | }, |
| 23006 | .call_frame = .{ .alignment = .@"16" }, | 36386 | .call_frame = .{ .alignment = .@"16" }, |
| 23007 | .extra_temps = .{ | 36387 | .extra_temps = .{ |
| 23008 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36388 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23009 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36389 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 23010 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, | 36390 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 23011 | .unused, | 36391 | .unused, |
| 23012 | .unused, | 36392 | .unused, |
| 23013 | .unused, | 36393 | .unused, |
| ... | @@ -23018,25 +36398,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23018,25 +36398,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23018 | .dst_temps = .{.mem}, | 36398 | .dst_temps = .{.mem}, |
| 23019 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36399 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23020 | .each = .{ .once = &.{ | 36400 | .each = .{ .once = &.{ |
| 23021 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36401 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23022 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 36402 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23023 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 36405 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23026 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36406 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23027 | } }, | 36407 | } }, |
| 23028 | }, .{ | 36408 | }, .{ |
| 23029 | .required_features = .{ .sse2, null, null, null }, | 36409 | .required_features = .{ .sse2, null, null, null }, |
| 23030 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36410 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 23031 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | 36411 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23032 | .patterns = &.{ | 36412 | .patterns = &.{ |
| 23033 | .{ .src = .{ .to_mem, .none } }, | 36413 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23034 | }, | 36414 | }, |
| 23035 | .call_frame = .{ .alignment = .@"16" }, | 36415 | .call_frame = .{ .alignment = .@"16" }, |
| 23036 | .extra_temps = .{ | 36416 | .extra_temps = .{ |
| 23037 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36417 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23038 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36418 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 23039 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, | 36419 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 23040 | .unused, | 36420 | .unused, |
| 23041 | .unused, | 36421 | .unused, |
| 23042 | .unused, | 36422 | .unused, |
| ... | @@ -23047,25 +36427,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23047,25 +36427,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23047 | .dst_temps = .{.mem}, | 36427 | .dst_temps = .{.mem}, |
| 23048 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36428 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23049 | .each = .{ .once = &.{ | 36429 | .each = .{ .once = &.{ |
| 23050 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36430 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23051 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 36431 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23052 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 36434 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23055 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36435 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23056 | } }, | 36436 | } }, |
| 23057 | }, .{ | 36437 | }, .{ |
| 23058 | .required_features = .{ .sse, null, null, null }, | 36438 | .required_features = .{ .sse, null, null, null }, |
| 23059 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36439 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 23060 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | 36440 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23061 | .patterns = &.{ | 36441 | .patterns = &.{ |
| 23062 | .{ .src = .{ .to_mem, .none } }, | 36442 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23063 | }, | 36443 | }, |
| 23064 | .call_frame = .{ .alignment = .@"16" }, | 36444 | .call_frame = .{ .alignment = .@"16" }, |
| 23065 | .extra_temps = .{ | 36445 | .extra_temps = .{ |
| 23066 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23067 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36447 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 23068 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfdf2" } } }, | 36448 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, |
| 23069 | .unused, | 36449 | .unused, |
| 23070 | .unused, | 36450 | .unused, |
| 23071 | .unused, | 36451 | .unused, |
| ... | @@ -23076,50 +36456,105 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23076,50 +36456,105 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23076 | .dst_temps = .{.mem}, | 36456 | .dst_temps = .{.mem}, |
| 23077 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36457 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23078 | .each = .{ .once = &.{ | 36458 | .each = .{ .once = &.{ |
| 23079 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36459 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23080 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 36460 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 36461 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23081 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 36464 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 23084 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36465 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23085 | } }, | 36466 | } }, |
| 23086 | }, .{ | 36467 | }, .{ |
| 23087 | .required_features = .{ .sse, null, null, null }, | 36468 | .required_features = .{ .avx, null, null, null }, |
| 23088 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36469 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 23089 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36470 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23090 | .patterns = &.{ | 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 | .extra_temps = .{ | 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 | .unused, | 36479 | .unused, |
| 23097 | .unused, | 36480 | .unused, |
| 23098 | .unused, | 36481 | .unused, |
| 23099 | .unused, | 36482 | .unused, |
| 23100 | .unused, | 36483 | .unused, |
| 23101 | .unused, | 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 | .unused, | 36509 | .unused, |
| 23103 | .unused, | 36510 | .unused, |
| 23104 | }, | 36511 | }, |
| 23105 | .dst_temps = .{.{ .reg = .st0 }}, | 36512 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 23106 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36513 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23107 | .each = .{ .once = &.{ | 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 | .required_features = .{ .avx, null, null, null }, | 36546 | .required_features = .{ .avx, null, null, null }, |
| 23112 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36547 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 23113 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36548 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23114 | .patterns = &.{ | 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 | .extra_temps = .{ | 36553 | .extra_temps = .{ |
| 23119 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36554 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23120 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36555 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 23121 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, | 36556 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 23122 | .unused, | 36557 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 23123 | .unused, | 36558 | .unused, |
| 23124 | .unused, | 36559 | .unused, |
| 23125 | .unused, | 36560 | .unused, |
| ... | @@ -23129,27 +36564,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23129,27 +36564,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23129 | .dst_temps = .{.mem}, | 36564 | .dst_temps = .{.mem}, |
| 23130 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36565 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23131 | .each = .{ .once = &.{ | 36566 | .each = .{ .once = &.{ |
| 23132 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36567 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23133 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 36568 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23134 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36569 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 23135 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, | 36570 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 23136 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 36571 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23137 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 36572 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23138 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36573 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23139 | } }, | 36574 | } }, |
| 23140 | }, .{ | 36575 | }, .{ |
| 23141 | .required_features = .{ .sse2, null, null, null }, | 36576 | .required_features = .{ .sse2, null, null, null }, |
| 23142 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36577 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 23143 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36578 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23144 | .patterns = &.{ | 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 | .extra_temps = .{ | 36583 | .extra_temps = .{ |
| 23149 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36584 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23150 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36585 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 23151 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, | 36586 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 23152 | .unused, | 36587 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 23153 | .unused, | 36588 | .unused, |
| 23154 | .unused, | 36589 | .unused, |
| 23155 | .unused, | 36590 | .unused, |
| ... | @@ -23159,27 +36594,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23159,27 +36594,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23159 | .dst_temps = .{.mem}, | 36594 | .dst_temps = .{.mem}, |
| 23160 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36595 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23161 | .each = .{ .once = &.{ | 36596 | .each = .{ .once = &.{ |
| 23162 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36597 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23163 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 36598 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23164 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36599 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 23165 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, | 36600 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 23166 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 36601 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23167 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 36602 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23168 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36603 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23169 | } }, | 36604 | } }, |
| 23170 | }, .{ | 36605 | }, .{ |
| 23171 | .required_features = .{ .sse, null, null, null }, | 36606 | .required_features = .{ .sse, null, null, null }, |
| 23172 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any }, | 36607 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 23173 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36608 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 23174 | .patterns = &.{ | 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 | .extra_temps = .{ | 36613 | .extra_temps = .{ |
| 23179 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36614 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23180 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, | 36615 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 23181 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunctfxf2" } } }, | 36616 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 23182 | .unused, | 36617 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, |
| 23183 | .unused, | 36618 | .unused, |
| 23184 | .unused, | 36619 | .unused, |
| 23185 | .unused, | 36620 | .unused, |
| ... | @@ -23189,11 +36624,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23189,11 +36624,11 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23189 | .dst_temps = .{.mem}, | 36624 | .dst_temps = .{.mem}, |
| 23190 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36625 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 23191 | .each = .{ .once = &.{ | 36626 | .each = .{ .once = &.{ |
| 23192 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 36627 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 23193 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 36628 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 23194 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36629 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 23195 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, | 36630 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 23196 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 36631 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 23197 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 36632 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 23198 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36633 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23199 | } }, | 36634 | } }, |
| ... | @@ -23208,138 +36643,76 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23208,138 +36643,76 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23208 | }; | 36643 | }; |
| 23209 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 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 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; | 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 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); | 36650 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 23214 | var res: [1]Temp = undefined; | 36651 | var res: [1]Temp = undefined; |
| 23215 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 36652 | cg.select(&res, &.{dst_ty}, &ops, if (dst_ty.scalarType(zcu).abiSize(zcu) <= src_ty.scalarType(zcu).abiSize(zcu)) comptime &.{ .{ |
| 23216 | .required_features = .{ .f16c, null, null, null }, | 36653 | .dst_constraints = .{.{ .int = .dword }}, |
| 23217 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | | |
| 23218 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | | |
| 23219 | .patterns = &.{ | 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 } }}, | 36658 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23223 | .each = .{ .once = &.{ | 36659 | .each = .{ .once = &.{} }, |
| 23224 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | | |
| 23225 | } }, | | |
| 23226 | }, .{ | 36660 | }, .{ |
| 23227 | .required_features = .{ .f16c, null, null, null }, | 36661 | .required_features = .{ .@"64bit", null, null, null }, |
| 23228 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any }, | 36662 | .dst_constraints = .{.{ .int = .qword }}, |
| 23229 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, | | |
| 23230 | .patterns = &.{ | 36663 | .patterns = &.{ |
| 23231 | .{ .src = .{ .mem, .none } }, | 36664 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 23232 | .{ .src = .{ .to_sse, .none } }, | 36665 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 23233 | }, | 36666 | }, |
| 23234 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 36667 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23235 | .each = .{ .once = &.{ | 36668 | .each = .{ .once = &.{} }, |
| 23236 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | | |
| 23237 | } }, | | |
| 23238 | }, .{ | 36669 | }, .{ |
| 23239 | .required_features = .{ .f16c, null, null, null }, | 36670 | .dst_constraints = .{.{ .int = .byte }}, |
| 23240 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any }, | | |
| 23241 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, | | |
| 23242 | .patterns = &.{ | 36671 | .patterns = &.{ |
| 23243 | .{ .src = .{ .mem, .none } }, | 36672 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23244 | .{ .src = .{ .to_sse, .none } }, | | |
| 23245 | }, | 36673 | }, |
| 23246 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 36674 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23247 | .each = .{ .once = &.{ | 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 }, | 36679 | .dst_constraints = .{.{ .int = .word }}, |
| 23252 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | | |
| 23253 | .dst_constraints = .{.{ .scalar_float = .{ .of = .dword, .is = .dword } }}, | | |
| 23254 | .patterns = &.{ | 36680 | .patterns = &.{ |
| 23255 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 36681 | .{ .src = .{ .to_mem, .none, .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, | | |
| 23268 | }, | 36682 | }, |
| 23269 | .dst_temps = .{.{ .ref = .src0 }}, | 36683 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23270 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 23271 | .each = .{ .once = &.{ | 36684 | .each = .{ .once = &.{ |
| 23272 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 36685 | .{ ._, ._, .mov, .dst0w, .mem(.src0w), ._, ._ }, |
| 23273 | } }, | 36686 | } }, |
| 23274 | }, .{ | 36687 | }, .{ |
| 23275 | .required_features = .{ .f16c, null, null, null }, | 36688 | .dst_constraints = .{.{ .int = .dword }}, |
| 23276 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any }, | | |
| 23277 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, | | |
| 23278 | .patterns = &.{ | 36689 | .patterns = &.{ |
| 23279 | .{ .src = .{ .to_mem, .none } }, | 36690 | .{ .src = .{ .to_mem, .none, .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, | | |
| 23291 | }, | 36691 | }, |
| 23292 | .dst_temps = .{.mem}, | 36692 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23293 | .clobbers = .{ .eflags = true }, | | |
| 23294 | .each = .{ .once = &.{ | 36693 | .each = .{ .once = &.{ |
| 23295 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36694 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 23300 | } }, | 36695 | } }, |
| 23301 | }, .{ | 36696 | }, .{ |
| 23302 | .required_features = .{ .avx, null, null, null }, | 36697 | .required_features = .{ .@"64bit", null, null, null }, |
| 23303 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36698 | .dst_constraints = .{.{ .int = .qword }}, |
| 23304 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | | |
| 23305 | .patterns = &.{ | 36699 | .patterns = &.{ |
| 23306 | .{ .src = .{ .to_mem, .none } }, | 36700 | .{ .src = .{ .to_mem, .none, .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, | | |
| 23319 | }, | 36701 | }, |
| 23320 | .dst_temps = .{.mem}, | 36702 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 23321 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 23322 | .each = .{ .once = &.{ | 36703 | .each = .{ .once = &.{ |
| 23323 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36704 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 23330 | } }, | 36705 | } }, |
| 23331 | }, .{ | 36706 | }, .{ |
| 23332 | .required_features = .{ .sse2, null, null, null }, | 36707 | .required_features = .{ .@"64bit", null, null, null }, |
| 23333 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36708 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 23334 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | | |
| 23335 | .patterns = &.{ | 36709 | .patterns = &.{ |
| 23336 | .{ .src = .{ .to_mem, .none } }, | 36710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23337 | }, | 36711 | }, |
| 23338 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23339 | .extra_temps = .{ | 36712 | .extra_temps = .{ |
| 23340 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36713 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 23341 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36714 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 23342 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, | 36715 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 23343 | .unused, | 36716 | .unused, |
| 23344 | .unused, | 36717 | .unused, |
| 23345 | .unused, | 36718 | .unused, |
| ... | @@ -23348,180 +36721,109 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23348,180 +36721,109 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23348 | .unused, | 36721 | .unused, |
| 23349 | }, | 36722 | }, |
| 23350 | .dst_temps = .{.mem}, | 36723 | .dst_temps = .{.mem}, |
| 23351 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 23352 | .each = .{ .once = &.{ | 36724 | .each = .{ .once = &.{ |
| 23353 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36725 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 23354 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 36726 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 23355 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, | 36727 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| 23356 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36728 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 23357 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | | |
| 23358 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 23359 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 23360 | } }, | 36729 | } }, |
| 23361 | }, .{ | 36730 | }, .{ |
| 23362 | .required_features = .{ .sse, null, null, null }, | 36731 | .required_features = .{ .sse, null, null, null }, |
| 23363 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36732 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 23364 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, | 36733 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, |
| 23365 | .patterns = &.{ | 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" }, | 36738 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23369 | .extra_temps = .{ | 36739 | .each = .{ .once = &.{} }, |
| 23370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36740 | }, .{ |
| 23371 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 36741 | .required_features = .{ .avx, null, null, null }, |
| 23372 | .{ .type = .f32, .kind = .mem }, | 36742 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 23373 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36743 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .byte } }}, |
| 23374 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfsf2" } } }, | 36744 | .patterns = &.{ |
| 23375 | .unused, | 36745 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 23376 | .unused, | 36746 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23377 | .unused, | | |
| 23378 | .unused, | | |
| 23379 | }, | 36747 | }, |
| 23380 | .dst_temps = .{.mem}, | 36748 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23381 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36749 | .each = .{ .once = &.{} }, |
| 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 | } }, | | |
| 23392 | }, .{ | 36750 | }, .{ |
| 23393 | .required_features = .{ .f16c, null, null, null }, | 36751 | .required_features = .{ .avx, null, null, null }, |
| 23394 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36752 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 23395 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 36753 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 23396 | .patterns = &.{ | 36754 | .patterns = &.{ |
| 23397 | .{ .src = .{ .to_sse, .none } }, | 36755 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23398 | }, | 36756 | }, |
| 23399 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 36757 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23400 | .each = .{ .once = &.{ | 36758 | .each = .{ .once = &.{ |
| 23401 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 36759 | .{ ._, .vp_b, .ackssw, .dst0x, .src0x, .dst0x, ._ }, |
| 23402 | .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .dst0d, ._ }, | | |
| 23403 | } }, | 36760 | } }, |
| 23404 | }, .{ | 36761 | }, .{ |
| 23405 | .required_features = .{ .f16c, null, null, null }, | 36762 | .required_features = .{ .avx, null, null, null }, |
| 23406 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .word } }, .any }, | 36763 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 23407 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, | 36764 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 23408 | .patterns = &.{ | 36765 | .patterns = &.{ |
| 23409 | .{ .src = .{ .mem, .none } }, | 36766 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23410 | .{ .src = .{ .to_sse, .none } }, | | |
| 23411 | }, | 36767 | }, |
| 23412 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 36768 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23413 | .each = .{ .once = &.{ | 36769 | .each = .{ .once = &.{ |
| 23414 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 36770 | .{ ._, .vp_b, .ackusw, .dst0x, .src0x, .dst0x, ._ }, |
| 23415 | .{ ._, .v_pd, .cvtps2, .dst0x, .dst0q, ._, ._ }, | | |
| 23416 | } }, | 36771 | } }, |
| 23417 | }, .{ | 36772 | }, .{ |
| 23418 | .required_features = .{ .f16c, null, null, null }, | 36773 | .required_features = .{ .sse2, null, null, null }, |
| 23419 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any }, | 36774 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 23420 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, | 36775 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 23421 | .patterns = &.{ | 36776 | .patterns = &.{ |
| 23422 | .{ .src = .{ .mem, .none } }, | 36777 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23423 | .{ .src = .{ .to_sse, .none } }, | | |
| 23424 | }, | 36778 | }, |
| 23425 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 36779 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23426 | .each = .{ .once = &.{ | 36780 | .each = .{ .once = &.{ |
| 23427 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, | 36781 | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, |
| 23428 | .{ ._, .v_pd, .cvtps2, .dst0y, .dst0x, ._, ._ }, | | |
| 23429 | } }, | 36782 | } }, |
| 23430 | }, .{ | 36783 | }, .{ |
| 23431 | .required_features = .{ .f16c, null, null, null }, | 36784 | .required_features = .{ .sse2, null, null, null }, |
| 23432 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .word } }, .any }, | 36785 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 23433 | .dst_constraints = .{.{ .scalar_float = .{ .of = .zword, .is = .qword } }}, | 36786 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 23434 | .patterns = &.{ | 36787 | .patterns = &.{ |
| 23435 | .{ .src = .{ .mem, .none } }, | 36788 | .{ .src = .{ .to_mut_sse, .none, .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, | | |
| 23448 | }, | 36789 | }, |
| 23449 | .dst_temps = .{.mem}, | 36790 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23450 | .each = .{ .once = &.{ | 36791 | .each = .{ .once = &.{ |
| 23451 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src0x, ._, ._ }, | 36792 | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, |
| 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, ._, ._ }, | | |
| 23457 | } }, | 36793 | } }, |
| 23458 | }, .{ | 36794 | }, .{ |
| 23459 | .required_features = .{ .sse, null, null, null }, | 36795 | .required_features = .{ .avx2, null, null, null }, |
| 23460 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36796 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 23461 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 36797 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 23462 | .patterns = &.{ | 36798 | .patterns = &.{ |
| 23463 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 36799 | .{ .src = .{ .to_sse, .none, .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, | | |
| 23476 | }, | 36800 | }, |
| 23477 | .dst_temps = .{.{ .ref = .src0 }}, | 36801 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23478 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 23479 | .each = .{ .once = &.{ | 36802 | .each = .{ .once = &.{ |
| 23480 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 36803 | .{ ._, .vp_b, .ackssw, .dst0y, .src0y, .dst0y, ._ }, |
| 23481 | } }, | 36804 | } }, |
| 23482 | }, .{ | 36805 | }, .{ |
| 23483 | .required_features = .{ .f16c, null, null, null }, | 36806 | .required_features = .{ .avx2, null, null, null }, |
| 23484 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }, .any }, | 36807 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 23485 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .zword, .is = .qword } }}, | 36808 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, |
| 23486 | .patterns = &.{ | 36809 | .patterns = &.{ |
| 23487 | .{ .src = .{ .to_mem, .none } }, | 36810 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23488 | }, | 36811 | }, |
| 23489 | .extra_temps = .{ | 36812 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 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 }, | | |
| 23502 | .each = .{ .once = &.{ | 36813 | .each = .{ .once = &.{ |
| 23503 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36814 | .{ ._, .vp_b, .ackusw, .dst0y, .src0y, .dst0y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 23512 | } }, | 36815 | } }, |
| 23513 | }, .{ | 36816 | }, .{ |
| 23514 | .required_features = .{ .avx, null, null, null }, | 36817 | .required_features = .{ .slow_incdec, null, null, null }, |
| 23515 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36818 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 23516 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | 36819 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23517 | .patterns = &.{ | 36820 | .patterns = &.{ |
| 23518 | .{ .src = .{ .to_mem, .none } }, | 36821 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23519 | }, | 36822 | }, |
| 23520 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23521 | .extra_temps = .{ | 36823 | .extra_temps = .{ |
| 23522 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36824 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23523 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36825 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23524 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, | 36826 | .unused, |
| 23525 | .unused, | 36827 | .unused, |
| 23526 | .unused, | 36828 | .unused, |
| 23527 | .unused, | 36829 | .unused, |
| ... | @@ -23530,28 +36832,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23530,28 +36832,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23530 | .unused, | 36832 | .unused, |
| 23531 | }, | 36833 | }, |
| 23532 | .dst_temps = .{.mem}, | 36834 | .dst_temps = .{.mem}, |
| 23533 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36835 | .clobbers = .{ .eflags = true }, |
| 23534 | .each = .{ .once = &.{ | 36836 | .each = .{ .once = &.{ |
| 23535 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36837 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23536 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, | 36838 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 23537 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, | 36839 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 23538 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36840 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23539 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | | |
| 23540 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 23541 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36841 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23542 | } }, | 36842 | } }, |
| 23543 | }, .{ | 36843 | }, .{ |
| 23544 | .required_features = .{ .sse2, null, null, null }, | 36844 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 23545 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36845 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23546 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | | |
| 23547 | .patterns = &.{ | 36846 | .patterns = &.{ |
| 23548 | .{ .src = .{ .to_mem, .none } }, | 36847 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23549 | }, | 36848 | }, |
| 23550 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23551 | .extra_temps = .{ | 36849 | .extra_temps = .{ |
| 23552 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23553 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36851 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23554 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, | 36852 | .unused, |
| 23555 | .unused, | 36853 | .unused, |
| 23556 | .unused, | 36854 | .unused, |
| 23557 | .unused, | 36855 | .unused, |
| ... | @@ -23560,108 +36858,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23560,108 +36858,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23560 | .unused, | 36858 | .unused, |
| 23561 | }, | 36859 | }, |
| 23562 | .dst_temps = .{.mem}, | 36860 | .dst_temps = .{.mem}, |
| 23563 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36861 | .clobbers = .{ .eflags = true }, |
| 23564 | .each = .{ .once = &.{ | 36862 | .each = .{ .once = &.{ |
| 23565 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36863 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23566 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 36864 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 23567 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, | 36865 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 23568 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36866 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 23569 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 36867 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23570 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 23571 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 23572 | } }, | 36868 | } }, |
| 23573 | }, .{ | 36869 | }, .{ |
| 23574 | .required_features = .{ .sse, null, null, null }, | 36870 | .required_features = .{ .avx, null, null, null }, |
| 23575 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36871 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23576 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | 36872 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, |
| 23577 | .patterns = &.{ | 36873 | .patterns = &.{ |
| 23578 | .{ .src = .{ .to_mem, .none } }, | 36874 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23579 | }, | 36875 | }, |
| 23580 | .call_frame = .{ .alignment = .@"16" }, | 36876 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23581 | .extra_temps = .{ | 36877 | .each = .{ .once = &.{ |
| 23582 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36878 | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, |
| 23583 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 36879 | .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ }, |
| 23584 | .{ .type = .f32, .kind = .mem }, | 36880 | } }, |
| 23585 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36881 | }, .{ |
| 23586 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfdf2" } } }, | 36882 | .required_features = .{ .avx, null, null, null }, |
| 23587 | .unused, | 36883 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23588 | .unused, | 36884 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 23589 | .unused, | 36885 | .patterns = &.{ |
| 23590 | .unused, | 36886 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23591 | }, | 36887 | }, |
| 23592 | .dst_temps = .{.mem}, | 36888 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23593 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 23594 | .each = .{ .once = &.{ | 36889 | .each = .{ .once = &.{ |
| 23595 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36890 | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, |
| 23596 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 36891 | .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ }, |
| 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", ._, ._, ._ }, | | |
| 23603 | } }, | 36892 | } }, |
| 23604 | }, .{ | 36893 | }, .{ |
| 23605 | .required_features = .{ .f16c, .x87, null, null }, | 36894 | .required_features = .{ .sse2, null, null, null }, |
| 23606 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36895 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23607 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36896 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, |
| 23608 | .patterns = &.{ | 36897 | .patterns = &.{ |
| 23609 | .{ .src = .{ .to_sse, .none } }, | 36898 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23610 | }, | 36899 | }, |
| 23611 | .extra_temps = .{ | 36900 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23612 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 36901 | .each = .{ .once = &.{ |
| 23613 | .{ .type = .f32, .kind = .mem }, | 36902 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 23614 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 36903 | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, |
| 23615 | .unused, | 36904 | } }, |
| 23616 | .unused, | 36905 | }, .{ |
| 23617 | .unused, | 36906 | .required_features = .{ .sse4_1, null, null, null }, |
| 23618 | .unused, | 36907 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23619 | .unused, | 36908 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 23620 | .unused, | 36909 | .patterns = &.{ |
| | 36910 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23621 | }, | 36911 | }, |
| 23622 | .dst_temps = .{.{ .rc = .x87 }}, | 36912 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23623 | .each = .{ .once = &.{ | 36913 | .each = .{ .once = &.{ |
| 23624 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src0q, ._, ._ }, | 36914 | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 23625 | .{ ._, .v_ss, .mov, .mem(.tmp1d), .tmp0x, ._, ._ }, | 36915 | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, |
| 23626 | .{ ._, .f_, .ld, .mem(.tmp1d), ._, ._, ._ }, | | |
| 23627 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | | |
| 23628 | } }, | 36916 | } }, |
| 23629 | }, .{ | 36917 | }, .{ |
| 23630 | .required_features = .{ .sse, null, null, null }, | 36918 | .required_features = .{ .avx2, null, null, null }, |
| 23631 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36919 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 23632 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36920 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, |
| 23633 | .patterns = &.{ | 36921 | .patterns = &.{ |
| 23634 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 36922 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23635 | }, | 36923 | }, |
| 23636 | .call_frame = .{ .alignment = .@"16" }, | 36924 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23637 | .extra_temps = .{ | 36925 | .each = .{ .once = &.{ |
| 23638 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, | 36926 | .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, |
| 23639 | .unused, | 36927 | .{ ._, .vp_b, .ackssw, .dst0y, .dst0y, .dst0y, ._ }, |
| 23640 | .unused, | 36928 | } }, |
| 23641 | .unused, | 36929 | }, .{ |
| 23642 | .unused, | 36930 | .required_features = .{ .avx2, null, null, null }, |
| 23643 | .unused, | 36931 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 23644 | .unused, | 36932 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, |
| 23645 | .unused, | 36933 | .patterns = &.{ |
| 23646 | .unused, | 36934 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23647 | }, | 36935 | }, |
| 23648 | .dst_temps = .{.{ .reg = .st0 }}, | 36936 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23649 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 23650 | .each = .{ .once = &.{ | 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 }, | 36942 | .required_features = .{ .slow_incdec, null, null, null }, |
| 23655 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36943 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 23656 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36944 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23657 | .patterns = &.{ | 36945 | .patterns = &.{ |
| 23658 | .{ .src = .{ .to_mem, .none } }, | 36946 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23659 | }, | 36947 | }, |
| 23660 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23661 | .extra_temps = .{ | 36948 | .extra_temps = .{ |
| 23662 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36949 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23663 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36950 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23664 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, | 36951 | .unused, |
| 23665 | .unused, | 36952 | .unused, |
| 23666 | .unused, | 36953 | .unused, |
| 23667 | .unused, | 36954 | .unused, |
| ... | @@ -23670,29 +36957,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23670,29 +36957,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23670 | .unused, | 36957 | .unused, |
| 23671 | }, | 36958 | }, |
| 23672 | .dst_temps = .{.mem}, | 36959 | .dst_temps = .{.mem}, |
| 23673 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36960 | .clobbers = .{ .eflags = true }, |
| 23674 | .each = .{ .once = &.{ | 36961 | .each = .{ .once = &.{ |
| 23675 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36962 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23676 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, | 36963 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 23677 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, | 36964 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 23678 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36965 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23679 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, | | |
| 23680 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, | | |
| 23681 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 23682 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 36966 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23683 | } }, | 36967 | } }, |
| 23684 | }, .{ | 36968 | }, .{ |
| 23685 | .required_features = .{ .sse2, null, null, null }, | 36969 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 23686 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36970 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23687 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | | |
| 23688 | .patterns = &.{ | 36971 | .patterns = &.{ |
| 23689 | .{ .src = .{ .to_mem, .none } }, | 36972 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23690 | }, | 36973 | }, |
| 23691 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23692 | .extra_temps = .{ | 36974 | .extra_temps = .{ |
| 23693 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 36975 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23694 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 36976 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23695 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, | 36977 | .unused, |
| 23696 | .unused, | 36978 | .unused, |
| 23697 | .unused, | 36979 | .unused, |
| 23698 | .unused, | 36980 | .unused, |
| ... | @@ -23701,60 +36983,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23701,60 +36983,50 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23701 | .unused, | 36983 | .unused, |
| 23702 | }, | 36984 | }, |
| 23703 | .dst_temps = .{.mem}, | 36985 | .dst_temps = .{.mem}, |
| 23704 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 36986 | .clobbers = .{ .eflags = true }, |
| 23705 | .each = .{ .once = &.{ | 36987 | .each = .{ .once = &.{ |
| 23706 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 36988 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23707 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 36989 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 23708 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, | 36990 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 23709 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 36991 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 23710 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, | 36992 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23711 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, | | |
| 23712 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 23713 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 23714 | } }, | 36993 | } }, |
| 23715 | }, .{ | 36994 | }, .{ |
| 23716 | .required_features = .{ .sse, null, null, null }, | 36995 | .required_features = .{ .slow_incdec, null, null, null }, |
| 23717 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 36996 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 23718 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | 36997 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23719 | .patterns = &.{ | 36998 | .patterns = &.{ |
| 23720 | .{ .src = .{ .to_mem, .none } }, | 36999 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23721 | }, | 37000 | }, |
| 23722 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23723 | .extra_temps = .{ | 37001 | .extra_temps = .{ |
| 23724 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37002 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23725 | .{ .type = .f16, .kind = .{ .reg = .ax } }, | 37003 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23726 | .{ .type = .f32, .kind = .mem }, | 37004 | .unused, |
| 23727 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 37005 | .unused, |
| 23728 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhfxf2" } } }, | 37006 | .unused, |
| 23729 | .unused, | 37007 | .unused, |
| 23730 | .unused, | 37008 | .unused, |
| 23731 | .unused, | 37009 | .unused, |
| 23732 | .unused, | 37010 | .unused, |
| 23733 | }, | 37011 | }, |
| 23734 | .dst_temps = .{.mem}, | 37012 | .dst_temps = .{.mem}, |
| 23735 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37013 | .clobbers = .{ .eflags = true }, |
| 23736 | .each = .{ .once = &.{ | 37014 | .each = .{ .once = &.{ |
| 23737 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37015 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23738 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 37016 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 23739 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, | 37017 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 23740 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, | 37018 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23741 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | | |
| 23742 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, | | |
| 23743 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, | | |
| 23744 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 23745 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37019 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23746 | } }, | 37020 | } }, |
| 23747 | }, .{ | 37021 | }, .{ |
| 23748 | .required_features = .{ .sse, null, null, null }, | 37022 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 23749 | .src_constraints = .{ .{ .scalar_float = .{ .of = .word, .is = .word } }, .any }, | 37023 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23750 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 23751 | .patterns = &.{ | 37024 | .patterns = &.{ |
| 23752 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 37025 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23753 | }, | 37026 | }, |
| 23754 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23755 | .extra_temps = .{ | 37027 | .extra_temps = .{ |
| 23756 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, | 37028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23757 | .unused, | 37029 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23758 | .unused, | 37030 | .unused, |
| 23759 | .unused, | 37031 | .unused, |
| 23760 | .unused, | 37032 | .unused, |
| ... | @@ -23763,23 +37035,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23763,23 +37035,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23763 | .unused, | 37035 | .unused, |
| 23764 | .unused, | 37036 | .unused, |
| 23765 | }, | 37037 | }, |
| 23766 | .dst_temps = .{.{ .ref = .src0 }}, | 37038 | .dst_temps = .{.mem}, |
| 23767 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37039 | .clobbers = .{ .eflags = true }, |
| 23768 | .each = .{ .once = &.{ | 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 }, | 37048 | .required_features = .{ .slow_incdec, null, null, null }, |
| 23773 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 37049 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 23774 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37050 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23775 | .patterns = &.{ | 37051 | .patterns = &.{ |
| 23776 | .{ .src = .{ .to_mem, .none } }, | 37052 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23777 | }, | 37053 | }, |
| 23778 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23779 | .extra_temps = .{ | 37054 | .extra_temps = .{ |
| 23780 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37055 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23781 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 37056 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23782 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, | 37057 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23783 | .unused, | 37058 | .unused, |
| 23784 | .unused, | 37059 | .unused, |
| 23785 | .unused, | 37060 | .unused, |
| ... | @@ -23788,28 +37063,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23788,28 +37063,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23788 | .unused, | 37063 | .unused, |
| 23789 | }, | 37064 | }, |
| 23790 | .dst_temps = .{.mem}, | 37065 | .dst_temps = .{.mem}, |
| 23791 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37066 | .clobbers = .{ .eflags = true }, |
| 23792 | .each = .{ .once = &.{ | 37067 | .each = .{ .once = &.{ |
| 23793 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37068 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23794 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, | 37069 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23795 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, | 37070 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 23796 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 37071 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 23797 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37072 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 23798 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 37073 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 23799 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37074 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23800 | } }, | 37075 | } }, |
| 23801 | }, .{ | 37076 | }, .{ |
| 23802 | .required_features = .{ .sse2, null, null, null }, | 37077 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 23803 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 37078 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 23804 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 23805 | .patterns = &.{ | 37079 | .patterns = &.{ |
| 23806 | .{ .src = .{ .to_mem, .none } }, | 37080 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23807 | }, | 37081 | }, |
| 23808 | .call_frame = .{ .alignment = .@"16" }, | | |
| 23809 | .extra_temps = .{ | 37082 | .extra_temps = .{ |
| 23810 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37083 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23811 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, | 37084 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 23812 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendhftf2" } } }, | 37085 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 23813 | .unused, | 37086 | .unused, |
| 23814 | .unused, | 37087 | .unused, |
| 23815 | .unused, | 37088 | .unused, |
| ... | @@ -23818,152 +37091,111 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23818,152 +37091,111 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23818 | .unused, | 37091 | .unused, |
| 23819 | }, | 37092 | }, |
| 23820 | .dst_temps = .{.mem}, | 37093 | .dst_temps = .{.mem}, |
| 23821 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37094 | .clobbers = .{ .eflags = true }, |
| 23822 | .each = .{ .once = &.{ | 37095 | .each = .{ .once = &.{ |
| 23823 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37096 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23824 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, | 37097 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 23825 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, | 37098 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 23826 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 37099 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 23827 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37100 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 23828 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 37101 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 23829 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37102 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 23830 | } }, | 37103 | } }, |
| 23831 | }, .{ | 37104 | }, .{ |
| 23832 | .required_features = .{ .sse, null, null, null }, | 37105 | .required_features = .{ .sse, null, null, null }, |
| 23833 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any }, | 37106 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 23834 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37107 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 23835 | .patterns = &.{ | 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" }, | 37112 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23839 | .extra_temps = .{ | 37113 | .each = .{ .once = &.{} }, |
| 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 | } }, | | |
| 23862 | }, .{ | 37114 | }, .{ |
| 23863 | .required_features = .{ .avx, null, null, null }, | 37115 | .required_features = .{ .avx, null, null, null }, |
| 23864 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37116 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 23865 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 37117 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, |
| 23866 | .patterns = &.{ | 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 }}, | 37122 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23870 | .each = .{ .once = &.{ | 37123 | .each = .{ .once = &.{} }, |
| 23871 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | | |
| 23872 | .{ ._, .v_sd, .cvtss2, .dst0x, .dst0x, .src0d, ._ }, | | |
| 23873 | } }, | | |
| 23874 | }, .{ | 37124 | }, .{ |
| 23875 | .required_features = .{ .avx, null, null, null }, | 37125 | .required_features = .{ .avx, null, null, null }, |
| 23876 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37126 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23877 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 37127 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 23878 | .patterns = &.{ | 37128 | .patterns = &.{ |
| 23879 | .{ .src = .{ .to_sse, .none } }, | 37129 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23880 | }, | 37130 | }, |
| 23881 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 37131 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23882 | .each = .{ .once = &.{ | 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 }, | 37136 | .required_features = .{ .avx, null, null, null }, |
| 23887 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37137 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23888 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 37138 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, |
| 23889 | .patterns = &.{ | 37139 | .patterns = &.{ |
| 23890 | .{ .src = .{ .mem, .none } }, | 37140 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23891 | .{ .src = .{ .to_sse, .none } }, | | |
| 23892 | }, | 37141 | }, |
| 23893 | .dst_temps = .{.{ .rc = .sse }}, | 37142 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23894 | .each = .{ .once = &.{ | 37143 | .each = .{ .once = &.{ |
| 23895 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | 37144 | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, |
| 23896 | .{ ._, ._sd, .cvtss2, .dst0x, .src0d, ._, ._ }, | | |
| 23897 | } }, | 37145 | } }, |
| 23898 | }, .{ | 37146 | }, .{ |
| 23899 | .required_features = .{ .x87, null, null, null }, | 37147 | .required_features = .{ .sse2, null, null, null }, |
| 23900 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37148 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23901 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .qword } }}, | 37149 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 23902 | .patterns = &.{ | 37150 | .patterns = &.{ |
| 23903 | .{ .src = .{ .to_mem, .none } }, | 37151 | .{ .src = .{ .to_mut_sse, .none, .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, | | |
| 23915 | }, | 37152 | }, |
| 23916 | .dst_temps = .{.mem}, | 37153 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23917 | .each = .{ .once = &.{ | 37154 | .each = .{ .once = &.{ |
| 23918 | .{ ._, .f_, .ld, .src0d, ._, ._, ._ }, | 37155 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 23919 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | | |
| 23920 | } }, | 37156 | } }, |
| 23921 | }, .{ | 37157 | }, .{ |
| 23922 | .required_features = .{ .avx, null, null, null }, | 37158 | .required_features = .{ .sse4_1, null, null, null }, |
| 23923 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any }, | 37159 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 23924 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, | 37160 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, |
| 23925 | .patterns = &.{ | 37161 | .patterns = &.{ |
| 23926 | .{ .src = .{ .mem, .none } }, | 37162 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 23927 | .{ .src = .{ .to_sse, .none } }, | | |
| 23928 | }, | 37163 | }, |
| 23929 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 37164 | .dst_temps = .{.{ .ref = .src0 }}, |
| 23930 | .each = .{ .once = &.{ | 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 }, | 37169 | .required_features = .{ .avx2, null, null, null }, |
| 23935 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .dword } }, .any }, | 37170 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 23936 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, | 37171 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 23937 | .patterns = &.{ | 37172 | .patterns = &.{ |
| 23938 | .{ .src = .{ .mem, .none } }, | 37173 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23939 | .{ .src = .{ .to_sse, .none } }, | | |
| 23940 | }, | 37174 | }, |
| 23941 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 37175 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23942 | .each = .{ .once = &.{ | 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 }, | 37180 | .required_features = .{ .avx2, null, null, null }, |
| 23947 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 37181 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 23948 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, | 37182 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 23949 | .patterns = &.{ | 37183 | .patterns = &.{ |
| 23950 | .{ .src = .{ .mem, .none } }, | 37184 | .{ .src = .{ .to_sse, .none, .none } }, |
| 23951 | .{ .src = .{ .to_sse, .none } }, | | |
| 23952 | }, | 37185 | }, |
| 23953 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 37186 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 23954 | .each = .{ .once = &.{ | 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 }, | 37191 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 23959 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 37192 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 23960 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, | | |
| 23961 | .patterns = &.{ | 37193 | .patterns = &.{ |
| 23962 | .{ .src = .{ .to_mem, .none } }, | 37194 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23963 | }, | 37195 | }, |
| 23964 | .extra_temps = .{ | 37196 | .extra_temps = .{ |
| 23965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37197 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23966 | .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } }, | 37198 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 23967 | .unused, | 37199 | .unused, |
| 23968 | .unused, | 37200 | .unused, |
| 23969 | .unused, | 37201 | .unused, |
| ... | @@ -23975,22 +37207,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23975,22 +37207,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23975 | .dst_temps = .{.mem}, | 37207 | .dst_temps = .{.mem}, |
| 23976 | .clobbers = .{ .eflags = true }, | 37208 | .clobbers = .{ .eflags = true }, |
| 23977 | .each = .{ .once = &.{ | 37209 | .each = .{ .once = &.{ |
| 23978 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37210 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 23979 | .{ .@"0:", .v_pd, .cvtps2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 37211 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 23980 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 37212 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 23981 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 37213 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 23982 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37214 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 23983 | } }, | 37215 | } }, |
| 23984 | }, .{ | 37216 | }, .{ |
| 23985 | .required_features = .{ .sse2, null, null, null }, | 37217 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 23986 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .dword } }, .any }, | 37218 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 23987 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, | | |
| 23988 | .patterns = &.{ | 37219 | .patterns = &.{ |
| 23989 | .{ .src = .{ .to_mem, .none } }, | 37220 | .{ .src = .{ .to_mem, .none, .none } }, |
| 23990 | }, | 37221 | }, |
| 23991 | .extra_temps = .{ | 37222 | .extra_temps = .{ |
| 23992 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37223 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 23993 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, | 37224 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 23994 | .unused, | 37225 | .unused, |
| 23995 | .unused, | 37226 | .unused, |
| 23996 | .unused, | 37227 | .unused, |
| ... | @@ -24002,22 +37233,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24002,22 +37233,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24002 | .dst_temps = .{.mem}, | 37233 | .dst_temps = .{.mem}, |
| 24003 | .clobbers = .{ .eflags = true }, | 37234 | .clobbers = .{ .eflags = true }, |
| 24004 | .each = .{ .once = &.{ | 37235 | .each = .{ .once = &.{ |
| 24005 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37236 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24006 | .{ .@"0:", ._pd, .cvtps2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 37237 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24007 | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37238 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 24008 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 37239 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 24009 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37240 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24010 | } }, | 37241 | } }, |
| 24011 | }, .{ | 37242 | }, .{ |
| 24012 | .required_features = .{ .x87, null, null, null }, | 37243 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 24013 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37244 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 24014 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, | | |
| 24015 | .patterns = &.{ | 37245 | .patterns = &.{ |
| 24016 | .{ .src = .{ .to_mem, .none } }, | 37246 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24017 | }, | 37247 | }, |
| 24018 | .extra_temps = .{ | 37248 | .extra_temps = .{ |
| 24019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37249 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24020 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 37250 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 24021 | .unused, | 37251 | .unused, |
| 24022 | .unused, | 37252 | .unused, |
| 24023 | .unused, | 37253 | .unused, |
| ... | @@ -24029,46 +37259,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24029,46 +37259,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24029 | .dst_temps = .{.mem}, | 37259 | .dst_temps = .{.mem}, |
| 24030 | .clobbers = .{ .eflags = true }, | 37260 | .clobbers = .{ .eflags = true }, |
| 24031 | .each = .{ .once = &.{ | 37261 | .each = .{ .once = &.{ |
| 24032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37262 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24033 | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 37263 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24034 | .{ ._, .f_p, .st, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, | 37264 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 24035 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 37265 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 24036 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37266 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24037 | } }, | 37267 | } }, |
| 24038 | }, .{ | 37268 | }, .{ |
| 24039 | .required_features = .{ .x87, null, null, null }, | 37269 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 24040 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37270 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 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 } }}, | | |
| 24065 | .patterns = &.{ | 37271 | .patterns = &.{ |
| 24066 | .{ .src = .{ .to_mem, .none } }, | 37272 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24067 | }, | 37273 | }, |
| 24068 | .extra_temps = .{ | 37274 | .extra_temps = .{ |
| 24069 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37275 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24070 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 37276 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24071 | .unused, | 37277 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 24072 | .unused, | 37278 | .unused, |
| 24073 | .unused, | 37279 | .unused, |
| 24074 | .unused, | 37280 | .unused, |
| ... | @@ -24079,106 +37285,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24079,106 +37285,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24079 | .dst_temps = .{.mem}, | 37285 | .dst_temps = .{.mem}, |
| 24080 | .clobbers = .{ .eflags = true }, | 37286 | .clobbers = .{ .eflags = true }, |
| 24081 | .each = .{ .once = &.{ | 37287 | .each = .{ .once = &.{ |
| 24082 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37288 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24083 | .{ .@"0:", .f_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 37289 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 24084 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, | 37290 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 24085 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 37291 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| | 37292 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| | 37293 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 24086 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37294 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24087 | } }, | 37295 | } }, |
| 24088 | }, .{ | 37296 | }, .{ |
| 24089 | .required_features = .{ .sse, null, null, null }, | 37297 | .required_features = .{ .sse, null, null, null }, |
| 24090 | .src_constraints = .{ .{ .scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37298 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 24091 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, | 37299 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 24092 | .patterns = &.{ | 37300 | .patterns = &.{ |
| 24093 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 37301 | .{ .src = .{ .mut_mem, .none, .none } }, |
| 24094 | }, | 37302 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 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, | | |
| 24106 | }, | 37303 | }, |
| 24107 | .dst_temps = .{.{ .ref = .src0 }}, | 37304 | .dst_temps = .{.{ .ref = .src0 }}, |
| 24108 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37305 | .each = .{ .once = &.{} }, |
| 24109 | .each = .{ .once = &.{ | | |
| 24110 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | | |
| 24111 | } }, | | |
| 24112 | }, .{ | 37306 | }, .{ |
| 24113 | .required_features = .{ .avx, null, null, null }, | 37307 | .required_features = .{ .avx, null, null, null }, |
| 24114 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37308 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 24115 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37309 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 24116 | .patterns = &.{ | 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" }, | 37314 | .dst_temps = .{.{ .ref = .src0 }}, |
| 24120 | .extra_temps = .{ | 37315 | .each = .{ .once = &.{} }, |
| 24121 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37316 | }, .{ |
| 24122 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, | 37317 | .required_features = .{ .avx, null, null, null }, |
| 24123 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, | 37318 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 24124 | .unused, | 37319 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, |
| 24125 | .unused, | 37320 | .patterns = &.{ |
| 24126 | .unused, | 37321 | .{ .src = .{ .mem, .none, .none } }, |
| 24127 | .unused, | 37322 | .{ .src = .{ .to_sse, .none, .none } }, |
| 24128 | .unused, | | |
| 24129 | .unused, | | |
| 24130 | }, | 37323 | }, |
| 24131 | .dst_temps = .{.mem}, | 37324 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24132 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 24133 | .each = .{ .once = &.{ | 37325 | .each = .{ .once = &.{ |
| 24134 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37326 | .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ }, |
| 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", ._, ._, ._ }, | | |
| 24140 | } }, | 37327 | } }, |
| 24141 | }, .{ | 37328 | }, .{ |
| 24142 | .required_features = .{ .sse2, null, null, null }, | 37329 | .required_features = .{ .sse2, null, null, null }, |
| 24143 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37330 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 24144 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37331 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, |
| 24145 | .patterns = &.{ | 37332 | .patterns = &.{ |
| 24146 | .{ .src = .{ .to_mem, .none } }, | 37333 | .{ .src = .{ .mem, .none, .none } }, |
| 24147 | }, | 37334 | .{ .src = .{ .to_sse, .none, .none } }, |
| 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, | | |
| 24159 | }, | 37335 | }, |
| 24160 | .dst_temps = .{.mem}, | 37336 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 24161 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 24162 | .each = .{ .once = &.{ | 37337 | .each = .{ .once = &.{ |
| 24163 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37338 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b10_00_10_00), ._ }, |
| 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", ._, ._, ._ }, | | |
| 24169 | } }, | 37339 | } }, |
| 24170 | }, .{ | 37340 | }, .{ |
| 24171 | .required_features = .{ .sse, null, null, null }, | 37341 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 24172 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any }, | 37342 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24173 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 24174 | .patterns = &.{ | 37343 | .patterns = &.{ |
| 24175 | .{ .src = .{ .to_mem, .none } }, | 37344 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24176 | }, | 37345 | }, |
| 24177 | .call_frame = .{ .alignment = .@"16" }, | | |
| 24178 | .extra_temps = .{ | 37346 | .extra_temps = .{ |
| 24179 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37347 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24180 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, | 37348 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24181 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendsftf2" } } }, | 37349 | .unused, |
| 24182 | .unused, | 37350 | .unused, |
| 24183 | .unused, | 37351 | .unused, |
| 24184 | .unused, | 37352 | .unused, |
| ... | @@ -24187,25 +37355,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24187,25 +37355,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24187 | .unused, | 37355 | .unused, |
| 24188 | }, | 37356 | }, |
| 24189 | .dst_temps = .{.mem}, | 37357 | .dst_temps = .{.mem}, |
| 24190 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37358 | .clobbers = .{ .eflags = true }, |
| 24191 | .each = .{ .once = &.{ | 37359 | .each = .{ .once = &.{ |
| 24192 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37360 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24193 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 37361 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24194 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 37362 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 24195 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | | |
| 24196 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 37363 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 24197 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37364 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24198 | } }, | 37365 | } }, |
| 24199 | }, .{ | 37366 | }, .{ |
| 24200 | .required_features = .{ .x87, null, null, null }, | 37367 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 24201 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 37368 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24202 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .tbyte } }}, | | |
| 24203 | .patterns = &.{ | 37369 | .patterns = &.{ |
| 24204 | .{ .src = .{ .to_mem, .none } }, | 37370 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24205 | }, | 37371 | }, |
| 24206 | .extra_temps = .{ | 37372 | .extra_temps = .{ |
| 24207 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 37373 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24208 | .unused, | 37374 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24209 | .unused, | 37375 | .unused, |
| 24210 | .unused, | 37376 | .unused, |
| 24211 | .unused, | 37377 | .unused, |
| ... | @@ -24215,20 +37381,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24215,20 +37381,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24215 | .unused, | 37381 | .unused, |
| 24216 | }, | 37382 | }, |
| 24217 | .dst_temps = .{.mem}, | 37383 | .dst_temps = .{.mem}, |
| | 37384 | .clobbers = .{ .eflags = true }, |
| 24218 | .each = .{ .once = &.{ | 37385 | .each = .{ .once = &.{ |
| 24219 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 37386 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24220 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 37393 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 24224 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 37394 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24225 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, | | |
| 24226 | .patterns = &.{ | 37395 | .patterns = &.{ |
| 24227 | .{ .src = .{ .to_mem, .none } }, | 37396 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24228 | }, | 37397 | }, |
| 24229 | .extra_temps = .{ | 37398 | .extra_temps = .{ |
| 24230 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24231 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 37400 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24232 | .unused, | 37401 | .unused, |
| 24233 | .unused, | 37402 | .unused, |
| 24234 | .unused, | 37403 | .unused, |
| ... | @@ -24240,24 +37409,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24240,24 +37409,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24240 | .dst_temps = .{.mem}, | 37409 | .dst_temps = .{.mem}, |
| 24241 | .clobbers = .{ .eflags = true }, | 37410 | .clobbers = .{ .eflags = true }, |
| 24242 | .each = .{ .once = &.{ | 37411 | .each = .{ .once = &.{ |
| 24243 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37412 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24244 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 37413 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 24245 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, | 37414 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 24246 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 37415 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 24247 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37416 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24248 | } }, | 37417 | } }, |
| 24249 | }, .{ | 37418 | }, .{ |
| 24250 | .required_features = .{ .sse, null, null, null }, | 37419 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 24251 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 37420 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 24252 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 24253 | .patterns = &.{ | 37421 | .patterns = &.{ |
| 24254 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none } }, | 37422 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24255 | }, | 37423 | }, |
| 24256 | .call_frame = .{ .alignment = .@"16" }, | | |
| 24257 | .extra_temps = .{ | 37424 | .extra_temps = .{ |
| 24258 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, | 37425 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24259 | .unused, | 37426 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24260 | .unused, | 37427 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24261 | .unused, | 37428 | .unused, |
| 24262 | .unused, | 37429 | .unused, |
| 24263 | .unused, | 37430 | .unused, |
| ... | @@ -24265,23 +37432,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24265,23 +37432,48 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24265 | .unused, | 37432 | .unused, |
| 24266 | .unused, | 37433 | .unused, |
| 24267 | }, | 37434 | }, |
| 24268 | .dst_temps = .{.{ .ref = .src0 }}, | 37435 | .dst_temps = .{.mem}, |
| 24269 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37436 | .clobbers = .{ .eflags = true }, |
| 24270 | .each = .{ .once = &.{ | 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 | .required_features = .{ .avx, null, null, null }, | 37457 | .required_features = .{ .avx, null, null, null }, |
| 24275 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 37458 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 24276 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37459 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 24277 | .patterns = &.{ | 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 | .extra_temps = .{ | 37473 | .extra_temps = .{ |
| 24282 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37474 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 24283 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 37475 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24284 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, | 37476 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 24285 | .unused, | 37477 | .unused, |
| 24286 | .unused, | 37478 | .unused, |
| 24287 | .unused, | 37479 | .unused, |
| ... | @@ -24290,28 +37482,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24290,28 +37482,58 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24290 | .unused, | 37482 | .unused, |
| 24291 | }, | 37483 | }, |
| 24292 | .dst_temps = .{.mem}, | 37484 | .dst_temps = .{.mem}, |
| 24293 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37485 | .clobbers = .{ .eflags = true }, |
| 24294 | .each = .{ .once = &.{ | 37486 | .each = .{ .once = &.{ |
| 24295 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37487 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 24296 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 37488 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 24297 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 37489 | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 24298 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37490 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 37491 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 24299 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 37492 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 24300 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37493 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 24301 | } }, | 37494 | } }, |
| 24302 | }, .{ | 37495 | }, .{ |
| 24303 | .required_features = .{ .sse2, null, null, null }, | 37496 | .required_features = .{ .sse, null, null, null }, |
| 24304 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 37497 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 24305 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37498 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 24306 | .patterns = &.{ | 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 | .extra_temps = .{ | 37532 | .extra_temps = .{ |
| 24311 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37533 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24312 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 37534 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 24313 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, | 37535 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24314 | .unused, | 37536 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24315 | .unused, | 37537 | .unused, |
| 24316 | .unused, | 37538 | .unused, |
| 24317 | .unused, | 37539 | .unused, |
| ... | @@ -24319,28 +37541,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24319,28 +37541,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24319 | .unused, | 37541 | .unused, |
| 24320 | }, | 37542 | }, |
| 24321 | .dst_temps = .{.mem}, | 37543 | .dst_temps = .{.mem}, |
| 24322 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37544 | .clobbers = .{ .eflags = true }, |
| 24323 | .each = .{ .once = &.{ | 37545 | .each = .{ .once = &.{ |
| 24324 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37546 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 24325 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 37547 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 24326 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 37548 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 24327 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37549 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 24328 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 37550 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 24329 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 37556 | .required_features = .{ .@"64bit", null, null, null }, |
| 24333 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any }, | 37557 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 24334 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37558 | .dst_constraints = .{.any_scalar_int}, |
| 24335 | .patterns = &.{ | 37559 | .patterns = &.{ |
| 24336 | .{ .src = .{ .to_mem, .none } }, | 37560 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24337 | }, | 37561 | }, |
| 24338 | .call_frame = .{ .alignment = .@"16" }, | | |
| 24339 | .extra_temps = .{ | 37562 | .extra_temps = .{ |
| 24340 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37563 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 24341 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, | 37564 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 24342 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extenddftf2" } } }, | 37565 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24343 | .unused, | 37566 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24344 | .unused, | 37567 | .unused, |
| 24345 | .unused, | 37568 | .unused, |
| 24346 | .unused, | 37569 | .unused, |
| ... | @@ -24348,80 +37571,75 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24348,80 +37571,75 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24348 | .unused, | 37571 | .unused, |
| 24349 | }, | 37572 | }, |
| 24350 | .dst_temps = .{.mem}, | 37573 | .dst_temps = .{.mem}, |
| 24351 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37574 | .clobbers = .{ .eflags = true }, |
| 24352 | .each = .{ .once = &.{ | 37575 | .each = .{ .once = &.{ |
| 24353 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37576 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 24354 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, | 37577 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 24355 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 37578 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 24356 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 37579 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 24357 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37580 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 24358 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 37581 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 24359 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 37582 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 37583 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 24360 | } }, | 37584 | } }, |
| 24361 | }, .{ | 37585 | } } else comptime &.{ .{ |
| 24362 | .required_features = .{ .avx, null, null, null }, | 37586 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 24363 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 37587 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 24364 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 24365 | .patterns = &.{ | 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" }, | 37592 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24369 | .extra_temps = .{ | 37593 | .each = .{ .once = &.{ |
| 24370 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 37594 | .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ }, |
| 24371 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, | 37595 | } }, |
| 24372 | .unused, | 37596 | }, .{ |
| 24373 | .unused, | 37597 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 24374 | .unused, | 37598 | .dst_constraints = .{.{ .int = .dword }}, |
| 24375 | .unused, | 37599 | .patterns = &.{ |
| 24376 | .unused, | 37600 | .{ .src = .{ .mem, .none, .none } }, |
| 24377 | .unused, | 37601 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24378 | .unused, | | |
| 24379 | }, | 37602 | }, |
| 24380 | .dst_temps = .{.{ .reg = .xmm0 }}, | 37603 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24381 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 24382 | .each = .{ .once = &.{ | 37604 | .each = .{ .once = &.{ |
| 24383 | .{ ._, .v_dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, | 37605 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 24384 | .{ ._, .v_dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, | | |
| 24385 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | | |
| 24386 | } }, | 37606 | } }, |
| 24387 | }, .{ | 37607 | }, .{ |
| 24388 | .required_features = .{ .sse2, null, null, null }, | 37608 | .required_features = .{ .@"64bit", null, null, null }, |
| 24389 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 37609 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 24390 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, | 37610 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 24391 | .patterns = &.{ | 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" }, | 37615 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24395 | .extra_temps = .{ | 37616 | .each = .{ .once = &.{ |
| 24396 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 37617 | .{ ._, ._, .movsx, .dst0q, .src0b, ._, ._ }, |
| 24397 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, | 37618 | } }, |
| 24398 | .unused, | 37619 | }, .{ |
| 24399 | .unused, | 37620 | .required_features = .{ .@"64bit", null, null, null }, |
| 24400 | .unused, | 37621 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 24401 | .unused, | 37622 | .dst_constraints = .{.{ .int = .qword }}, |
| 24402 | .unused, | 37623 | .patterns = &.{ |
| 24403 | .unused, | 37624 | .{ .src = .{ .mem, .none, .none } }, |
| 24404 | .unused, | 37625 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24405 | }, | 37626 | }, |
| 24406 | .dst_temps = .{.{ .reg = .xmm0 }}, | 37627 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }}, |
| 24407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 24408 | .each = .{ .once = &.{ | 37628 | .each = .{ .once = &.{ |
| 24409 | .{ ._, ._dqa, .mov, .dst0x, .mem(.src0x), ._, ._ }, | 37629 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 24410 | .{ ._, ._dqa, .mov, .mem(.tmp0x), .dst0x, ._, ._ }, | | |
| 24411 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | | |
| 24412 | } }, | 37630 | } }, |
| 24413 | }, .{ | 37631 | }, .{ |
| 24414 | .required_features = .{ .sse, null, null, null }, | 37632 | .required_features = .{ .@"64bit", null, null, null }, |
| 24415 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 37633 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 24416 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .xword } }}, | 37634 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24417 | .patterns = &.{ | 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 | .extra_temps = .{ | 37639 | .extra_temps = .{ |
| 24422 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 37640 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24423 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, | 37641 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24424 | .unused, | 37642 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24425 | .unused, | 37643 | .unused, |
| 24426 | .unused, | 37644 | .unused, |
| 24427 | .unused, | 37645 | .unused, |
| ... | @@ -24429,26 +37647,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24429,26 +37647,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24429 | .unused, | 37647 | .unused, |
| 24430 | .unused, | 37648 | .unused, |
| 24431 | }, | 37649 | }, |
| 24432 | .dst_temps = .{.{ .reg = .xmm0 }}, | 37650 | .dst_temps = .{.mem}, |
| 24433 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37651 | .clobbers = .{ .eflags = true }, |
| 24434 | .each = .{ .once = &.{ | 37652 | .each = .{ .once = &.{ |
| 24435 | .{ ._, ._ps, .mova, .dst0x, .mem(.src0x), ._, ._ }, | 37653 | .{ ._, ._, .movsx, .tmp0q, .src0b, ._, ._ }, |
| 24436 | .{ ._, ._ps, .mova, .mem(.tmp0x), .dst0x, ._, ._ }, | 37654 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24437 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 }, | 37661 | .required_features = .{ .@"64bit", null, null, null }, |
| 24441 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 37662 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 24442 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | 37663 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24443 | .patterns = &.{ | 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 | .extra_temps = .{ | 37668 | .extra_temps = .{ |
| 24448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37669 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 24449 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 37670 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24450 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 37671 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24451 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, | 37672 | .unused, |
| 24452 | .unused, | 37673 | .unused, |
| 24453 | .unused, | 37674 | .unused, |
| 24454 | .unused, | 37675 | .unused, |
| ... | @@ -24456,29 +37677,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24456,29 +37677,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24456 | .unused, | 37677 | .unused, |
| 24457 | }, | 37678 | }, |
| 24458 | .dst_temps = .{.mem}, | 37679 | .dst_temps = .{.mem}, |
| 24459 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37680 | .clobbers = .{ .eflags = true }, |
| 24460 | .each = .{ .once = &.{ | 37681 | .each = .{ .once = &.{ |
| 24461 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37682 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 24462 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 37683 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24463 | .{ ._, .v_dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, | 37684 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 24464 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 37685 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 24465 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37686 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 24466 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 37687 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24467 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 24468 | } }, | 37688 | } }, |
| 24469 | }, .{ | 37689 | }, .{ |
| 24470 | .required_features = .{ .sse2, null, null, null }, | 37690 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 24471 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 37691 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 24472 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 24473 | .patterns = &.{ | 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 | .extra_temps = .{ | 37696 | .extra_temps = .{ |
| 24478 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37697 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 24479 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 37698 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 24480 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 37699 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24481 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, | 37700 | .unused, |
| 24482 | .unused, | 37701 | .unused, |
| 24483 | .unused, | 37702 | .unused, |
| 24484 | .unused, | 37703 | .unused, |
| ... | @@ -24486,29 +37705,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24486,29 +37705,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24486 | .unused, | 37705 | .unused, |
| 24487 | }, | 37706 | }, |
| 24488 | .dst_temps = .{.mem}, | 37707 | .dst_temps = .{.mem}, |
| 24489 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37708 | .clobbers = .{ .eflags = true }, |
| 24490 | .each = .{ .once = &.{ | 37709 | .each = .{ .once = &.{ |
| 24491 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37710 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 24492 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 37711 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24493 | .{ ._, ._dqa, .mov, .mem(.tmp2x), .tmp1x, ._, ._ }, | 37712 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 24494 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 37713 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 24495 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37714 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 24496 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 37715 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 24497 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 24498 | } }, | 37716 | } }, |
| 24499 | }, .{ | 37717 | }, .{ |
| 24500 | .required_features = .{ .sse, null, null, null }, | 37718 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| 24501 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any }, | 37719 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 24502 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, | | |
| 24503 | .patterns = &.{ | 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 | .extra_temps = .{ | 37724 | .extra_temps = .{ |
| 24508 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37725 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 24509 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 37726 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 24510 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 37727 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24511 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__extendxftf2" } } }, | 37728 | .unused, |
| 24512 | .unused, | 37729 | .unused, |
| 24513 | .unused, | 37730 | .unused, |
| 24514 | .unused, | 37731 | .unused, |
| ... | @@ -24516,95 +37733,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24516,95 +37733,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24516 | .unused, | 37733 | .unused, |
| 24517 | }, | 37734 | }, |
| 24518 | .dst_temps = .{.mem}, | 37735 | .dst_temps = .{.mem}, |
| 24519 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 37736 | .clobbers = .{ .eflags = true }, |
| 24520 | .each = .{ .once = &.{ | 37737 | .each = .{ .once = &.{ |
| 24521 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 37738 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 24522 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 37739 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24523 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, | 37740 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 24524 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 37741 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 24525 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 37742 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, |
| 24526 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 37743 | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, |
| 24527 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 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 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 37776 | .each = .{ .once = &.{ |
| 24588 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, | 37777 | .{ ._, ._, .movsx, .dst0q, .src0w, ._, ._ }, |
| 24589 | } }, | 37778 | } }, |
| 24590 | }, .{ | 37779 | }, .{ |
| 24591 | .required_features = .{ .@"64bit", null, null, null }, | 37780 | .required_features = .{ .@"64bit", null, null, null }, |
| | 37781 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 24592 | .dst_constraints = .{.{ .int = .qword }}, | 37782 | .dst_constraints = .{.{ .int = .qword }}, |
| 24593 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 37788 | .each = .{ .once = &.{ |
| 24598 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, | 37789 | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, |
| 24599 | } }, | 37790 | } }, |
| 24600 | }, .{ | 37791 | }, .{ |
| 24601 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 37795 | .patterns = &.{ |
| 24604 | .{ .src = .{ .to_mem, .none } }, | 37796 | .{ .src = .{ .mem, .none, .none } }, |
| | 37797 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24605 | }, | 37798 | }, |
| 24606 | .extra_temps = .{ | 37799 | .extra_temps = .{ |
| 24607 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 37800 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24608 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 37801 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24609 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 37802 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24610 | .unused, | 37803 | .unused, |
| ... | @@ -24615,109 +37808,55 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24615,109 +37808,55 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24615 | .unused, | 37808 | .unused, |
| 24616 | }, | 37809 | }, |
| 24617 | .dst_temps = .{.mem}, | 37810 | .dst_temps = .{.mem}, |
| | 37811 | .clobbers = .{ .eflags = true }, |
| 24618 | .each = .{ .once = &.{ | 37812 | .each = .{ .once = &.{ |
| 24619 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 37813 | .{ ._, ._, .movsx, .tmp0q, .src0w, ._, ._ }, |
| 24620 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 37814 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24621 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, | 37815 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 24622 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 37816 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 24623 | } }, | 37817 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 24624 | }, .{ | 37818 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 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, ._, ._ }, | | |
| 24687 | } }, | 37819 | } }, |
| 24688 | }, .{ | 37820 | }, .{ |
| 24689 | .required_features = .{ .avx2, null, null, null }, | 37821 | .required_features = .{ .@"64bit", null, null, null }, |
| 24690 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any }, | 37822 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 24691 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, | 37823 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24692 | .patterns = &.{ | 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 } }}, | 37828 | .extra_temps = .{ |
| 24696 | .each = .{ .once = &.{ | 37829 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 24697 | .{ ._, .vp_b, .ackssw, .dst0y, .src0y, .dst0y, ._ }, | 37830 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24698 | } }, | 37831 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24699 | }, .{ | 37832 | .unused, |
| 24700 | .required_features = .{ .avx2, null, null, null }, | 37833 | .unused, |
| 24701 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any }, | 37834 | .unused, |
| 24702 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .byte } }}, | 37835 | .unused, |
| 24703 | .patterns = &.{ | 37836 | .unused, |
| 24704 | .{ .src = .{ .to_sse, .none } }, | 37837 | .unused, |
| 24705 | }, | 37838 | }, |
| 24706 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 37839 | .dst_temps = .{.mem}, |
| | 37840 | .clobbers = .{ .eflags = true }, |
| 24707 | .each = .{ .once = &.{ | 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 }, | 37850 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 24712 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 37851 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 24713 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | | |
| 24714 | .patterns = &.{ | 37852 | .patterns = &.{ |
| 24715 | .{ .src = .{ .to_mem, .none } }, | 37853 | .{ .src = .{ .mem, .none, .none } }, |
| | 37854 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24716 | }, | 37855 | }, |
| 24717 | .extra_temps = .{ | 37856 | .extra_temps = .{ |
| 24718 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37857 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 24719 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 37858 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 24720 | .unused, | 37859 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24721 | .unused, | 37860 | .unused, |
| 24722 | .unused, | 37861 | .unused, |
| 24723 | .unused, | 37862 | .unused, |
| ... | @@ -24728,22 +37867,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24728,22 +37867,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24728 | .dst_temps = .{.mem}, | 37867 | .dst_temps = .{.mem}, |
| 24729 | .clobbers = .{ .eflags = true }, | 37868 | .clobbers = .{ .eflags = true }, |
| 24730 | .each = .{ .once = &.{ | 37869 | .each = .{ .once = &.{ |
| 24731 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 37870 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 24732 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 37871 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24733 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 37872 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 24734 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 37873 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 24735 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 37878 | .src_constraints = .{ .{ .int = .word }, .any, .any }, |
| 24739 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | 37879 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 24740 | .patterns = &.{ | 37880 | .patterns = &.{ |
| 24741 | .{ .src = .{ .to_mem, .none } }, | 37881 | .{ .src = .{ .mem, .none, .none } }, |
| | 37882 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24742 | }, | 37883 | }, |
| 24743 | .extra_temps = .{ | 37884 | .extra_temps = .{ |
| 24744 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37885 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 24745 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 37886 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 24746 | .unused, | 37887 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24747 | .unused, | 37888 | .unused, |
| 24748 | .unused, | 37889 | .unused, |
| 24749 | .unused, | 37890 | .unused, |
| ... | @@ -24754,95 +37895,106 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24754,95 +37895,106 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24754 | .dst_temps = .{.mem}, | 37895 | .dst_temps = .{.mem}, |
| 24755 | .clobbers = .{ .eflags = true }, | 37896 | .clobbers = .{ .eflags = true }, |
| 24756 | .each = .{ .once = &.{ | 37897 | .each = .{ .once = &.{ |
| 24757 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 37898 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 24758 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 37899 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24759 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 37900 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 24760 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 37901 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 24761 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 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 }, | 37906 | .required_features = .{ .@"64bit", null, null, null }, |
| 24765 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 37907 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 24766 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, | 37908 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 24767 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 37914 | .each = .{ .once = &.{ |
| 24772 | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, | 37915 | .{ ._, ._d, .movsx, .dst0q, .src0d, ._, ._ }, |
| 24773 | .{ ._, .vp_b, .ackssw, .dst0x, .dst0x, .dst0x, ._ }, | | |
| 24774 | } }, | 37916 | } }, |
| 24775 | }, .{ | 37917 | }, .{ |
| 24776 | .required_features = .{ .avx, null, null, null }, | 37918 | .required_features = .{ .@"64bit", null, null, null }, |
| 24777 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 37919 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 24778 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, | 37920 | .dst_constraints = .{.{ .int = .qword }}, |
| 24779 | .patterns = &.{ | 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 | .each = .{ .once = &.{ | 37926 | .each = .{ .once = &.{ |
| 24784 | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, | 37927 | .{ ._, ._, .mov, .dst0d, .src0d, ._, ._ }, |
| 24785 | .{ ._, .vp_b, .ackusw, .dst0x, .dst0x, .dst0x, ._ }, | | |
| 24786 | } }, | 37928 | } }, |
| 24787 | }, .{ | 37929 | }, .{ |
| 24788 | .required_features = .{ .sse2, null, null, null }, | 37930 | .required_features = .{ .@"64bit", null, null, null }, |
| 24789 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 37931 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 24790 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }}, | 37932 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24791 | .patterns = &.{ | 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 }}, | 37937 | .extra_temps = .{ |
| 24795 | .each = .{ .once = &.{ | 37938 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24796 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, | 37939 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24797 | .{ ._, .p_b, .ackssw, .dst0x, .dst0x, ._, ._ }, | 37940 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24798 | } }, | 37941 | .unused, |
| 24799 | }, .{ | 37942 | .unused, |
| 24800 | .required_features = .{ .sse4_1, null, null, null }, | 37943 | .unused, |
| 24801 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 37944 | .unused, |
| 24802 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, | 37945 | .unused, |
| 24803 | .patterns = &.{ | 37946 | .unused, |
| 24804 | .{ .src = .{ .to_mut_sse, .none } }, | | |
| 24805 | }, | 37947 | }, |
| 24806 | .dst_temps = .{.{ .ref = .src0 }}, | 37948 | .dst_temps = .{.mem}, |
| | 37949 | .clobbers = .{ .eflags = true }, |
| 24807 | .each = .{ .once = &.{ | 37950 | .each = .{ .once = &.{ |
| 24808 | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, | 37951 | .{ ._, ._d, .movsx, .tmp0q, .src0d, ._, ._ }, |
| 24809 | .{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ }, | 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 }, | 37959 | .required_features = .{ .@"64bit", null, null, null }, |
| 24813 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, | 37960 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 24814 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }}, | 37961 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24815 | .patterns = &.{ | 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 } }}, | 37966 | .extra_temps = .{ |
| 24819 | .each = .{ .once = &.{ | 37967 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 24820 | .{ ._, .vp_w, .ackssd, .dst0y, .src0y, .dst0y, ._ }, | 37968 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24821 | .{ ._, .vp_b, .ackssw, .dst0y, .dst0y, .dst0y, ._ }, | 37969 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24822 | } }, | 37970 | .unused, |
| 24823 | }, .{ | 37971 | .unused, |
| 24824 | .required_features = .{ .avx2, null, null, null }, | 37972 | .unused, |
| 24825 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, | 37973 | .unused, |
| 24826 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .byte } }}, | 37974 | .unused, |
| 24827 | .patterns = &.{ | 37975 | .unused, |
| 24828 | .{ .src = .{ .to_sse, .none } }, | | |
| 24829 | }, | 37976 | }, |
| 24830 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 37977 | .dst_temps = .{.mem}, |
| | 37978 | .clobbers = .{ .eflags = true }, |
| 24831 | .each = .{ .once = &.{ | 37979 | .each = .{ .once = &.{ |
| 24832 | .{ ._, .vp_w, .ackusd, .dst0y, .src0y, .dst0y, ._ }, | 37980 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 24833 | .{ ._, .vp_b, .ackusw, .dst0y, .dst0y, .dst0y, ._ }, | 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 }, | 37988 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 24837 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 37989 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 24838 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | | |
| 24839 | .patterns = &.{ | 37990 | .patterns = &.{ |
| 24840 | .{ .src = .{ .to_mem, .none } }, | 37991 | .{ .src = .{ .mem, .none, .none } }, |
| | 37992 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24841 | }, | 37993 | }, |
| 24842 | .extra_temps = .{ | 37994 | .extra_temps = .{ |
| 24843 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 37995 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 24844 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 37996 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 24845 | .unused, | 37997 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24846 | .unused, | 37998 | .unused, |
| 24847 | .unused, | 37999 | .unused, |
| 24848 | .unused, | 38000 | .unused, |
| ... | @@ -24853,22 +38005,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24853,22 +38005,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24853 | .dst_temps = .{.mem}, | 38005 | .dst_temps = .{.mem}, |
| 24854 | .clobbers = .{ .eflags = true }, | 38006 | .clobbers = .{ .eflags = true }, |
| 24855 | .each = .{ .once = &.{ | 38007 | .each = .{ .once = &.{ |
| 24856 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38008 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 24857 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 38009 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24858 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 38010 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 24859 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 38011 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 24860 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 38016 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| 24864 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | 38017 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, |
| 24865 | .patterns = &.{ | 38018 | .patterns = &.{ |
| 24866 | .{ .src = .{ .to_mem, .none } }, | 38019 | .{ .src = .{ .mem, .none, .none } }, |
| | 38020 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24867 | }, | 38021 | }, |
| 24868 | .extra_temps = .{ | 38022 | .extra_temps = .{ |
| 24869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38023 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 24870 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 38024 | .{ .type = .usize, .kind = .{ .reg = .edi } }, |
| 24871 | .unused, | 38025 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24872 | .unused, | 38026 | .unused, |
| 24873 | .unused, | 38027 | .unused, |
| 24874 | .unused, | 38028 | .unused, |
| ... | @@ -24879,23 +38033,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24879,23 +38033,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24879 | .dst_temps = .{.mem}, | 38033 | .dst_temps = .{.mem}, |
| 24880 | .clobbers = .{ .eflags = true }, | 38034 | .clobbers = .{ .eflags = true }, |
| 24881 | .each = .{ .once = &.{ | 38035 | .each = .{ .once = &.{ |
| 24882 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38036 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 24883 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 38037 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24884 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 38038 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, |
| 24885 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 38039 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 24886 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 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 }, | 38044 | .required_features = .{ .@"64bit", null, null, null }, |
| 24890 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 38045 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 24891 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | 38046 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24892 | .patterns = &.{ | 38047 | .patterns = &.{ |
| 24893 | .{ .src = .{ .to_mem, .none } }, | 38048 | .{ .src = .{ .mem, .none, .none } }, |
| | 38049 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24894 | }, | 38050 | }, |
| 24895 | .extra_temps = .{ | 38051 | .extra_temps = .{ |
| 24896 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38052 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24897 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 38053 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24898 | .unused, | 38054 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24899 | .unused, | 38055 | .unused, |
| 24900 | .unused, | 38056 | .unused, |
| 24901 | .unused, | 38057 | .unused, |
| ... | @@ -24906,22 +38062,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24906,22 +38062,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24906 | .dst_temps = .{.mem}, | 38062 | .dst_temps = .{.mem}, |
| 24907 | .clobbers = .{ .eflags = true }, | 38063 | .clobbers = .{ .eflags = true }, |
| 24908 | .each = .{ .once = &.{ | 38064 | .each = .{ .once = &.{ |
| 24909 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38065 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| 24910 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 38066 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24911 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 38067 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 24912 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 38068 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 24913 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 38073 | .required_features = .{ .@"64bit", null, null, null }, |
| 24917 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | 38074 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| | 38075 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24918 | .patterns = &.{ | 38076 | .patterns = &.{ |
| 24919 | .{ .src = .{ .to_mem, .none } }, | 38077 | .{ .src = .{ .mem, .none, .none } }, |
| | 38078 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 24920 | }, | 38079 | }, |
| 24921 | .extra_temps = .{ | 38080 | .extra_temps = .{ |
| 24922 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38081 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 24923 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 38082 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24924 | .unused, | 38083 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24925 | .unused, | 38084 | .unused, |
| 24926 | .unused, | 38085 | .unused, |
| 24927 | .unused, | 38086 | .unused, |
| ... | @@ -24932,24 +38091,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24932,24 +38091,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24932 | .dst_temps = .{.mem}, | 38091 | .dst_temps = .{.mem}, |
| 24933 | .clobbers = .{ .eflags = true }, | 38092 | .clobbers = .{ .eflags = true }, |
| 24934 | .each = .{ .once = &.{ | 38093 | .each = .{ .once = &.{ |
| 24935 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38094 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| 24936 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 38095 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24937 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 38096 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 24938 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 38097 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 24939 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 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 }, | 38102 | .required_features = .{ .@"64bit", null, null, null }, |
| 24943 | .src_constraints = .{ .any_scalar_int, .any }, | 38103 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 24944 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | 38104 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 24945 | .patterns = &.{ | 38105 | .patterns = &.{ |
| 24946 | .{ .src = .{ .to_mem, .none } }, | 38106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24947 | }, | 38107 | }, |
| 24948 | .extra_temps = .{ | 38108 | .extra_temps = .{ |
| 24949 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38109 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 24950 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38110 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24951 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 38111 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24952 | .unused, | 38112 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 24953 | .unused, | 38113 | .unused, |
| 24954 | .unused, | 38114 | .unused, |
| 24955 | .unused, | 38115 | .unused, |
| ... | @@ -24959,25 +38119,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24959,25 +38119,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24959 | .dst_temps = .{.mem}, | 38119 | .dst_temps = .{.mem}, |
| 24960 | .clobbers = .{ .eflags = true }, | 38120 | .clobbers = .{ .eflags = true }, |
| 24961 | .each = .{ .once = &.{ | 38121 | .each = .{ .once = &.{ |
| 24962 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38122 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 24963 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 38123 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24964 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 38124 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 24965 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 38125 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 24966 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 38126 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, |
| 24967 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 38127 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 24968 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 38133 | .required_features = .{ .@"64bit", null, null, null }, |
| 24972 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, | 38134 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| | 38135 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, |
| 24973 | .patterns = &.{ | 38136 | .patterns = &.{ |
| 24974 | .{ .src = .{ .to_mem, .none } }, | 38137 | .{ .src = .{ .to_mem, .none, .none } }, |
| 24975 | }, | 38138 | }, |
| 24976 | .extra_temps = .{ | 38139 | .extra_temps = .{ |
| 24977 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38140 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 24978 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38141 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 24979 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 38142 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 24980 | .unused, | 38143 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 24981 | .unused, | 38144 | .unused, |
| 24982 | .unused, | 38145 | .unused, |
| 24983 | .unused, | 38146 | .unused, |
| ... | @@ -24987,135 +38150,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24987,135 +38150,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24987 | .dst_temps = .{.mem}, | 38150 | .dst_temps = .{.mem}, |
| 24988 | .clobbers = .{ .eflags = true }, | 38151 | .clobbers = .{ .eflags = true }, |
| 24989 | .each = .{ .once = &.{ | 38152 | .each = .{ .once = &.{ |
| 24990 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38153 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 24991 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 38154 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 24992 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 38155 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 24993 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 38156 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 24994 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 38157 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 24995 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 38158 | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, |
| 24996 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 38162 | .required_features = .{ .avx, null, null, null }, |
| 25020 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 38163 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25021 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, | 38164 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25022 | .patterns = &.{ | 38165 | .patterns = &.{ |
| 25023 | .{ .src = .{ .to_sse, .none } }, | 38166 | .{ .src = .{ .mem, .none, .none } }, |
| | 38167 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25024 | }, | 38168 | }, |
| 25025 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38169 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25026 | .each = .{ .once = &.{ | 38170 | .each = .{ .once = &.{ |
| 25027 | .{ ._, .vp_w, .ackssd, .dst0x, .src0x, .dst0x, ._ }, | 38171 | .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ }, |
| 25028 | } }, | 38172 | } }, |
| 25029 | }, .{ | 38173 | }, .{ |
| 25030 | .required_features = .{ .avx, null, null, null }, | 38174 | .required_features = .{ .avx, null, null, null }, |
| 25031 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 38175 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25032 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .word } }}, | 38176 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25033 | .patterns = &.{ | 38177 | .patterns = &.{ |
| 25034 | .{ .src = .{ .to_sse, .none } }, | 38178 | .{ .src = .{ .mem, .none, .none } }, |
| | 38179 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25035 | }, | 38180 | }, |
| 25036 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38181 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25037 | .each = .{ .once = &.{ | 38182 | .each = .{ .once = &.{ |
| 25038 | .{ ._, .vp_w, .ackusd, .dst0x, .src0x, .dst0x, ._ }, | 38183 | .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ }, |
| 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, ._, ._ }, | | |
| 25050 | } }, | 38184 | } }, |
| 25051 | }, .{ | 38185 | }, .{ |
| 25052 | .required_features = .{ .sse4_1, null, null, null }, | 38186 | .required_features = .{ .sse4_1, null, null, null }, |
| 25053 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 38187 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .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 }, | | |
| 25065 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 38188 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25066 | .patterns = &.{ | 38189 | .patterns = &.{ |
| 25067 | .{ .src = .{ .to_sse, .none } }, | 38190 | .{ .src = .{ .mem, .none, .none } }, |
| | 38191 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25068 | }, | 38192 | }, |
| 25069 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38193 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25070 | .each = .{ .once = &.{ | 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 }, | 38198 | .required_features = .{ .sse4_1, null, null, null }, |
| 25075 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, | 38199 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25076 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, | 38200 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25077 | .patterns = &.{ | 38201 | .patterns = &.{ |
| 25078 | .{ .src = .{ .to_sse, .none } }, | 38202 | .{ .src = .{ .mem, .none, .none } }, |
| | 38203 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25079 | }, | 38204 | }, |
| 25080 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38205 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25081 | .each = .{ .once = &.{ | 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 }, | 38210 | .required_features = .{ .sse2, null, null, null }, |
| 25086 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, | 38211 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 38212 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 25087 | .patterns = &.{ | 38213 | .patterns = &.{ |
| 25088 | .{ .src = .{ .to_mem, .none } }, | 38214 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25089 | }, | 38215 | }, |
| 25090 | .extra_temps = .{ | 38216 | .extra_temps = .{ |
| 25091 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38217 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 25092 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 25093 | .unused, | | |
| 25094 | .unused, | | |
| 25095 | .unused, | | |
| 25096 | .unused, | | |
| 25097 | .unused, | | |
| 25098 | .unused, | | |
| 25099 | .unused, | 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 | .unused, | 38219 | .unused, |
| 25120 | .unused, | 38220 | .unused, |
| 25121 | .unused, | 38221 | .unused, |
| ... | @@ -25124,51 +38224,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25124,51 +38224,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25124 | .unused, | 38224 | .unused, |
| 25125 | .unused, | 38225 | .unused, |
| 25126 | }, | 38226 | }, |
| 25127 | .dst_temps = .{.mem}, | 38227 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25128 | .clobbers = .{ .eflags = true }, | | |
| 25129 | .each = .{ .once = &.{ | 38228 | .each = .{ .once = &.{ |
| 25130 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38229 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 25131 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 38230 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 25132 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 38231 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 25133 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 25134 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 25135 | } }, | 38232 | } }, |
| 25136 | }, .{ | 38233 | }, .{ |
| 25137 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, | 38234 | .required_features = .{ .sse2, null, null, null }, |
| 25138 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, | 38235 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 38236 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25139 | .patterns = &.{ | 38237 | .patterns = &.{ |
| 25140 | .{ .src = .{ .to_mem, .none } }, | 38238 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25141 | }, | 38239 | }, |
| 25142 | .extra_temps = .{ | 38240 | .extra_temps = .{ |
| 25143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38241 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 25144 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | | |
| 25145 | .unused, | | |
| 25146 | .unused, | | |
| 25147 | .unused, | | |
| 25148 | .unused, | | |
| 25149 | .unused, | | |
| 25150 | .unused, | 38242 | .unused, |
| 25151 | .unused, | 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 | .unused, | 38244 | .unused, |
| 25173 | .unused, | 38245 | .unused, |
| 25174 | .unused, | 38246 | .unused, |
| ... | @@ -25176,70 +38248,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25176,70 +38248,45 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25176 | .unused, | 38248 | .unused, |
| 25177 | .unused, | 38249 | .unused, |
| 25178 | }, | 38250 | }, |
| 25179 | .dst_temps = .{.mem}, | 38251 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25180 | .clobbers = .{ .eflags = true }, | | |
| 25181 | .each = .{ .once = &.{ | 38252 | .each = .{ .once = &.{ |
| 25182 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38253 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 25183 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 38254 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 25189 | } }, | 38255 | } }, |
| 25190 | }, .{ | 38256 | }, .{ |
| 25191 | .required_features = .{ .sse, null, null, null }, | 38257 | .required_features = .{ .avx2, null, null, null }, |
| 25192 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 38258 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 25193 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 38259 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 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 } }}, | | |
| 25214 | .patterns = &.{ | 38260 | .patterns = &.{ |
| 25215 | .{ .src = .{ .mem, .none } }, | 38261 | .{ .src = .{ .mem, .none, .none } }, |
| 25216 | .{ .src = .{ .to_sse, .none } }, | 38262 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25217 | }, | 38263 | }, |
| 25218 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38264 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25219 | .each = .{ .once = &.{ | 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 }, | 38269 | .required_features = .{ .avx2, null, null, null }, |
| 25224 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, | 38270 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 25225 | .dst_constraints = .{.{ .scalar_int = .{ .of = .qword, .is = .dword } }}, | 38271 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, |
| 25226 | .patterns = &.{ | 38272 | .patterns = &.{ |
| 25227 | .{ .src = .{ .mem, .none } }, | 38273 | .{ .src = .{ .mem, .none, .none } }, |
| 25228 | .{ .src = .{ .to_sse, .none } }, | 38274 | .{ .src = .{ .to_sse, .none, .none } }, |
| 25229 | }, | 38275 | }, |
| 25230 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38276 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 25231 | .each = .{ .once = &.{ | 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 }, | 38281 | .required_features = .{ .avx2, null, null, null }, |
| 25236 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 38284 | .patterns = &.{ |
| 25238 | .{ .src = .{ .to_mem, .none } }, | 38285 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25239 | }, | 38286 | }, |
| 25240 | .extra_temps = .{ | 38287 | .extra_temps = .{ |
| 25241 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38288 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25242 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38289 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 25243 | .unused, | 38290 | .unused, |
| 25244 | .unused, | 38291 | .unused, |
| 25245 | .unused, | 38292 | .unused, |
| ... | @@ -25251,21 +38298,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25251,21 +38298,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25251 | .dst_temps = .{.mem}, | 38298 | .dst_temps = .{.mem}, |
| 25252 | .clobbers = .{ .eflags = true }, | 38299 | .clobbers = .{ .eflags = true }, |
| 25253 | .each = .{ .once = &.{ | 38300 | .each = .{ .once = &.{ |
| 25254 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38301 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25255 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 38302 | .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25256 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 38303 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 25257 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 38304 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 25258 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 38305 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25259 | } }, | 38306 | } }, |
| 25260 | }, .{ | 38307 | }, .{ |
| 25261 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, | 38308 | .required_features = .{ .avx2, null, null, null }, |
| 25262 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, | 38309 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 38310 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }}, |
| 25263 | .patterns = &.{ | 38311 | .patterns = &.{ |
| 25264 | .{ .src = .{ .to_mem, .none } }, | 38312 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25265 | }, | 38313 | }, |
| 25266 | .extra_temps = .{ | 38314 | .extra_temps = .{ |
| 25267 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38315 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25268 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38316 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 25269 | .unused, | 38317 | .unused, |
| 25270 | .unused, | 38318 | .unused, |
| 25271 | .unused, | 38319 | .unused, |
| ... | @@ -25277,48 +38325,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25277,48 +38325,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25277 | .dst_temps = .{.mem}, | 38325 | .dst_temps = .{.mem}, |
| 25278 | .clobbers = .{ .eflags = true }, | 38326 | .clobbers = .{ .eflags = true }, |
| 25279 | .each = .{ .once = &.{ | 38327 | .each = .{ .once = &.{ |
| 25280 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38328 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25281 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 38329 | .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25282 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 38330 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 25283 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 38331 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 25284 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 38332 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25285 | } }, | 38333 | } }, |
| 25286 | }, .{ | 38334 | }, .{ |
| 25287 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any }, | 38335 | .required_features = .{ .avx, null, null, null }, |
| 25288 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 38338 | .patterns = &.{ |
| 25290 | .{ .src = .{ .to_mem, .none } }, | 38339 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25291 | }, | 38340 | }, |
| 25292 | .extra_temps = .{ | 38341 | .extra_temps = .{ |
| 25293 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38342 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25294 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38343 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 25295 | .unused, | | |
| 25296 | .unused, | | |
| 25297 | .unused, | | |
| 25298 | .unused, | | |
| 25299 | .unused, | | |
| 25300 | .unused, | | |
| 25301 | .unused, | 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 | .unused, | 38345 | .unused, |
| 25323 | .unused, | 38346 | .unused, |
| 25324 | .unused, | 38347 | .unused, |
| ... | @@ -25329,45 +38352,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25329,45 +38352,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25329 | .dst_temps = .{.mem}, | 38352 | .dst_temps = .{.mem}, |
| 25330 | .clobbers = .{ .eflags = true }, | 38353 | .clobbers = .{ .eflags = true }, |
| 25331 | .each = .{ .once = &.{ | 38354 | .each = .{ .once = &.{ |
| 25332 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38355 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25333 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 38356 | .{ .@"0:", .vp_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25334 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 38357 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25335 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 38358 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25336 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | | |
| 25337 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | | |
| 25338 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 38362 | .required_features = .{ .avx, null, null, null }, |
| 25352 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any }, | 38363 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25353 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, | 38364 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, |
| 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 } }}, | | |
| 25364 | .patterns = &.{ | 38365 | .patterns = &.{ |
| 25365 | .{ .src = .{ .to_mem, .none } }, | 38366 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25366 | }, | 38367 | }, |
| 25367 | .extra_temps = .{ | 38368 | .extra_temps = .{ |
| 25368 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 38369 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25369 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38370 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 25370 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 38371 | .unused, |
| 25371 | .unused, | 38372 | .unused, |
| 25372 | .unused, | 38373 | .unused, |
| 25373 | .unused, | 38374 | .unused, |
| ... | @@ -25378,56 +38379,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25378,56 +38379,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25378 | .dst_temps = .{.mem}, | 38379 | .dst_temps = .{.mem}, |
| 25379 | .clobbers = .{ .eflags = true }, | 38380 | .clobbers = .{ .eflags = true }, |
| 25380 | .each = .{ .once = &.{ | 38381 | .each = .{ .once = &.{ |
| 25381 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 38382 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25382 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 38383 | .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25383 | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, | 38384 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25384 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, | | |
| 25385 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | | |
| 25386 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 38385 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25387 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 38386 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25388 | } }, | 38387 | } }, |
| 25389 | }, .{ | 38388 | }, .{ |
| 25390 | .required_features = .{ .sse, null, null, null }, | 38389 | .required_features = .{ .sse4_1, null, null, null }, |
| 25391 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .xword } }, .any }, | 38390 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25392 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 38391 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 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}, | | |
| 25423 | .patterns = &.{ | 38392 | .patterns = &.{ |
| 25424 | .{ .src = .{ .to_mem, .none } }, | 38393 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25425 | }, | 38394 | }, |
| 25426 | .extra_temps = .{ | 38395 | .extra_temps = .{ |
| 25427 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25428 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 38397 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 25429 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38398 | .unused, |
| 25430 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38399 | .unused, |
| 25431 | .unused, | 38400 | .unused, |
| 25432 | .unused, | 38401 | .unused, |
| 25433 | .unused, | 38402 | .unused, |
| ... | @@ -25437,27 +38406,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25437,27 +38406,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25437 | .dst_temps = .{.mem}, | 38406 | .dst_temps = .{.mem}, |
| 25438 | .clobbers = .{ .eflags = true }, | 38407 | .clobbers = .{ .eflags = true }, |
| 25439 | .each = .{ .once = &.{ | 38408 | .each = .{ .once = &.{ |
| 25440 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 38409 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25441 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 38410 | .{ .@"0:", .p_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25442 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 38411 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25443 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, | 38412 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25444 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 38413 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25445 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, | | |
| 25446 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | | |
| 25447 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, | | |
| 25448 | } }, | 38414 | } }, |
| 25449 | }, .{ | 38415 | }, .{ |
| 25450 | .required_features = .{ .@"64bit", null, null, null }, | 38416 | .required_features = .{ .sse4_1, null, null, null }, |
| 25451 | .src_constraints = .{ .any_scalar_int, .any }, | 38417 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 25452 | .dst_constraints = .{.any_scalar_int}, | 38418 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, |
| 25453 | .patterns = &.{ | 38419 | .patterns = &.{ |
| 25454 | .{ .src = .{ .to_mem, .none } }, | 38420 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25455 | }, | 38421 | }, |
| 25456 | .extra_temps = .{ | 38422 | .extra_temps = .{ |
| 25457 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 38423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25458 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 38424 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 25459 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38425 | .unused, |
| 25460 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38426 | .unused, |
| 25461 | .unused, | 38427 | .unused, |
| 25462 | .unused, | 38428 | .unused, |
| 25463 | .unused, | 38429 | .unused, |
| ... | @@ -25467,73 +38433,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25467,73 +38433,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25467 | .dst_temps = .{.mem}, | 38433 | .dst_temps = .{.mem}, |
| 25468 | .clobbers = .{ .eflags = true }, | 38434 | .clobbers = .{ .eflags = true }, |
| 25469 | .each = .{ .once = &.{ | 38435 | .each = .{ .once = &.{ |
| 25470 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 38436 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25471 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 38437 | .{ .@"0:", .p_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25472 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 38438 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25473 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, | 38439 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25474 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 38440 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._ }, | | |
| 25524 | } }, | 38441 | } }, |
| 25525 | }, .{ | 38442 | }, .{ |
| 25526 | .required_features = .{ .@"64bit", null, null, null }, | 38443 | .required_features = .{ .slow_incdec, null, null, null }, |
| 25527 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, | 38444 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 25528 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 38445 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 25529 | .patterns = &.{ | 38446 | .patterns = &.{ |
| 25530 | .{ .src = .{ .mem, .none } }, | 38447 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25531 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25532 | }, | 38448 | }, |
| 25533 | .extra_temps = .{ | 38449 | .extra_temps = .{ |
| 25534 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 38450 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25535 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38451 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 25536 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38452 | .unused, |
| 25537 | .unused, | 38453 | .unused, |
| 25538 | .unused, | 38454 | .unused, |
| 25539 | .unused, | 38455 | .unused, |
| ... | @@ -25544,25 +38460,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25544,25 +38460,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25544 | .dst_temps = .{.mem}, | 38460 | .dst_temps = .{.mem}, |
| 25545 | .clobbers = .{ .eflags = true }, | 38461 | .clobbers = .{ .eflags = true }, |
| 25546 | .each = .{ .once = &.{ | 38462 | .each = .{ .once = &.{ |
| 25547 | .{ ._, ._, .movsx, .tmp0q, .src0b, ._, ._ }, | 38463 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25548 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38464 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25549 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38465 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25550 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 38466 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 25551 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38467 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25552 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25553 | } }, | 38468 | } }, |
| 25554 | }, .{ | 38469 | }, .{ |
| 25555 | .required_features = .{ .@"64bit", null, null, null }, | 38470 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 25556 | .src_constraints = .{ .{ .int = .byte }, .any }, | 38471 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 25557 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, | | |
| 25558 | .patterns = &.{ | 38472 | .patterns = &.{ |
| 25559 | .{ .src = .{ .mem, .none } }, | 38473 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25560 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25561 | }, | 38474 | }, |
| 25562 | .extra_temps = .{ | 38475 | .extra_temps = .{ |
| 25563 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 38476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25564 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38477 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 25565 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38478 | .unused, |
| 25566 | .unused, | 38479 | .unused, |
| 25567 | .unused, | 38480 | .unused, |
| 25568 | .unused, | 38481 | .unused, |
| ... | @@ -25573,24 +38486,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25573,24 +38486,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25573 | .dst_temps = .{.mem}, | 38486 | .dst_temps = .{.mem}, |
| 25574 | .clobbers = .{ .eflags = true }, | 38487 | .clobbers = .{ .eflags = true }, |
| 25575 | .each = .{ .once = &.{ | 38488 | .each = .{ .once = &.{ |
| 25576 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 38489 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25577 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38490 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25578 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38491 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25579 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 38492 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 25580 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38493 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25581 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25582 | } }, | 38494 | } }, |
| 25583 | }, .{ | 38495 | }, .{ |
| 25584 | .src_constraints = .{ .{ .signed_int = .byte }, .any }, | 38496 | .required_features = .{ .slow_incdec, null, null, null }, |
| 25585 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 38497 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| | 38498 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 25586 | .patterns = &.{ | 38499 | .patterns = &.{ |
| 25587 | .{ .src = .{ .mem, .none } }, | 38500 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25588 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25589 | }, | 38501 | }, |
| 25590 | .extra_temps = .{ | 38502 | .extra_temps = .{ |
| 25591 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 38503 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25592 | .{ .type = .usize, .kind = .{ .reg = .edi } }, | 38504 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 25593 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38505 | .unused, |
| 25594 | .unused, | 38506 | .unused, |
| 25595 | .unused, | 38507 | .unused, |
| 25596 | .unused, | 38508 | .unused, |
| ... | @@ -25601,24 +38513,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25601,24 +38513,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25601 | .dst_temps = .{.mem}, | 38513 | .dst_temps = .{.mem}, |
| 25602 | .clobbers = .{ .eflags = true }, | 38514 | .clobbers = .{ .eflags = true }, |
| 25603 | .each = .{ .once = &.{ | 38515 | .each = .{ .once = &.{ |
| 25604 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 38516 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25605 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38517 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25606 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, | 38518 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25607 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, | 38519 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 25608 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, | 38520 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25609 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25610 | } }, | 38521 | } }, |
| 25611 | }, .{ | 38522 | }, .{ |
| 25612 | .src_constraints = .{ .{ .int = .byte }, .any }, | 38523 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 25613 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, | 38524 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 25614 | .patterns = &.{ | 38525 | .patterns = &.{ |
| 25615 | .{ .src = .{ .mem, .none } }, | 38526 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25616 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25617 | }, | 38527 | }, |
| 25618 | .extra_temps = .{ | 38528 | .extra_temps = .{ |
| 25619 | .{ .type = .u32, .kind = .{ .reg = .eax } }, | 38529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25620 | .{ .type = .usize, .kind = .{ .reg = .edi } }, | 38530 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 25621 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38531 | .unused, |
| 25622 | .unused, | 38532 | .unused, |
| 25623 | .unused, | 38533 | .unused, |
| 25624 | .unused, | 38534 | .unused, |
| ... | @@ -25629,71 +38539,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25629,71 +38539,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25629 | .dst_temps = .{.mem}, | 38539 | .dst_temps = .{.mem}, |
| 25630 | .clobbers = .{ .eflags = true }, | 38540 | .clobbers = .{ .eflags = true }, |
| 25631 | .each = .{ .once = &.{ | 38541 | .each = .{ .once = &.{ |
| 25632 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 38542 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25633 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38543 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25634 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, | 38544 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 25635 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 38545 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 25636 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, | 38546 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25637 | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, | | |
| 25638 | } }, | 38547 | } }, |
| 25639 | }, .{ | 38548 | }, .{ |
| 25640 | .src_constraints = .{ .{ .signed_int = .word }, .any }, | 38549 | .required_features = .{ .avx, null, null, null }, |
| 25641 | .dst_constraints = .{.{ .signed_int = .dword }}, | 38550 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 38551 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25642 | .patterns = &.{ | 38552 | .patterns = &.{ |
| 25643 | .{ .src = .{ .mem, .none } }, | 38553 | .{ .src = .{ .mem, .none, .none } }, |
| 25644 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 38557 | .each = .{ .once = &.{ |
| 25648 | .{ ._, ._, .movsx, .dst0d, .src0w, ._, ._ }, | 38558 | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 25649 | } }, | 38559 | } }, |
| 25650 | }, .{ | 38560 | }, .{ |
| 25651 | .src_constraints = .{ .{ .int = .word }, .any }, | 38561 | .required_features = .{ .avx, null, null, null }, |
| 25652 | .dst_constraints = .{.{ .int = .dword }}, | 38562 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 38563 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25653 | .patterns = &.{ | 38564 | .patterns = &.{ |
| 25654 | .{ .src = .{ .mem, .none } }, | 38565 | .{ .src = .{ .mem, .none, .none } }, |
| 25655 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 38569 | .each = .{ .once = &.{ |
| 25659 | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, | 38570 | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 25660 | } }, | 38571 | } }, |
| 25661 | }, .{ | 38572 | }, .{ |
| 25662 | .required_features = .{ .@"64bit", null, null, null }, | 38573 | .required_features = .{ .sse4_1, null, null, null }, |
| 25663 | .src_constraints = .{ .{ .signed_int = .word }, .any }, | 38574 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 25664 | .dst_constraints = .{.{ .signed_int = .qword }}, | 38575 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25665 | .patterns = &.{ | 38576 | .patterns = &.{ |
| 25666 | .{ .src = .{ .mem, .none } }, | 38577 | .{ .src = .{ .mem, .none, .none } }, |
| 25667 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 38581 | .each = .{ .once = &.{ |
| 25671 | .{ ._, ._, .movsx, .dst0q, .src0w, ._, ._ }, | 38582 | .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 25672 | } }, | 38583 | } }, |
| 25673 | }, .{ | 38584 | }, .{ |
| 25674 | .required_features = .{ .@"64bit", null, null, null }, | 38585 | .required_features = .{ .sse4_1, null, null, null }, |
| 25675 | .src_constraints = .{ .{ .int = .word }, .any }, | 38586 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 25676 | .dst_constraints = .{.{ .int = .qword }}, | 38587 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25677 | .patterns = &.{ | 38588 | .patterns = &.{ |
| 25678 | .{ .src = .{ .mem, .none } }, | 38589 | .{ .src = .{ .mem, .none, .none } }, |
| 25679 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 38593 | .each = .{ .once = &.{ |
| 25683 | .{ ._, ._, .movzx, .dst0d, .src0w, ._, ._ }, | 38594 | .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 25684 | } }, | 38595 | } }, |
| 25685 | }, .{ | 38596 | }, .{ |
| 25686 | .required_features = .{ .@"64bit", null, null, null }, | 38597 | .required_features = .{ .sse2, null, null, null }, |
| 25687 | .src_constraints = .{ .{ .signed_int = .word }, .any }, | 38598 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 25688 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 38599 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25689 | .patterns = &.{ | 38600 | .patterns = &.{ |
| 25690 | .{ .src = .{ .mem, .none } }, | 38601 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25691 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25692 | }, | 38602 | }, |
| 25693 | .extra_temps = .{ | 38603 | .extra_temps = .{ |
| 25694 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 38604 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 25695 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38605 | .unused, |
| 25696 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38606 | .unused, |
| 25697 | .unused, | 38607 | .unused, |
| 25698 | .unused, | 38608 | .unused, |
| 25699 | .unused, | 38609 | .unused, |
| ... | @@ -25701,28 +38611,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25701,28 +38611,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25701 | .unused, | 38611 | .unused, |
| 25702 | .unused, | 38612 | .unused, |
| 25703 | }, | 38613 | }, |
| 25704 | .dst_temps = .{.mem}, | 38614 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25705 | .clobbers = .{ .eflags = true }, | | |
| 25706 | .each = .{ .once = &.{ | 38615 | .each = .{ .once = &.{ |
| 25707 | .{ ._, ._, .movsx, .tmp0q, .src0w, ._, ._ }, | 38616 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 25708 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38617 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 25709 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38618 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 25710 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 38619 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 25711 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38620 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 25712 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25713 | } }, | 38621 | } }, |
| 25714 | }, .{ | 38622 | }, .{ |
| 25715 | .required_features = .{ .@"64bit", null, null, null }, | 38623 | .required_features = .{ .sse2, null, null, null }, |
| 25716 | .src_constraints = .{ .{ .int = .word }, .any }, | 38624 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 25717 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, | 38625 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25718 | .patterns = &.{ | 38626 | .patterns = &.{ |
| 25719 | .{ .src = .{ .mem, .none } }, | 38627 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 25720 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25721 | }, | 38628 | }, |
| 25722 | .extra_temps = .{ | 38629 | .extra_temps = .{ |
| 25723 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 38630 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 25724 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38631 | .unused, |
| 25725 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38632 | .unused, |
| 25726 | .unused, | 38633 | .unused, |
| 25727 | .unused, | 38634 | .unused, |
| 25728 | .unused, | 38635 | .unused, |
| ... | @@ -25730,27 +38637,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25730,27 +38637,47 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25730 | .unused, | 38637 | .unused, |
| 25731 | .unused, | 38638 | .unused, |
| 25732 | }, | 38639 | }, |
| 25733 | .dst_temps = .{.mem}, | 38640 | .dst_temps = .{.{ .ref = .src0 }}, |
| 25734 | .clobbers = .{ .eflags = true }, | | |
| 25735 | .each = .{ .once = &.{ | 38641 | .each = .{ .once = &.{ |
| 25736 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 38642 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 25737 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38643 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 25738 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38644 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 25739 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | | |
| 25740 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | | |
| 25741 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25742 | } }, | 38645 | } }, |
| 25743 | }, .{ | 38646 | }, .{ |
| 25744 | .src_constraints = .{ .{ .signed_int = .word }, .any }, | 38647 | .required_features = .{ .avx2, null, null, null }, |
| 25745 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 38674 | .patterns = &.{ |
| 25747 | .{ .src = .{ .mem, .none } }, | 38675 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25748 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25749 | }, | 38676 | }, |
| 25750 | .extra_temps = .{ | 38677 | .extra_temps = .{ |
| 25751 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 38678 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25752 | .{ .type = .usize, .kind = .{ .reg = .edi } }, | 38679 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 25753 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38680 | .unused, |
| 25754 | .unused, | 38681 | .unused, |
| 25755 | .unused, | 38682 | .unused, |
| 25756 | .unused, | 38683 | .unused, |
| ... | @@ -25761,24 +38688,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25761,24 +38688,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25761 | .dst_temps = .{.mem}, | 38688 | .dst_temps = .{.mem}, |
| 25762 | .clobbers = .{ .eflags = true }, | 38689 | .clobbers = .{ .eflags = true }, |
| 25763 | .each = .{ .once = &.{ | 38690 | .each = .{ .once = &.{ |
| 25764 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 38691 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25765 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38692 | .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25766 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, | 38693 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 25767 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, | 38694 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25768 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, | 38695 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25769 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25770 | } }, | 38696 | } }, |
| 25771 | }, .{ | 38697 | }, .{ |
| 25772 | .src_constraints = .{ .{ .int = .word }, .any }, | 38698 | .required_features = .{ .avx2, null, null, null }, |
| 25773 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, | 38699 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 38700 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 25774 | .patterns = &.{ | 38701 | .patterns = &.{ |
| 25775 | .{ .src = .{ .mem, .none } }, | 38702 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25776 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25777 | }, | 38703 | }, |
| 25778 | .extra_temps = .{ | 38704 | .extra_temps = .{ |
| 25779 | .{ .type = .u32, .kind = .{ .reg = .eax } }, | 38705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25780 | .{ .type = .usize, .kind = .{ .reg = .edi } }, | 38706 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 25781 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38707 | .unused, |
| 25782 | .unused, | 38708 | .unused, |
| 25783 | .unused, | 38709 | .unused, |
| 25784 | .unused, | 38710 | .unused, |
| ... | @@ -25789,49 +38715,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25789,49 +38715,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25789 | .dst_temps = .{.mem}, | 38715 | .dst_temps = .{.mem}, |
| 25790 | .clobbers = .{ .eflags = true }, | 38716 | .clobbers = .{ .eflags = true }, |
| 25791 | .each = .{ .once = &.{ | 38717 | .each = .{ .once = &.{ |
| 25792 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 38718 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25793 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38719 | .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25794 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, | 38720 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 25795 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 38721 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 25796 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, | 38722 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._ }, | | |
| 25822 | } }, | 38723 | } }, |
| 25823 | }, .{ | 38724 | }, .{ |
| 25824 | .required_features = .{ .@"64bit", null, null, null }, | 38725 | .required_features = .{ .avx, null, null, null }, |
| 25825 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, | 38726 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 25826 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 38727 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 25827 | .patterns = &.{ | 38728 | .patterns = &.{ |
| 25828 | .{ .src = .{ .mem, .none } }, | 38729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25829 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25830 | }, | 38730 | }, |
| 25831 | .extra_temps = .{ | 38731 | .extra_temps = .{ |
| 25832 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 38732 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25833 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38733 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 25834 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38734 | .unused, |
| 25835 | .unused, | 38735 | .unused, |
| 25836 | .unused, | 38736 | .unused, |
| 25837 | .unused, | 38737 | .unused, |
| ... | @@ -25842,25 +38742,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25842,25 +38742,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25842 | .dst_temps = .{.mem}, | 38742 | .dst_temps = .{.mem}, |
| 25843 | .clobbers = .{ .eflags = true }, | 38743 | .clobbers = .{ .eflags = true }, |
| 25844 | .each = .{ .once = &.{ | 38744 | .each = .{ .once = &.{ |
| 25845 | .{ ._, ._d, .movsx, .tmp0q, .src0d, ._, ._ }, | 38745 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25846 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38746 | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25847 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38747 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25848 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 38748 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 25849 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25850 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25851 | } }, | 38750 | } }, |
| 25852 | }, .{ | 38751 | }, .{ |
| 25853 | .required_features = .{ .@"64bit", null, null, null }, | 38752 | .required_features = .{ .avx, null, null, null }, |
| 25854 | .src_constraints = .{ .{ .int = .dword }, .any }, | 38753 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 25855 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, | 38754 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25856 | .patterns = &.{ | 38755 | .patterns = &.{ |
| 25857 | .{ .src = .{ .mem, .none } }, | 38756 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25858 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25859 | }, | 38757 | }, |
| 25860 | .extra_temps = .{ | 38758 | .extra_temps = .{ |
| 25861 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 38759 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25862 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38760 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 25863 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38761 | .unused, |
| 25864 | .unused, | 38762 | .unused, |
| 25865 | .unused, | 38763 | .unused, |
| 25866 | .unused, | 38764 | .unused, |
| ... | @@ -25871,24 +38769,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25871,24 +38769,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25871 | .dst_temps = .{.mem}, | 38769 | .dst_temps = .{.mem}, |
| 25872 | .clobbers = .{ .eflags = true }, | 38770 | .clobbers = .{ .eflags = true }, |
| 25873 | .each = .{ .once = &.{ | 38771 | .each = .{ .once = &.{ |
| 25874 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 38772 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25875 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38773 | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25876 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38774 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25877 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 38775 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 25878 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38776 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25879 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25880 | } }, | 38777 | } }, |
| 25881 | }, .{ | 38778 | }, .{ |
| 25882 | .src_constraints = .{ .{ .signed_int = .dword }, .any }, | 38779 | .required_features = .{ .sse4_1, null, null, null }, |
| 25883 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 38782 | .patterns = &.{ |
| 25885 | .{ .src = .{ .mem, .none } }, | 38783 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25886 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25887 | }, | 38784 | }, |
| 25888 | .extra_temps = .{ | 38785 | .extra_temps = .{ |
| 25889 | .{ .type = .i32, .kind = .{ .reg = .eax } }, | 38786 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25890 | .{ .type = .usize, .kind = .{ .reg = .edi } }, | 38787 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 25891 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38788 | .unused, |
| 25892 | .unused, | 38789 | .unused, |
| 25893 | .unused, | 38790 | .unused, |
| 25894 | .unused, | 38791 | .unused, |
| ... | @@ -25899,24 +38796,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25899,24 +38796,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25899 | .dst_temps = .{.mem}, | 38796 | .dst_temps = .{.mem}, |
| 25900 | .clobbers = .{ .eflags = true }, | 38797 | .clobbers = .{ .eflags = true }, |
| 25901 | .each = .{ .once = &.{ | 38798 | .each = .{ .once = &.{ |
| 25902 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 38799 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25903 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38800 | .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25904 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, | 38801 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25905 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, | 38802 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 25906 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, | 38803 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25907 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25908 | } }, | 38804 | } }, |
| 25909 | }, .{ | 38805 | }, .{ |
| 25910 | .src_constraints = .{ .{ .int = .dword }, .any }, | 38806 | .required_features = .{ .sse4_1, null, null, null }, |
| 25911 | .dst_constraints = .{.{ .remainder_int = .{ .of = .dword, .is = .dword } }}, | 38807 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 38808 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 25912 | .patterns = &.{ | 38809 | .patterns = &.{ |
| 25913 | .{ .src = .{ .mem, .none } }, | 38810 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25914 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25915 | }, | 38811 | }, |
| 25916 | .extra_temps = .{ | 38812 | .extra_temps = .{ |
| 25917 | .{ .type = .u32, .kind = .{ .reg = .eax } }, | 38813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25918 | .{ .type = .usize, .kind = .{ .reg = .edi } }, | 38814 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 25919 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38815 | .unused, |
| 25920 | .unused, | 38816 | .unused, |
| 25921 | .unused, | 38817 | .unused, |
| 25922 | .unused, | 38818 | .unused, |
| ... | @@ -25927,25 +38823,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25927,25 +38823,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25927 | .dst_temps = .{.mem}, | 38823 | .dst_temps = .{.mem}, |
| 25928 | .clobbers = .{ .eflags = true }, | 38824 | .clobbers = .{ .eflags = true }, |
| 25929 | .each = .{ .once = &.{ | 38825 | .each = .{ .once = &.{ |
| 25930 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 38826 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25931 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38827 | .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25932 | .{ ._, ._sd, .sto, ._, ._, ._, ._ }, | 38828 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 25933 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 38829 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 25934 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_4), ._, ._ }, | 38830 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25935 | .{ ._, .@"rep _sd", .sto, ._, ._, ._, ._ }, | | |
| 25936 | } }, | 38831 | } }, |
| 25937 | }, .{ | 38832 | }, .{ |
| 25938 | .required_features = .{ .@"64bit", null, null, null }, | 38833 | .required_features = .{ .slow_incdec, null, null, null }, |
| 25939 | .src_constraints = .{ .{ .signed_int = .qword }, .any }, | 38834 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 25940 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 38835 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 25941 | .patterns = &.{ | 38836 | .patterns = &.{ |
| 25942 | .{ .src = .{ .mem, .none } }, | 38837 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25943 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25944 | }, | 38838 | }, |
| 25945 | .extra_temps = .{ | 38839 | .extra_temps = .{ |
| 25946 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 38840 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25947 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38841 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 25948 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38842 | .unused, |
| 25949 | .unused, | 38843 | .unused, |
| 25950 | .unused, | 38844 | .unused, |
| 25951 | .unused, | 38845 | .unused, |
| ... | @@ -25956,25 +38850,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25956,25 +38850,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25956 | .dst_temps = .{.mem}, | 38850 | .dst_temps = .{.mem}, |
| 25957 | .clobbers = .{ .eflags = true }, | 38851 | .clobbers = .{ .eflags = true }, |
| 25958 | .each = .{ .once = &.{ | 38852 | .each = .{ .once = &.{ |
| 25959 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, | 38853 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25960 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38854 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25961 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38855 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 25962 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 38856 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 25963 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38857 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 25964 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25965 | } }, | 38858 | } }, |
| 25966 | }, .{ | 38859 | }, .{ |
| 25967 | .required_features = .{ .@"64bit", null, null, null }, | 38860 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 25968 | .src_constraints = .{ .{ .int = .qword }, .any }, | 38861 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 25969 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, | | |
| 25970 | .patterns = &.{ | 38862 | .patterns = &.{ |
| 25971 | .{ .src = .{ .mem, .none } }, | 38863 | .{ .src = .{ .to_mem, .none, .none } }, |
| 25972 | .{ .src = .{ .to_gpr, .none } }, | | |
| 25973 | }, | 38864 | }, |
| 25974 | .extra_temps = .{ | 38865 | .extra_temps = .{ |
| 25975 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 38866 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 25976 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38867 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 25977 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38868 | .unused, |
| 25978 | .unused, | 38869 | .unused, |
| 25979 | .unused, | 38870 | .unused, |
| 25980 | .unused, | 38871 | .unused, |
| ... | @@ -25985,25 +38876,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -25985,25 +38876,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 25985 | .dst_temps = .{.mem}, | 38876 | .dst_temps = .{.mem}, |
| 25986 | .clobbers = .{ .eflags = true }, | 38877 | .clobbers = .{ .eflags = true }, |
| 25987 | .each = .{ .once = &.{ | 38878 | .each = .{ .once = &.{ |
| 25988 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, | 38879 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 25989 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38880 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 25990 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 38881 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 25991 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, | 38882 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 25992 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 38883 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 25993 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 25994 | } }, | 38884 | } }, |
| 25995 | }, .{ | 38885 | }, .{ |
| 25996 | .required_features = .{ .@"64bit", null, null, null }, | 38886 | .required_features = .{ .slow_incdec, null, null, null }, |
| 25997 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, .any }, | 38887 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 25998 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 38888 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 25999 | .patterns = &.{ | 38889 | .patterns = &.{ |
| 26000 | .{ .src = .{ .to_mem, .none } }, | 38890 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26001 | }, | 38891 | }, |
| 26002 | .extra_temps = .{ | 38892 | .extra_temps = .{ |
| 26003 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 38893 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26004 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38894 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 26005 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38895 | .unused, |
| 26006 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 38896 | .unused, |
| 26007 | .unused, | 38897 | .unused, |
| 26008 | .unused, | 38898 | .unused, |
| 26009 | .unused, | 38899 | .unused, |
| ... | @@ -26013,28 +38903,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26013,28 +38903,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26013 | .dst_temps = .{.mem}, | 38903 | .dst_temps = .{.mem}, |
| 26014 | .clobbers = .{ .eflags = true }, | 38904 | .clobbers = .{ .eflags = true }, |
| 26015 | .each = .{ .once = &.{ | 38905 | .each = .{ .once = &.{ |
| 26016 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 38906 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26017 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38907 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26018 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, | 38908 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26019 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 38909 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 26020 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, | 38910 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26021 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | | |
| 26022 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, | | |
| 26023 | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, | | |
| 26024 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 26025 | } }, | 38911 | } }, |
| 26026 | }, .{ | 38912 | }, .{ |
| 26027 | .required_features = .{ .@"64bit", null, null, null }, | 38913 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26028 | .src_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any }, | 38914 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 26029 | .dst_constraints = .{.{ .remainder_int = .{ .of = .qword, .is = .qword } }}, | | |
| 26030 | .patterns = &.{ | 38915 | .patterns = &.{ |
| 26031 | .{ .src = .{ .to_mem, .none } }, | 38916 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26032 | }, | 38917 | }, |
| 26033 | .extra_temps = .{ | 38918 | .extra_temps = .{ |
| 26034 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 38919 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26035 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 38920 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 26036 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 38921 | .unused, |
| 26037 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 38922 | .unused, |
| 26038 | .unused, | 38923 | .unused, |
| 26039 | .unused, | 38924 | .unused, |
| 26040 | .unused, | 38925 | .unused, |
| ... | @@ -26044,68 +38929,66 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26044,68 +38929,66 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26044 | .dst_temps = .{.mem}, | 38929 | .dst_temps = .{.mem}, |
| 26045 | .clobbers = .{ .eflags = true }, | 38930 | .clobbers = .{ .eflags = true }, |
| 26046 | .each = .{ .once = &.{ | 38931 | .each = .{ .once = &.{ |
| 26047 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 38932 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26048 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 38933 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26049 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 38934 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26050 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 38935 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26051 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 38936 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26052 | .{ ._, ._, .mov, .tmp2d, .sa2(.dst0, .src0, .add_delta_size_div_8), ._, ._ }, | | |
| 26053 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 26054 | } }, | 38937 | } }, |
| 26055 | }, .{ | 38938 | }, .{ |
| 26056 | .required_features = .{ .avx, null, null, null }, | 38939 | .required_features = .{ .avx, null, null, null }, |
| 26057 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 38940 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26058 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 38941 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26059 | .patterns = &.{ | 38942 | .patterns = &.{ |
| 26060 | .{ .src = .{ .mem, .none } }, | 38943 | .{ .src = .{ .mem, .none, .none } }, |
| 26061 | .{ .src = .{ .to_sse, .none } }, | 38944 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26062 | }, | 38945 | }, |
| 26063 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38946 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26064 | .each = .{ .once = &.{ | 38947 | .each = .{ .once = &.{ |
| 26065 | .{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ }, | 38948 | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 26066 | } }, | 38949 | } }, |
| 26067 | }, .{ | 38950 | }, .{ |
| 26068 | .required_features = .{ .avx, null, null, null }, | 38951 | .required_features = .{ .avx, null, null, null }, |
| 26069 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 38952 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26070 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, | 38953 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26071 | .patterns = &.{ | 38954 | .patterns = &.{ |
| 26072 | .{ .src = .{ .mem, .none } }, | 38955 | .{ .src = .{ .mem, .none, .none } }, |
| 26073 | .{ .src = .{ .to_sse, .none } }, | 38956 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26074 | }, | 38957 | }, |
| 26075 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38958 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26076 | .each = .{ .once = &.{ | 38959 | .each = .{ .once = &.{ |
| 26077 | .{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ }, | 38960 | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 26078 | } }, | 38961 | } }, |
| 26079 | }, .{ | 38962 | }, .{ |
| 26080 | .required_features = .{ .sse4_1, null, null, null }, | 38963 | .required_features = .{ .sse4_1, null, null, null }, |
| 26081 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 38964 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26082 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 38965 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26083 | .patterns = &.{ | 38966 | .patterns = &.{ |
| 26084 | .{ .src = .{ .mem, .none } }, | 38967 | .{ .src = .{ .mem, .none, .none } }, |
| 26085 | .{ .src = .{ .to_sse, .none } }, | 38968 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26086 | }, | 38969 | }, |
| 26087 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38970 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26088 | .each = .{ .once = &.{ | 38971 | .each = .{ .once = &.{ |
| 26089 | .{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ }, | 38972 | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, |
| 26090 | } }, | 38973 | } }, |
| 26091 | }, .{ | 38974 | }, .{ |
| 26092 | .required_features = .{ .sse4_1, null, null, null }, | 38975 | .required_features = .{ .sse4_1, null, null, null }, |
| 26093 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 38976 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26094 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, | 38977 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26095 | .patterns = &.{ | 38978 | .patterns = &.{ |
| 26096 | .{ .src = .{ .mem, .none } }, | 38979 | .{ .src = .{ .mem, .none, .none } }, |
| 26097 | .{ .src = .{ .to_sse, .none } }, | 38980 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26098 | }, | 38981 | }, |
| 26099 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 38982 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26100 | .each = .{ .once = &.{ | 38983 | .each = .{ .once = &.{ |
| 26101 | .{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ }, | 38984 | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, |
| 26102 | } }, | 38985 | } }, |
| 26103 | }, .{ | 38986 | }, .{ |
| 26104 | .required_features = .{ .sse2, null, null, null }, | 38987 | .required_features = .{ .sse2, null, null, null }, |
| 26105 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 38988 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26106 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 38989 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26107 | .patterns = &.{ | 38990 | .patterns = &.{ |
| 26108 | .{ .src = .{ .to_mut_sse, .none } }, | 38991 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26109 | }, | 38992 | }, |
| 26110 | .extra_temps = .{ | 38993 | .extra_temps = .{ |
| 26111 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 38994 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| ... | @@ -26123,13 +39006,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26123,13 +39006,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26123 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 39006 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26124 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 39007 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 26125 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 39015 | .required_features = .{ .sse2, null, null, null }, |
| 26129 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 39016 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26130 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .word } }}, | 39017 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26131 | .patterns = &.{ | 39018 | .patterns = &.{ |
| 26132 | .{ .src = .{ .to_mut_sse, .none } }, | 39019 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26133 | }, | 39020 | }, |
| 26134 | .extra_temps = .{ | 39021 | .extra_temps = .{ |
| 26135 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 39022 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| ... | @@ -26146,41 +39033,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26146,41 +39033,43 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26146 | .each = .{ .once = &.{ | 39033 | .each = .{ .once = &.{ |
| 26147 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 39034 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26148 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | 39035 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| | 39036 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| | 39037 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26149 | } }, | 39038 | } }, |
| 26150 | }, .{ | 39039 | }, .{ |
| 26151 | .required_features = .{ .avx2, null, null, null }, | 39040 | .required_features = .{ .avx2, null, null, null }, |
| 26152 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, | 39041 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 26153 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, | 39042 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26154 | .patterns = &.{ | 39043 | .patterns = &.{ |
| 26155 | .{ .src = .{ .mem, .none } }, | 39044 | .{ .src = .{ .mem, .none, .none } }, |
| 26156 | .{ .src = .{ .to_sse, .none } }, | 39045 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26157 | }, | 39046 | }, |
| 26158 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39047 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26159 | .each = .{ .once = &.{ | 39048 | .each = .{ .once = &.{ |
| 26160 | .{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ }, | 39049 | .{ ._, .vp_q, .movsxb, .dst0y, .src0d, ._, ._ }, |
| 26161 | } }, | 39050 | } }, |
| 26162 | }, .{ | 39051 | }, .{ |
| 26163 | .required_features = .{ .avx2, null, null, null }, | 39052 | .required_features = .{ .avx2, null, null, null }, |
| 26164 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 39053 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 26165 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .word } }}, | 39054 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26166 | .patterns = &.{ | 39055 | .patterns = &.{ |
| 26167 | .{ .src = .{ .mem, .none } }, | 39056 | .{ .src = .{ .mem, .none, .none } }, |
| 26168 | .{ .src = .{ .to_sse, .none } }, | 39057 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26169 | }, | 39058 | }, |
| 26170 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39059 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26171 | .each = .{ .once = &.{ | 39060 | .each = .{ .once = &.{ |
| 26172 | .{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ }, | 39061 | .{ ._, .vp_q, .movzxb, .dst0y, .src0d, ._, ._ }, |
| 26173 | } }, | 39062 | } }, |
| 26174 | }, .{ | 39063 | }, .{ |
| 26175 | .required_features = .{ .avx2, null, null, null }, | 39064 | .required_features = .{ .avx2, null, null, null }, |
| 26176 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, | 39065 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 26177 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, | 39066 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26178 | .patterns = &.{ | 39067 | .patterns = &.{ |
| 26179 | .{ .src = .{ .to_mem, .none } }, | 39068 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26180 | }, | 39069 | }, |
| 26181 | .extra_temps = .{ | 39070 | .extra_temps = .{ |
| 26182 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39071 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26183 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, | 39072 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 26184 | .unused, | 39073 | .unused, |
| 26185 | .unused, | 39074 | .unused, |
| 26186 | .unused, | 39075 | .unused, |
| ... | @@ -26193,21 +39082,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26193,21 +39082,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26193 | .clobbers = .{ .eflags = true }, | 39082 | .clobbers = .{ .eflags = true }, |
| 26194 | .each = .{ .once = &.{ | 39083 | .each = .{ .once = &.{ |
| 26195 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39084 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26196 | .{ .@"0:", .vp_w, .movsxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 39085 | .{ .@"0:", .vp_q, .movsxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26197 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 39086 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26198 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 39087 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 26199 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39088 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26200 | } }, | 39089 | } }, |
| 26201 | }, .{ | 39090 | }, .{ |
| 26202 | .required_features = .{ .avx2, null, null, null }, | 39091 | .required_features = .{ .avx2, null, null, null }, |
| 26203 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 39092 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 26204 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }}, | 39093 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26205 | .patterns = &.{ | 39094 | .patterns = &.{ |
| 26206 | .{ .src = .{ .to_mem, .none } }, | 39095 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26207 | }, | 39096 | }, |
| 26208 | .extra_temps = .{ | 39097 | .extra_temps = .{ |
| 26209 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39098 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26210 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, | 39099 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 26211 | .unused, | 39100 | .unused, |
| 26212 | .unused, | 39101 | .unused, |
| 26213 | .unused, | 39102 | .unused, |
| ... | @@ -26220,21 +39109,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26220,21 +39109,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26220 | .clobbers = .{ .eflags = true }, | 39109 | .clobbers = .{ .eflags = true }, |
| 26221 | .each = .{ .once = &.{ | 39110 | .each = .{ .once = &.{ |
| 26222 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39111 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26223 | .{ .@"0:", .vp_w, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 39112 | .{ .@"0:", .vp_q, .movzxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26224 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 39113 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26225 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 39114 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 26226 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39115 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26227 | } }, | 39116 | } }, |
| 26228 | }, .{ | 39117 | }, .{ |
| 26229 | .required_features = .{ .avx, null, null, null }, | 39118 | .required_features = .{ .avx, null, null, null }, |
| 26230 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 39119 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26231 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 39120 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26232 | .patterns = &.{ | 39121 | .patterns = &.{ |
| 26233 | .{ .src = .{ .to_mem, .none } }, | 39122 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26234 | }, | 39123 | }, |
| 26235 | .extra_temps = .{ | 39124 | .extra_temps = .{ |
| 26236 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26237 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, | 39126 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 26238 | .unused, | 39127 | .unused, |
| 26239 | .unused, | 39128 | .unused, |
| 26240 | .unused, | 39129 | .unused, |
| ... | @@ -26247,21 +39136,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26247,21 +39136,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26247 | .clobbers = .{ .eflags = true }, | 39136 | .clobbers = .{ .eflags = true }, |
| 26248 | .each = .{ .once = &.{ | 39137 | .each = .{ .once = &.{ |
| 26249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26250 | .{ .@"0:", .vp_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 39139 | .{ .@"0:", .vp_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26251 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39140 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26252 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 39141 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26253 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26254 | } }, | 39143 | } }, |
| 26255 | }, .{ | 39144 | }, .{ |
| 26256 | .required_features = .{ .avx, null, null, null }, | 39145 | .required_features = .{ .avx, null, null, null }, |
| 26257 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 39146 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26258 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, | 39147 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26259 | .patterns = &.{ | 39148 | .patterns = &.{ |
| 26260 | .{ .src = .{ .to_mem, .none } }, | 39149 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26261 | }, | 39150 | }, |
| 26262 | .extra_temps = .{ | 39151 | .extra_temps = .{ |
| 26263 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39152 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26264 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 39153 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 26265 | .unused, | 39154 | .unused, |
| 26266 | .unused, | 39155 | .unused, |
| 26267 | .unused, | 39156 | .unused, |
| ... | @@ -26274,21 +39163,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26274,21 +39163,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26274 | .clobbers = .{ .eflags = true }, | 39163 | .clobbers = .{ .eflags = true }, |
| 26275 | .each = .{ .once = &.{ | 39164 | .each = .{ .once = &.{ |
| 26276 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39165 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26277 | .{ .@"0:", .vp_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 39166 | .{ .@"0:", .vp_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26278 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39167 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26279 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 39168 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26280 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39169 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26281 | } }, | 39170 | } }, |
| 26282 | }, .{ | 39171 | }, .{ |
| 26283 | .required_features = .{ .sse4_1, null, null, null }, | 39172 | .required_features = .{ .sse4_1, null, null, null }, |
| 26284 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 39173 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26285 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 39174 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26286 | .patterns = &.{ | 39175 | .patterns = &.{ |
| 26287 | .{ .src = .{ .to_mem, .none } }, | 39176 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26288 | }, | 39177 | }, |
| 26289 | .extra_temps = .{ | 39178 | .extra_temps = .{ |
| 26290 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39179 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26291 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, | 39180 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 26292 | .unused, | 39181 | .unused, |
| 26293 | .unused, | 39182 | .unused, |
| 26294 | .unused, | 39183 | .unused, |
| ... | @@ -26301,21 +39190,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26301,21 +39190,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26301 | .clobbers = .{ .eflags = true }, | 39190 | .clobbers = .{ .eflags = true }, |
| 26302 | .each = .{ .once = &.{ | 39191 | .each = .{ .once = &.{ |
| 26303 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39192 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26304 | .{ .@"0:", .p_w, .movsxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 39193 | .{ .@"0:", .p_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26305 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39194 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26306 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 39195 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26307 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39196 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26308 | } }, | 39197 | } }, |
| 26309 | }, .{ | 39198 | }, .{ |
| 26310 | .required_features = .{ .sse4_1, null, null, null }, | 39199 | .required_features = .{ .sse4_1, null, null, null }, |
| 26311 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 39200 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 26312 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }}, | 39201 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26313 | .patterns = &.{ | 39202 | .patterns = &.{ |
| 26314 | .{ .src = .{ .to_mem, .none } }, | 39203 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26315 | }, | 39204 | }, |
| 26316 | .extra_temps = .{ | 39205 | .extra_temps = .{ |
| 26317 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39206 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26318 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 39207 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 26319 | .unused, | 39208 | .unused, |
| 26320 | .unused, | 39209 | .unused, |
| 26321 | .unused, | 39210 | .unused, |
| ... | @@ -26328,21 +39217,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26328,21 +39217,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26328 | .clobbers = .{ .eflags = true }, | 39217 | .clobbers = .{ .eflags = true }, |
| 26329 | .each = .{ .once = &.{ | 39218 | .each = .{ .once = &.{ |
| 26330 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39219 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26331 | .{ .@"0:", .p_w, .movzxb, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 39220 | .{ .@"0:", .p_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26332 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39221 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26333 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 39222 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26334 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39223 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26335 | } }, | 39224 | } }, |
| 26336 | }, .{ | 39225 | }, .{ |
| 26337 | .required_features = .{ .slow_incdec, null, null, null }, | 39226 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 26338 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 39227 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26339 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 39228 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 26340 | .patterns = &.{ | 39229 | .patterns = &.{ |
| 26341 | .{ .src = .{ .to_mem, .none } }, | 39230 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26342 | }, | 39231 | }, |
| 26343 | .extra_temps = .{ | 39232 | .extra_temps = .{ |
| 26344 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39233 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26345 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 39234 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 26346 | .unused, | 39235 | .unused, |
| 26347 | .unused, | 39236 | .unused, |
| 26348 | .unused, | 39237 | .unused, |
| ... | @@ -26355,20 +39244,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26355,20 +39244,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26355 | .clobbers = .{ .eflags = true }, | 39244 | .clobbers = .{ .eflags = true }, |
| 26356 | .each = .{ .once = &.{ | 39245 | .each = .{ .once = &.{ |
| 26357 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39246 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26358 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 39247 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26359 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 39248 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 26360 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 39249 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 26361 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39250 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26362 | } }, | 39251 | } }, |
| 26363 | }, .{ | 39252 | }, .{ |
| 26364 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 39253 | .required_features = .{ .@"64bit", null, null, null }, |
| 26365 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 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 | .patterns = &.{ | 39256 | .patterns = &.{ |
| 26367 | .{ .src = .{ .to_mem, .none } }, | 39257 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26368 | }, | 39258 | }, |
| 26369 | .extra_temps = .{ | 39259 | .extra_temps = .{ |
| 26370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39260 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26371 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 39261 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 26372 | .unused, | 39262 | .unused, |
| 26373 | .unused, | 39263 | .unused, |
| 26374 | .unused, | 39264 | .unused, |
| ... | @@ -26381,21 +39271,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26381,21 +39271,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26381 | .clobbers = .{ .eflags = true }, | 39271 | .clobbers = .{ .eflags = true }, |
| 26382 | .each = .{ .once = &.{ | 39272 | .each = .{ .once = &.{ |
| 26383 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39273 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26384 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 39274 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26385 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 39275 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 26386 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 39276 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26387 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 39277 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26388 | } }, | 39278 | } }, |
| 26389 | }, .{ | 39279 | }, .{ |
| 26390 | .required_features = .{ .slow_incdec, null, null, null }, | 39280 | .required_features = .{ .slow_incdec, null, null, null }, |
| 26391 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 39281 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26392 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, | 39282 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 26393 | .patterns = &.{ | 39283 | .patterns = &.{ |
| 26394 | .{ .src = .{ .to_mem, .none } }, | 39284 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26395 | }, | 39285 | }, |
| 26396 | .extra_temps = .{ | 39286 | .extra_temps = .{ |
| 26397 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39287 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26398 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 39288 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 26399 | .unused, | 39289 | .unused, |
| 26400 | .unused, | 39290 | .unused, |
| 26401 | .unused, | 39291 | .unused, |
| ... | @@ -26409,19 +39299,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26409,19 +39299,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26409 | .each = .{ .once = &.{ | 39299 | .each = .{ .once = &.{ |
| 26410 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39300 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26411 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 39303 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 26414 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39304 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26415 | } }, | 39305 | } }, |
| 26416 | }, .{ | 39306 | }, .{ |
| 26417 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 39307 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26418 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, | 39308 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 26419 | .patterns = &.{ | 39309 | .patterns = &.{ |
| 26420 | .{ .src = .{ .to_mem, .none } }, | 39310 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26421 | }, | 39311 | }, |
| 26422 | .extra_temps = .{ | 39312 | .extra_temps = .{ |
| 26423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39313 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26424 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 39314 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 26425 | .unused, | 39315 | .unused, |
| 26426 | .unused, | 39316 | .unused, |
| 26427 | .unused, | 39317 | .unused, |
| ... | @@ -26435,64 +39325,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26435,64 +39325,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26435 | .each = .{ .once = &.{ | 39325 | .each = .{ .once = &.{ |
| 26436 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39326 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26437 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 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 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 39329 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 26440 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 39330 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 26441 | } }, | 39331 | } }, |
| 26442 | }, .{ | 39332 | }, .{ |
| 26443 | .required_features = .{ .avx, null, null, null }, | 39333 | .required_features = .{ .avx, null, null, null }, |
| 26444 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, | 39334 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26445 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 39335 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 26446 | .patterns = &.{ | 39336 | .patterns = &.{ |
| 26447 | .{ .src = .{ .mem, .none } }, | 39337 | .{ .src = .{ .mem, .none, .none } }, |
| 26448 | .{ .src = .{ .to_sse, .none } }, | 39338 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26449 | }, | 39339 | }, |
| 26450 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39340 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26451 | .each = .{ .once = &.{ | 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 | .required_features = .{ .avx, null, null, null }, | 39346 | .required_features = .{ .avx, null, null, null }, |
| 26456 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, | 39347 | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26457 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 39348 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 26458 | .patterns = &.{ | 39349 | .patterns = &.{ |
| 26459 | .{ .src = .{ .mem, .none } }, | 39350 | .{ .src = .{ .mem, .none, .none } }, |
| 26460 | .{ .src = .{ .to_sse, .none } }, | 39351 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26461 | }, | 39352 | }, |
| 26462 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39353 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26463 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse4_1, null, null, null }, | 39359 | .required_features = .{ .sse4_1, null, null, null }, |
| 26468 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, | 39360 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26469 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 39361 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 26470 | .patterns = &.{ | 39362 | .patterns = &.{ |
| 26471 | .{ .src = .{ .mem, .none } }, | 39363 | .{ .src = .{ .mem, .none, .none } }, |
| 26472 | .{ .src = .{ .to_sse, .none } }, | 39364 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26473 | }, | 39365 | }, |
| 26474 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39366 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26475 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse4_1, null, null, null }, | 39372 | .required_features = .{ .sse4_1, null, null, null }, |
| 26480 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, | 39373 | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26481 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 39374 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 26482 | .patterns = &.{ | 39375 | .patterns = &.{ |
| 26483 | .{ .src = .{ .mem, .none } }, | 39376 | .{ .src = .{ .mem, .none, .none } }, |
| 26484 | .{ .src = .{ .to_sse, .none } }, | 39377 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26485 | }, | 39378 | }, |
| 26486 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39379 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26487 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse2, null, null, null }, | 39385 | .required_features = .{ .sse2, null, null, null }, |
| 26492 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, | 39386 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26493 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 39387 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 26494 | .patterns = &.{ | 39388 | .patterns = &.{ |
| 26495 | .{ .src = .{ .to_mut_sse, .none } }, | 39389 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26496 | }, | 39390 | }, |
| 26497 | .extra_temps = .{ | 39391 | .extra_temps = .{ |
| 26498 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 39392 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| ... | @@ -26512,13 +39406,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26512,13 +39406,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26512 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | 39406 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 26513 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, | 39407 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, |
| 26514 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 39415 | .required_features = .{ .sse2, null, null, null }, |
| 26518 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any }, | 39416 | .src_constraints = .{ .{ .scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26519 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 39417 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 26520 | .patterns = &.{ | 39418 | .patterns = &.{ |
| 26521 | .{ .src = .{ .to_mut_sse, .none } }, | 39419 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26522 | }, | 39420 | }, |
| 26523 | .extra_temps = .{ | 39421 | .extra_temps = .{ |
| 26524 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 39422 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| ... | @@ -26536,43 +39434,83 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26536,43 +39434,83 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26536 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 39434 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26537 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | 39435 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, |
| 26538 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 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 }, | 39441 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 26542 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 39442 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26543 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, | 39443 | .dst_constraints = .{.any_scalar_signed_int}, |
| 26544 | .patterns = &.{ | 39444 | .patterns = &.{ |
| 26545 | .{ .src = .{ .mem, .none } }, | 39445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26546 | .{ .src = .{ .to_sse, .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 | .each = .{ .once = &.{ | 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 }, | 39472 | .required_features = .{ .@"64bit", null, null, null }, |
| 26554 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 39473 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26555 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, | 39474 | .dst_constraints = .{.any_scalar_signed_int}, |
| 26556 | .patterns = &.{ | 39475 | .patterns = &.{ |
| 26557 | .{ .src = .{ .mem, .none } }, | 39476 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26558 | .{ .src = .{ .to_sse, .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 | .each = .{ .once = &.{ | 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 }, | 39503 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 26566 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any }, | 39504 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26567 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, | 39505 | .dst_constraints = .{.any_scalar_int}, |
| 26568 | .patterns = &.{ | 39506 | .patterns = &.{ |
| 26569 | .{ .src = .{ .to_mem, .none } }, | 39507 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26570 | }, | 39508 | }, |
| 26571 | .extra_temps = .{ | 39509 | .extra_temps = .{ |
| 26572 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39510 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26573 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, | 39511 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 26574 | .unused, | 39512 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 26575 | .unused, | 39513 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 26576 | .unused, | 39514 | .unused, |
| 26577 | .unused, | 39515 | .unused, |
| 26578 | .unused, | 39516 | .unused, |
| ... | @@ -26583,23 +39521,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26583,23 +39521,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26583 | .clobbers = .{ .eflags = true }, | 39521 | .clobbers = .{ .eflags = true }, |
| 26584 | .each = .{ .once = &.{ | 39522 | .each = .{ .once = &.{ |
| 26585 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39523 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26586 | .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 39524 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 26587 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 39525 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26588 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26590 | } }, | 39532 | } }, |
| 26591 | }, .{ | 39533 | }, .{ |
| 26592 | .required_features = .{ .avx2, null, null, null }, | 39534 | .required_features = .{ .@"64bit", null, null, null }, |
| 26593 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } }, .any }, | 39535 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 26594 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, | 39536 | .dst_constraints = .{.any_scalar_int}, |
| 26595 | .patterns = &.{ | 39537 | .patterns = &.{ |
| 26596 | .{ .src = .{ .to_mem, .none } }, | 39538 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26597 | }, | 39539 | }, |
| 26598 | .extra_temps = .{ | 39540 | .extra_temps = .{ |
| 26599 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39541 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26600 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, | 39542 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 26601 | .unused, | 39543 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 26602 | .unused, | 39544 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 26603 | .unused, | 39545 | .unused, |
| 26604 | .unused, | 39546 | .unused, |
| 26605 | .unused, | 39547 | .unused, |
| ... | @@ -26610,21 +39552,144 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26610,21 +39552,144 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26610 | .clobbers = .{ .eflags = true }, | 39552 | .clobbers = .{ .eflags = true }, |
| 26611 | .each = .{ .once = &.{ | 39553 | .each = .{ .once = &.{ |
| 26612 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39554 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26613 | .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 39555 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 26614 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 39556 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26615 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 39557 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 26616 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 39565 | .required_features = .{ .avx, null, null, null }, |
| 26620 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, | 39566 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26621 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 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 | .patterns = &.{ | 39687 | .patterns = &.{ |
| 26623 | .{ .src = .{ .to_mem, .none } }, | 39688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26624 | }, | 39689 | }, |
| 26625 | .extra_temps = .{ | 39690 | .extra_temps = .{ |
| 26626 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39691 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26627 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 39692 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 26628 | .unused, | 39693 | .unused, |
| 26629 | .unused, | 39694 | .unused, |
| 26630 | .unused, | 39695 | .unused, |
| ... | @@ -26637,21 +39702,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26637,21 +39702,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26637 | .clobbers = .{ .eflags = true }, | 39702 | .clobbers = .{ .eflags = true }, |
| 26638 | .each = .{ .once = &.{ | 39703 | .each = .{ .once = &.{ |
| 26639 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26640 | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 39705 | .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26641 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39706 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26642 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 39707 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 26643 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26644 | } }, | 39709 | } }, |
| 26645 | }, .{ | 39710 | }, .{ |
| 26646 | .required_features = .{ .avx, null, null, null }, | 39711 | .required_features = .{ .avx2, null, null, null }, |
| 26647 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any }, | 39712 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 26648 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, | 39713 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, |
| 26649 | .patterns = &.{ | 39714 | .patterns = &.{ |
| 26650 | .{ .src = .{ .to_mem, .none } }, | 39715 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26651 | }, | 39716 | }, |
| 26652 | .extra_temps = .{ | 39717 | .extra_temps = .{ |
| 26653 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39718 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26654 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 39719 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 26655 | .unused, | 39720 | .unused, |
| 26656 | .unused, | 39721 | .unused, |
| 26657 | .unused, | 39722 | .unused, |
| ... | @@ -26664,17 +39729,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26664,17 +39729,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26664 | .clobbers = .{ .eflags = true }, | 39729 | .clobbers = .{ .eflags = true }, |
| 26665 | .each = .{ .once = &.{ | 39730 | .each = .{ .once = &.{ |
| 26666 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39731 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26667 | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 39732 | .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26668 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39733 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26669 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 39734 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 26670 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39735 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26671 | } }, | 39736 | } }, |
| 26672 | }, .{ | 39737 | }, .{ |
| 26673 | .required_features = .{ .sse4_1, null, null, null }, | 39738 | .required_features = .{ .avx, null, null, null }, |
| 26674 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any }, | 39739 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26675 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 39740 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 26676 | .patterns = &.{ | 39741 | .patterns = &.{ |
| 26677 | .{ .src = .{ .to_mem, .none } }, | 39742 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26678 | }, | 39743 | }, |
| 26679 | .extra_temps = .{ | 39744 | .extra_temps = .{ |
| 26680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39745 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -26691,17 +39756,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26691,17 +39756,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26691 | .clobbers = .{ .eflags = true }, | 39756 | .clobbers = .{ .eflags = true }, |
| 26692 | .each = .{ .once = &.{ | 39757 | .each = .{ .once = &.{ |
| 26693 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39758 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26694 | .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 39759 | .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26695 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39760 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26696 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 39761 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26697 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39762 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26698 | } }, | 39763 | } }, |
| 26699 | }, .{ | 39764 | }, .{ |
| 26700 | .required_features = .{ .sse4_1, null, null, null }, | 39765 | .required_features = .{ .avx, null, null, null }, |
| 26701 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }, .any }, | 39766 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26702 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, | 39767 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 26703 | .patterns = &.{ | 39768 | .patterns = &.{ |
| 26704 | .{ .src = .{ .to_mem, .none } }, | 39769 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26705 | }, | 39770 | }, |
| 26706 | .extra_temps = .{ | 39771 | .extra_temps = .{ |
| 26707 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -26718,21 +39783,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26718,21 +39783,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26718 | .clobbers = .{ .eflags = true }, | 39783 | .clobbers = .{ .eflags = true }, |
| 26719 | .each = .{ .once = &.{ | 39784 | .each = .{ .once = &.{ |
| 26720 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39785 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26721 | .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 39786 | .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26722 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 39787 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26723 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 39788 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26724 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39789 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26725 | } }, | 39790 | } }, |
| 26726 | }, .{ | 39791 | }, .{ |
| 26727 | .required_features = .{ .slow_incdec, null, null, null }, | 39792 | .required_features = .{ .sse4_1, null, null, null }, |
| 26728 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 39793 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 26729 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 39794 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 26730 | .patterns = &.{ | 39795 | .patterns = &.{ |
| 26731 | .{ .src = .{ .to_mem, .none } }, | 39796 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26732 | }, | 39797 | }, |
| 26733 | .extra_temps = .{ | 39798 | .extra_temps = .{ |
| 26734 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39799 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26735 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 39800 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 26736 | .unused, | 39801 | .unused, |
| 26737 | .unused, | 39802 | .unused, |
| 26738 | .unused, | 39803 | .unused, |
| ... | @@ -26745,20 +39810,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26745,20 +39810,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26745 | .clobbers = .{ .eflags = true }, | 39810 | .clobbers = .{ .eflags = true }, |
| 26746 | .each = .{ .once = &.{ | 39811 | .each = .{ .once = &.{ |
| 26747 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39812 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26748 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 39813 | .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26749 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 39814 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26750 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 39815 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26751 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 39816 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26752 | } }, | 39817 | } }, |
| 26753 | }, .{ | 39818 | }, .{ |
| 26754 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 39819 | .required_features = .{ .sse4_1, null, null, null }, |
| 26755 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 39820 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| | 39821 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, |
| 26756 | .patterns = &.{ | 39822 | .patterns = &.{ |
| 26757 | .{ .src = .{ .to_mem, .none } }, | 39823 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26758 | }, | 39824 | }, |
| 26759 | .extra_temps = .{ | 39825 | .extra_temps = .{ |
| 26760 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39826 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26761 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 39827 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 26762 | .unused, | 39828 | .unused, |
| 26763 | .unused, | 39829 | .unused, |
| 26764 | .unused, | 39830 | .unused, |
| ... | @@ -26771,21 +39837,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26771,21 +39837,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26771 | .clobbers = .{ .eflags = true }, | 39837 | .clobbers = .{ .eflags = true }, |
| 26772 | .each = .{ .once = &.{ | 39838 | .each = .{ .once = &.{ |
| 26773 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39839 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26774 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 39840 | .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26775 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 39841 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 26776 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 39842 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26777 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 39843 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26778 | } }, | 39844 | } }, |
| 26779 | }, .{ | 39845 | }, .{ |
| 26780 | .required_features = .{ .slow_incdec, null, null, null }, | 39846 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 26781 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 39847 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 26782 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, | | |
| 26783 | .patterns = &.{ | 39848 | .patterns = &.{ |
| 26784 | .{ .src = .{ .to_mem, .none } }, | 39849 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26785 | }, | 39850 | }, |
| 26786 | .extra_temps = .{ | 39851 | .extra_temps = .{ |
| 26787 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39852 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 26788 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 39853 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 26789 | .unused, | 39854 | .unused, |
| 26790 | .unused, | 39855 | .unused, |
| 26791 | .unused, | 39856 | .unused, |
| ... | @@ -26798,16 +39863,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26798,16 +39863,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26798 | .clobbers = .{ .eflags = true }, | 39863 | .clobbers = .{ .eflags = true }, |
| 26799 | .each = .{ .once = &.{ | 39864 | .each = .{ .once = &.{ |
| 26800 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39865 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26801 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 39866 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26802 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 39867 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26803 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 39868 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26804 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, | 39873 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, |
| 26809 | .patterns = &.{ | 39874 | .patterns = &.{ |
| 26810 | .{ .src = .{ .to_mem, .none } }, | 39875 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26811 | }, | 39876 | }, |
| 26812 | .extra_temps = .{ | 39877 | .extra_temps = .{ |
| 26813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 39878 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -26824,68 +39889,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26824,68 +39889,68 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26824 | .clobbers = .{ .eflags = true }, | 39889 | .clobbers = .{ .eflags = true }, |
| 26825 | .each = .{ .once = &.{ | 39890 | .each = .{ .once = &.{ |
| 26826 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 39891 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26827 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 39892 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26828 | .{ ._, ._, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 39893 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 26829 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 39894 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 26830 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 39895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26831 | } }, | 39896 | } }, |
| 26832 | }, .{ | 39897 | }, .{ |
| 26833 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 39900 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26836 | .patterns = &.{ | 39901 | .patterns = &.{ |
| 26837 | .{ .src = .{ .mem, .none } }, | 39902 | .{ .src = .{ .mem, .none, .none } }, |
| 26838 | .{ .src = .{ .to_sse, .none } }, | 39903 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26839 | }, | 39904 | }, |
| 26840 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39905 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26841 | .each = .{ .once = &.{ | 39906 | .each = .{ .once = &.{ |
| 26842 | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, | 39907 | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 26843 | } }, | 39908 | } }, |
| 26844 | }, .{ | 39909 | }, .{ |
| 26845 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 39912 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26848 | .patterns = &.{ | 39913 | .patterns = &.{ |
| 26849 | .{ .src = .{ .mem, .none } }, | 39914 | .{ .src = .{ .mem, .none, .none } }, |
| 26850 | .{ .src = .{ .to_sse, .none } }, | 39915 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26851 | }, | 39916 | }, |
| 26852 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39917 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26853 | .each = .{ .once = &.{ | 39918 | .each = .{ .once = &.{ |
| 26854 | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, | 39919 | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 26855 | } }, | 39920 | } }, |
| 26856 | }, .{ | 39921 | }, .{ |
| 26857 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 39924 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26860 | .patterns = &.{ | 39925 | .patterns = &.{ |
| 26861 | .{ .src = .{ .mem, .none } }, | 39926 | .{ .src = .{ .mem, .none, .none } }, |
| 26862 | .{ .src = .{ .to_sse, .none } }, | 39927 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26863 | }, | 39928 | }, |
| 26864 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39929 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26865 | .each = .{ .once = &.{ | 39930 | .each = .{ .once = &.{ |
| 26866 | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, | 39931 | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 26867 | } }, | 39932 | } }, |
| 26868 | }, .{ | 39933 | }, .{ |
| 26869 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 39936 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26872 | .patterns = &.{ | 39937 | .patterns = &.{ |
| 26873 | .{ .src = .{ .mem, .none } }, | 39938 | .{ .src = .{ .mem, .none, .none } }, |
| 26874 | .{ .src = .{ .to_sse, .none } }, | 39939 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26875 | }, | 39940 | }, |
| 26876 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 39941 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26877 | .each = .{ .once = &.{ | 39942 | .each = .{ .once = &.{ |
| 26878 | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, | 39943 | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 26879 | } }, | 39944 | } }, |
| 26880 | }, .{ | 39945 | }, .{ |
| 26881 | .required_features = .{ .sse2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 39948 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 26884 | .patterns = &.{ | 39949 | .patterns = &.{ |
| 26885 | .{ .src = .{ .to_mut_sse, .none } }, | 39950 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26886 | }, | 39951 | }, |
| 26887 | .extra_temps = .{ | 39952 | .extra_temps = .{ |
| 26888 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 39953 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 26889 | .unused, | 39954 | .unused, |
| 26890 | .unused, | 39955 | .unused, |
| 26891 | .unused, | 39956 | .unused, |
| ... | @@ -26898,22 +39963,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26898,22 +39963,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26898 | .dst_temps = .{.{ .ref = .src0 }}, | 39963 | .dst_temps = .{.{ .ref = .src0 }}, |
| 26899 | .each = .{ .once = &.{ | 39964 | .each = .{ .once = &.{ |
| 26900 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 39965 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26901 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 39966 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 26902 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | | |
| 26903 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, | | |
| 26904 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 39967 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 26905 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, | 39968 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 26906 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 39969 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26907 | } }, | 39970 | } }, |
| 26908 | }, .{ | 39971 | }, .{ |
| 26909 | .required_features = .{ .sse2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 39974 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 26912 | .patterns = &.{ | 39975 | .patterns = &.{ |
| 26913 | .{ .src = .{ .to_mut_sse, .none } }, | 39976 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 26914 | }, | 39977 | }, |
| 26915 | .extra_temps = .{ | 39978 | .extra_temps = .{ |
| 26916 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 39979 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 26917 | .unused, | 39980 | .unused, |
| 26918 | .unused, | 39981 | .unused, |
| 26919 | .unused, | 39982 | .unused, |
| ... | @@ -26926,40 +39989,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26926,40 +39989,39 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26926 | .dst_temps = .{.{ .ref = .src0 }}, | 39989 | .dst_temps = .{.{ .ref = .src0 }}, |
| 26927 | .each = .{ .once = &.{ | 39990 | .each = .{ .once = &.{ |
| 26928 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 39991 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 26929 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | | |
| 26930 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 39992 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 26931 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 39993 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 26932 | } }, | 39994 | } }, |
| 26933 | }, .{ | 39995 | }, .{ |
| 26934 | .required_features = .{ .avx2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, | 39998 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26937 | .patterns = &.{ | 39999 | .patterns = &.{ |
| 26938 | .{ .src = .{ .mem, .none } }, | 40000 | .{ .src = .{ .mem, .none, .none } }, |
| 26939 | .{ .src = .{ .to_sse, .none } }, | 40001 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26940 | }, | 40002 | }, |
| 26941 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40003 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26942 | .each = .{ .once = &.{ | 40004 | .each = .{ .once = &.{ |
| 26943 | .{ ._, .vp_q, .movsxb, .dst0y, .src0d, ._, ._ }, | 40005 | .{ ._, .vp_q, .movsxw, .dst0y, .src0q, ._, ._ }, |
| 26944 | } }, | 40006 | } }, |
| 26945 | }, .{ | 40007 | }, .{ |
| 26946 | .required_features = .{ .avx2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, | 40010 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26949 | .patterns = &.{ | 40011 | .patterns = &.{ |
| 26950 | .{ .src = .{ .mem, .none } }, | 40012 | .{ .src = .{ .mem, .none, .none } }, |
| 26951 | .{ .src = .{ .to_sse, .none } }, | 40013 | .{ .src = .{ .to_sse, .none, .none } }, |
| 26952 | }, | 40014 | }, |
| 26953 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40015 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 26954 | .each = .{ .once = &.{ | 40016 | .each = .{ .once = &.{ |
| 26955 | .{ ._, .vp_q, .movzxb, .dst0y, .src0d, ._, ._ }, | 40017 | .{ ._, .vp_q, .movzxw, .dst0y, .src0q, ._, ._ }, |
| 26956 | } }, | 40018 | } }, |
| 26957 | }, .{ | 40019 | }, .{ |
| 26958 | .required_features = .{ .avx2, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, | 40022 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 26961 | .patterns = &.{ | 40023 | .patterns = &.{ |
| 26962 | .{ .src = .{ .to_mem, .none } }, | 40024 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26963 | }, | 40025 | }, |
| 26964 | .extra_temps = .{ | 40026 | .extra_temps = .{ |
| 26965 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40027 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -26976,17 +40038,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26976,17 +40038,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26976 | .clobbers = .{ .eflags = true }, | 40038 | .clobbers = .{ .eflags = true }, |
| 26977 | .each = .{ .once = &.{ | 40039 | .each = .{ .once = &.{ |
| 26978 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40040 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 26979 | .{ .@"0:", .vp_q, .movsxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 40041 | .{ .@"0:", .vp_q, .movsxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 26980 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 40042 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 26981 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 40043 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 26982 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40044 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26983 | } }, | 40045 | } }, |
| 26984 | }, .{ | 40046 | }, .{ |
| 26985 | .required_features = .{ .avx2, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, | 40049 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 26988 | .patterns = &.{ | 40050 | .patterns = &.{ |
| 26989 | .{ .src = .{ .to_mem, .none } }, | 40051 | .{ .src = .{ .to_mem, .none, .none } }, |
| 26990 | }, | 40052 | }, |
| 26991 | .extra_temps = .{ | 40053 | .extra_temps = .{ |
| 26992 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40054 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27003,17 +40065,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27003,17 +40065,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27003 | .clobbers = .{ .eflags = true }, | 40065 | .clobbers = .{ .eflags = true }, |
| 27004 | .each = .{ .once = &.{ | 40066 | .each = .{ .once = &.{ |
| 27005 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40067 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27006 | .{ .@"0:", .vp_q, .movzxb, .tmp1y, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 40068 | .{ .@"0:", .vp_q, .movzxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27007 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 40069 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27008 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 40070 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27009 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40071 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27010 | } }, | 40072 | } }, |
| 27011 | }, .{ | 40073 | }, .{ |
| 27012 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40076 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27015 | .patterns = &.{ | 40077 | .patterns = &.{ |
| 27016 | .{ .src = .{ .to_mem, .none } }, | 40078 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27017 | }, | 40079 | }, |
| 27018 | .extra_temps = .{ | 40080 | .extra_temps = .{ |
| 27019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27030,17 +40092,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27030,17 +40092,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27030 | .clobbers = .{ .eflags = true }, | 40092 | .clobbers = .{ .eflags = true }, |
| 27031 | .each = .{ .once = &.{ | 40093 | .each = .{ .once = &.{ |
| 27032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40094 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27033 | .{ .@"0:", .vp_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 40095 | .{ .@"0:", .vp_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27034 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40096 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27035 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 40097 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27036 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40098 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27037 | } }, | 40099 | } }, |
| 27038 | }, .{ | 40100 | }, .{ |
| 27039 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, | 40103 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27042 | .patterns = &.{ | 40104 | .patterns = &.{ |
| 27043 | .{ .src = .{ .to_mem, .none } }, | 40105 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27044 | }, | 40106 | }, |
| 27045 | .extra_temps = .{ | 40107 | .extra_temps = .{ |
| 27046 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40108 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27057,17 +40119,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27057,17 +40119,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27057 | .clobbers = .{ .eflags = true }, | 40119 | .clobbers = .{ .eflags = true }, |
| 27058 | .each = .{ .once = &.{ | 40120 | .each = .{ .once = &.{ |
| 27059 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40121 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27060 | .{ .@"0:", .vp_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 40122 | .{ .@"0:", .vp_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27061 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40123 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27062 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 40124 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27063 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40125 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27064 | } }, | 40126 | } }, |
| 27065 | }, .{ | 40127 | }, .{ |
| 27066 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40130 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27069 | .patterns = &.{ | 40131 | .patterns = &.{ |
| 27070 | .{ .src = .{ .to_mem, .none } }, | 40132 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27071 | }, | 40133 | }, |
| 27072 | .extra_temps = .{ | 40134 | .extra_temps = .{ |
| 27073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40135 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27084,17 +40146,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27084,17 +40146,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27084 | .clobbers = .{ .eflags = true }, | 40146 | .clobbers = .{ .eflags = true }, |
| 27085 | .each = .{ .once = &.{ | 40147 | .each = .{ .once = &.{ |
| 27086 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40148 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27087 | .{ .@"0:", .p_q, .movsxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 40149 | .{ .@"0:", .p_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27088 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40150 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27089 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 40151 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27090 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40152 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27091 | } }, | 40153 | } }, |
| 27092 | }, .{ | 40154 | }, .{ |
| 27093 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, | 40157 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27096 | .patterns = &.{ | 40158 | .patterns = &.{ |
| 27097 | .{ .src = .{ .to_mem, .none } }, | 40159 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27098 | }, | 40160 | }, |
| 27099 | .extra_temps = .{ | 40161 | .extra_temps = .{ |
| 27100 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40162 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27111,44 +40173,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27111,44 +40173,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27111 | .clobbers = .{ .eflags = true }, | 40173 | .clobbers = .{ .eflags = true }, |
| 27112 | .each = .{ .once = &.{ | 40174 | .each = .{ .once = &.{ |
| 27113 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40175 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27114 | .{ .@"0:", .p_q, .movzxb, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 40176 | .{ .@"0:", .p_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27115 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40177 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27116 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 40178 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 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), ._, ._ }, | | |
| 27144 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40179 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27145 | } }, | 40180 | } }, |
| 27146 | }, .{ | 40181 | }, .{ |
| 27147 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 40184 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 27150 | .patterns = &.{ | 40185 | .patterns = &.{ |
| 27151 | .{ .src = .{ .to_mem, .none } }, | 40186 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27152 | }, | 40187 | }, |
| 27153 | .extra_temps = .{ | 40188 | .extra_temps = .{ |
| 27154 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40189 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27164,48 +40199,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27164,48 +40199,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27164 | .dst_temps = .{.mem}, | 40199 | .dst_temps = .{.mem}, |
| 27165 | .clobbers = .{ .eflags = true }, | 40200 | .clobbers = .{ .eflags = true }, |
| 27166 | .each = .{ .once = &.{ | 40201 | .each = .{ .once = &.{ |
| 27167 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40202 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27168 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 40203 | .{ .@"0:", ._, .movsx, .tmp1q, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27169 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 40204 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27170 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 40205 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 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), ._, ._ }, | | |
| 27198 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, | 40211 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 27203 | .patterns = &.{ | 40212 | .patterns = &.{ |
| 27204 | .{ .src = .{ .to_mem, .none } }, | 40213 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27205 | }, | 40214 | }, |
| 27206 | .extra_temps = .{ | 40215 | .extra_temps = .{ |
| 27207 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40216 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27208 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 40217 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 27209 | .unused, | 40218 | .unused, |
| 27210 | .unused, | 40219 | .unused, |
| 27211 | .unused, | 40220 | .unused, |
| ... | @@ -27218,72 +40227,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27218,72 +40227,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27218 | .clobbers = .{ .eflags = true }, | 40227 | .clobbers = .{ .eflags = true }, |
| 27219 | .each = .{ .once = &.{ | 40228 | .each = .{ .once = &.{ |
| 27220 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40229 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27221 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 40230 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27222 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 40231 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27223 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 40232 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27224 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 40233 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27225 | } }, | 40234 | } }, |
| 27226 | }, .{ | 40235 | }, .{ |
| 27227 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | 40238 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27230 | .patterns = &.{ | 40239 | .patterns = &.{ |
| 27231 | .{ .src = .{ .mem, .none } }, | 40240 | .{ .src = .{ .mem, .none, .none } }, |
| 27232 | .{ .src = .{ .to_sse, .none } }, | 40241 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27233 | }, | 40242 | }, |
| 27234 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40243 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27235 | .each = .{ .once = &.{ | 40244 | .each = .{ .once = &.{ |
| 27236 | .{ ._, .vp_q, .movsxb, .dst0x, .src0w, ._, ._ }, | 40245 | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 27237 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, | 40246 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 27238 | } }, | 40247 | } }, |
| 27239 | }, .{ | 40248 | }, .{ |
| 27240 | .required_features = .{ .avx, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 40251 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27243 | .patterns = &.{ | 40252 | .patterns = &.{ |
| 27244 | .{ .src = .{ .mem, .none } }, | 40253 | .{ .src = .{ .mem, .none, .none } }, |
| 27245 | .{ .src = .{ .to_sse, .none } }, | 40254 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27246 | }, | 40255 | }, |
| 27247 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40256 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27248 | .each = .{ .once = &.{ | 40257 | .each = .{ .once = &.{ |
| 27249 | .{ ._, .vp_q, .movzxb, .dst0x, .src0w, ._, ._ }, | 40258 | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 27250 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, | 40259 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 27251 | } }, | 40260 | } }, |
| 27252 | }, .{ | 40261 | }, .{ |
| 27253 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | 40264 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27256 | .patterns = &.{ | 40265 | .patterns = &.{ |
| 27257 | .{ .src = .{ .mem, .none } }, | 40266 | .{ .src = .{ .mem, .none, .none } }, |
| 27258 | .{ .src = .{ .to_sse, .none } }, | 40267 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27259 | }, | 40268 | }, |
| 27260 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40269 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27261 | .each = .{ .once = &.{ | 40270 | .each = .{ .once = &.{ |
| 27262 | .{ ._, .p_q, .movsxb, .dst0x, .src0w, ._, ._ }, | 40271 | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, |
| 27263 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, | 40272 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, |
| 27264 | } }, | 40273 | } }, |
| 27265 | }, .{ | 40274 | }, .{ |
| 27266 | .required_features = .{ .sse4_1, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 40277 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27269 | .patterns = &.{ | 40278 | .patterns = &.{ |
| 27270 | .{ .src = .{ .mem, .none } }, | 40279 | .{ .src = .{ .mem, .none, .none } }, |
| 27271 | .{ .src = .{ .to_sse, .none } }, | 40280 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27272 | }, | 40281 | }, |
| 27273 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40282 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27274 | .each = .{ .once = &.{ | 40283 | .each = .{ .once = &.{ |
| 27275 | .{ ._, .p_q, .movzxb, .dst0x, .src0w, ._, ._ }, | 40284 | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, |
| 27276 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, | 40285 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, |
| 27277 | } }, | 40286 | } }, |
| 27278 | }, .{ | 40287 | }, .{ |
| 27279 | .required_features = .{ .sse2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | 40290 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27282 | .patterns = &.{ | 40291 | .patterns = &.{ |
| 27283 | .{ .src = .{ .to_mut_sse, .none } }, | 40292 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27284 | }, | 40293 | }, |
| 27285 | .extra_temps = .{ | 40294 | .extra_temps = .{ |
| 27286 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 40295 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 27287 | .unused, | 40296 | .unused, |
| 27288 | .unused, | 40297 | .unused, |
| 27289 | .unused, | 40298 | .unused, |
| ... | @@ -27296,9 +40305,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27296,9 +40305,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27296 | .dst_temps = .{.{ .ref = .src0 }}, | 40305 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27297 | .each = .{ .once = &.{ | 40306 | .each = .{ .once = &.{ |
| 27298 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 40307 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27299 | .{ ._, .p_b, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 40308 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27300 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | | |
| 27301 | .{ ._, .p_, .unpcklbw, .tmp0x, .tmp0x, ._, ._ }, | | |
| 27302 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 40309 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 27303 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, | 40310 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, |
| 27304 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 40311 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| ... | @@ -27307,13 +40314,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27307,13 +40314,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27307 | } }, | 40314 | } }, |
| 27308 | }, .{ | 40315 | }, .{ |
| 27309 | .required_features = .{ .sse2, null, null, null }, | 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 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 40318 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27312 | .patterns = &.{ | 40319 | .patterns = &.{ |
| 27313 | .{ .src = .{ .to_mut_sse, .none } }, | 40320 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27314 | }, | 40321 | }, |
| 27315 | .extra_temps = .{ | 40322 | .extra_temps = .{ |
| 27316 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 40323 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 27317 | .unused, | 40324 | .unused, |
| 27318 | .unused, | 40325 | .unused, |
| 27319 | .unused, | 40326 | .unused, |
| ... | @@ -27326,48 +40333,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27326,48 +40333,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27326 | .dst_temps = .{.{ .ref = .src0 }}, | 40333 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27327 | .each = .{ .once = &.{ | 40334 | .each = .{ .once = &.{ |
| 27328 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 40335 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27329 | .{ ._, .p_, .unpcklbw, .dst0x, .tmp0x, ._, ._ }, | | |
| 27330 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 40336 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, |
| 27331 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 40337 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 27332 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, | 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 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.any_scalar_signed_int}, | 40343 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27369 | .patterns = &.{ | 40344 | .patterns = &.{ |
| 27370 | .{ .src = .{ .to_mem, .none } }, | 40345 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27371 | }, | 40346 | }, |
| 27372 | .extra_temps = .{ | 40347 | .extra_temps = .{ |
| 27373 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40348 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27385,51 +40360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27385,51 +40360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27385 | .each = .{ .once = &.{ | 40360 | .each = .{ .once = &.{ |
| 27386 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40361 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27387 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, | 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 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 40364 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 27390 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, | 40365 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, |
| 27391 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 40366 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 27392 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 40367 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 27393 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 40368 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 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), ._, ._ }, | | |
| 27425 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40369 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27426 | } }, | 40370 | } }, |
| 27427 | }, .{ | 40371 | }, .{ |
| 27428 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .dst_constraints = .{.any_scalar_int}, | 40374 | .dst_constraints = .{.any_scalar_int}, |
| 27431 | .patterns = &.{ | 40375 | .patterns = &.{ |
| 27432 | .{ .src = .{ .to_mem, .none } }, | 40376 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27433 | }, | 40377 | }, |
| 27434 | .extra_temps = .{ | 40378 | .extra_temps = .{ |
| 27435 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40379 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -27447,71 +40391,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27447,71 +40391,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27447 | .each = .{ .once = &.{ | 40391 | .each = .{ .once = &.{ |
| 27448 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40392 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27449 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, | 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 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 40395 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 27452 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 40396 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 27453 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 40397 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 27454 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 40398 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 27455 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 40399 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27456 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 40400 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27457 | } }, | 40401 | } }, |
| 27458 | }, .{ | 40402 | }, .{ |
| 27459 | .required_features = .{ .avx, null, null, null }, | 40403 | .required_features = .{ .avx, null, null, null }, |
| 27460 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, | 40404 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27461 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 40405 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27462 | .patterns = &.{ | 40406 | .patterns = &.{ |
| 27463 | .{ .src = .{ .mem, .none } }, | 40407 | .{ .src = .{ .mem, .none, .none } }, |
| 27464 | .{ .src = .{ .to_sse, .none } }, | 40408 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27465 | }, | 40409 | }, |
| 27466 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40410 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27467 | .each = .{ .once = &.{ | 40411 | .each = .{ .once = &.{ |
| 27468 | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, | 40412 | .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 27469 | } }, | 40413 | } }, |
| 27470 | }, .{ | 40414 | }, .{ |
| 27471 | .required_features = .{ .avx, null, null, null }, | 40415 | .required_features = .{ .avx, null, null, null }, |
| 27472 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 40416 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27473 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 40417 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27474 | .patterns = &.{ | 40418 | .patterns = &.{ |
| 27475 | .{ .src = .{ .mem, .none } }, | 40419 | .{ .src = .{ .mem, .none, .none } }, |
| 27476 | .{ .src = .{ .to_sse, .none } }, | 40420 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27477 | }, | 40421 | }, |
| 27478 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40422 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27479 | .each = .{ .once = &.{ | 40423 | .each = .{ .once = &.{ |
| 27480 | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, | 40424 | .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 27481 | } }, | 40425 | } }, |
| 27482 | }, .{ | 40426 | }, .{ |
| 27483 | .required_features = .{ .sse4_1, null, null, null }, | 40427 | .required_features = .{ .sse4_1, null, null, null }, |
| 27484 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, | 40428 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27485 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 40429 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27486 | .patterns = &.{ | 40430 | .patterns = &.{ |
| 27487 | .{ .src = .{ .mem, .none } }, | 40431 | .{ .src = .{ .mem, .none, .none } }, |
| 27488 | .{ .src = .{ .to_sse, .none } }, | 40432 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27489 | }, | 40433 | }, |
| 27490 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40434 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27491 | .each = .{ .once = &.{ | 40435 | .each = .{ .once = &.{ |
| 27492 | .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ }, | 40436 | .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ }, |
| 27493 | } }, | 40437 | } }, |
| 27494 | }, .{ | 40438 | }, .{ |
| 27495 | .required_features = .{ .sse4_1, null, null, null }, | 40439 | .required_features = .{ .sse4_1, null, null, null }, |
| 27496 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 40440 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27497 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 40441 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27498 | .patterns = &.{ | 40442 | .patterns = &.{ |
| 27499 | .{ .src = .{ .mem, .none } }, | 40443 | .{ .src = .{ .mem, .none, .none } }, |
| 27500 | .{ .src = .{ .to_sse, .none } }, | 40444 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27501 | }, | 40445 | }, |
| 27502 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40446 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27503 | .each = .{ .once = &.{ | 40447 | .each = .{ .once = &.{ |
| 27504 | .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ }, | 40448 | .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ }, |
| 27505 | } }, | 40449 | } }, |
| 27506 | }, .{ | 40450 | }, .{ |
| 27507 | .required_features = .{ .sse2, null, null, null }, | 40451 | .required_features = .{ .sse2, null, null, null }, |
| 27508 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, | 40452 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27509 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 40453 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27510 | .patterns = &.{ | 40454 | .patterns = &.{ |
| 27511 | .{ .src = .{ .to_mut_sse, .none } }, | 40455 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27512 | }, | 40456 | }, |
| 27513 | .extra_temps = .{ | 40457 | .extra_temps = .{ |
| 27514 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, | 40458 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 27515 | .unused, | 40459 | .unused, |
| 27516 | .unused, | 40460 | .unused, |
| 27517 | .unused, | 40461 | .unused, |
| ... | @@ -27524,18 +40468,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27524,18 +40468,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27524 | .dst_temps = .{.{ .ref = .src0 }}, | 40468 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27525 | .each = .{ .once = &.{ | 40469 | .each = .{ .once = &.{ |
| 27526 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 40470 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27527 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 40471 | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27528 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 40472 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 27529 | } }, | 40473 | } }, |
| 27530 | }, .{ | 40474 | }, .{ |
| 27531 | .required_features = .{ .sse2, null, null, null }, | 40475 | .required_features = .{ .sse2, null, null, null }, |
| 27532 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 40476 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27533 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .dword } }}, | 40477 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27534 | .patterns = &.{ | 40478 | .patterns = &.{ |
| 27535 | .{ .src = .{ .to_mut_sse, .none } }, | 40479 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27536 | }, | 40480 | }, |
| 27537 | .extra_temps = .{ | 40481 | .extra_temps = .{ |
| 27538 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 40482 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 27539 | .unused, | 40483 | .unused, |
| 27540 | .unused, | 40484 | .unused, |
| 27541 | .unused, | 40485 | .unused, |
| ... | @@ -27548,42 +40492,42 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27548,42 +40492,42 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27548 | .dst_temps = .{.{ .ref = .src0 }}, | 40492 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27549 | .each = .{ .once = &.{ | 40493 | .each = .{ .once = &.{ |
| 27550 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 40494 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27551 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 40495 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| 27552 | } }, | 40496 | } }, |
| 27553 | }, .{ | 40497 | }, .{ |
| 27554 | .required_features = .{ .avx2, null, null, null }, | 40498 | .required_features = .{ .avx2, null, null, null }, |
| 27555 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, | 40499 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 27556 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, | 40500 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 27557 | .patterns = &.{ | 40501 | .patterns = &.{ |
| 27558 | .{ .src = .{ .mem, .none } }, | 40502 | .{ .src = .{ .mem, .none, .none } }, |
| 27559 | .{ .src = .{ .to_sse, .none } }, | 40503 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27560 | }, | 40504 | }, |
| 27561 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40505 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27562 | .each = .{ .once = &.{ | 40506 | .each = .{ .once = &.{ |
| 27563 | .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ }, | 40507 | .{ ._, .vp_q, .movsxd, .dst0y, .src0x, ._, ._ }, |
| 27564 | } }, | 40508 | } }, |
| 27565 | }, .{ | 40509 | }, .{ |
| 27566 | .required_features = .{ .avx2, null, null, null }, | 40510 | .required_features = .{ .avx2, null, null, null }, |
| 27567 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any }, | 40511 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 27568 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .dword } }}, | 40512 | .dst_constraints = .{.{ .scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 27569 | .patterns = &.{ | 40513 | .patterns = &.{ |
| 27570 | .{ .src = .{ .mem, .none } }, | 40514 | .{ .src = .{ .mem, .none, .none } }, |
| 27571 | .{ .src = .{ .to_sse, .none } }, | 40515 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27572 | }, | 40516 | }, |
| 27573 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40517 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27574 | .each = .{ .once = &.{ | 40518 | .each = .{ .once = &.{ |
| 27575 | .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ }, | 40519 | .{ ._, .vp_q, .movzxd, .dst0y, .src0x, ._, ._ }, |
| 27576 | } }, | 40520 | } }, |
| 27577 | }, .{ | 40521 | }, .{ |
| 27578 | .required_features = .{ .avx2, null, null, null }, | 40522 | .required_features = .{ .avx2, null, null, null }, |
| 27579 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, | 40523 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 27580 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, | 40524 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 27581 | .patterns = &.{ | 40525 | .patterns = &.{ |
| 27582 | .{ .src = .{ .to_mem, .none } }, | 40526 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27583 | }, | 40527 | }, |
| 27584 | .extra_temps = .{ | 40528 | .extra_temps = .{ |
| 27585 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27586 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, | 40530 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 27587 | .unused, | 40531 | .unused, |
| 27588 | .unused, | 40532 | .unused, |
| 27589 | .unused, | 40533 | .unused, |
| ... | @@ -27596,21 +40540,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27596,21 +40540,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27596 | .clobbers = .{ .eflags = true }, | 40540 | .clobbers = .{ .eflags = true }, |
| 27597 | .each = .{ .once = &.{ | 40541 | .each = .{ .once = &.{ |
| 27598 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 40544 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27601 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 40545 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 27602 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40546 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27603 | } }, | 40547 | } }, |
| 27604 | }, .{ | 40548 | }, .{ |
| 27605 | .required_features = .{ .avx2, null, null, null }, | 40549 | .required_features = .{ .avx2, null, null, null }, |
| 27606 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any }, | 40550 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 27607 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }}, | 40551 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, |
| 27608 | .patterns = &.{ | 40552 | .patterns = &.{ |
| 27609 | .{ .src = .{ .to_mem, .none } }, | 40553 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27610 | }, | 40554 | }, |
| 27611 | .extra_temps = .{ | 40555 | .extra_temps = .{ |
| 27612 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27613 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, | 40557 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 27614 | .unused, | 40558 | .unused, |
| 27615 | .unused, | 40559 | .unused, |
| 27616 | .unused, | 40560 | .unused, |
| ... | @@ -27623,21 +40567,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27623,21 +40567,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27623 | .clobbers = .{ .eflags = true }, | 40567 | .clobbers = .{ .eflags = true }, |
| 27624 | .each = .{ .once = &.{ | 40568 | .each = .{ .once = &.{ |
| 27625 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 40571 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 27628 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 40572 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 27629 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40573 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27630 | } }, | 40574 | } }, |
| 27631 | }, .{ | 40575 | }, .{ |
| 27632 | .required_features = .{ .avx, null, null, null }, | 40576 | .required_features = .{ .avx, null, null, null }, |
| 27633 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, | 40577 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27634 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 40578 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27635 | .patterns = &.{ | 40579 | .patterns = &.{ |
| 27636 | .{ .src = .{ .to_mem, .none } }, | 40580 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27637 | }, | 40581 | }, |
| 27638 | .extra_temps = .{ | 40582 | .extra_temps = .{ |
| 27639 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40583 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27640 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 40584 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 27641 | .unused, | 40585 | .unused, |
| 27642 | .unused, | 40586 | .unused, |
| 27643 | .unused, | 40587 | .unused, |
| ... | @@ -27650,21 +40594,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27650,21 +40594,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27650 | .clobbers = .{ .eflags = true }, | 40594 | .clobbers = .{ .eflags = true }, |
| 27651 | .each = .{ .once = &.{ | 40595 | .each = .{ .once = &.{ |
| 27652 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40598 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27655 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 40599 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27656 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40600 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27657 | } }, | 40601 | } }, |
| 27658 | }, .{ | 40602 | }, .{ |
| 27659 | .required_features = .{ .avx, null, null, null }, | 40603 | .required_features = .{ .avx, null, null, null }, |
| 27660 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 40604 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 27661 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, | 40605 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27662 | .patterns = &.{ | 40606 | .patterns = &.{ |
| 27663 | .{ .src = .{ .to_mem, .none } }, | 40607 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27664 | }, | 40608 | }, |
| 27665 | .extra_temps = .{ | 40609 | .extra_temps = .{ |
| 27666 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40610 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27667 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 40611 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 27668 | .unused, | 40612 | .unused, |
| 27669 | .unused, | 40613 | .unused, |
| 27670 | .unused, | 40614 | .unused, |
| ... | @@ -27677,21 +40621,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27677,21 +40621,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27677 | .clobbers = .{ .eflags = true }, | 40621 | .clobbers = .{ .eflags = true }, |
| 27678 | .each = .{ .once = &.{ | 40622 | .each = .{ .once = &.{ |
| 27679 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40625 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27682 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 40626 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27683 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40627 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27684 | } }, | 40628 | } }, |
| 27685 | }, .{ | 40629 | }, .{ |
| 27686 | .required_features = .{ .sse4_1, null, null, null }, | 40630 | .required_features = .{ .sse4_1, null, null, null }, |
| 27687 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, | 40631 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27688 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 40632 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 27689 | .patterns = &.{ | 40633 | .patterns = &.{ |
| 27690 | .{ .src = .{ .to_mem, .none } }, | 40634 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27691 | }, | 40635 | }, |
| 27692 | .extra_temps = .{ | 40636 | .extra_temps = .{ |
| 27693 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40637 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27694 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 40638 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 27695 | .unused, | 40639 | .unused, |
| 27696 | .unused, | 40640 | .unused, |
| 27697 | .unused, | 40641 | .unused, |
| ... | @@ -27704,21 +40648,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27704,21 +40648,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27704 | .clobbers = .{ .eflags = true }, | 40648 | .clobbers = .{ .eflags = true }, |
| 27705 | .each = .{ .once = &.{ | 40649 | .each = .{ .once = &.{ |
| 27706 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40652 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27709 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 40653 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27710 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40654 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27711 | } }, | 40655 | } }, |
| 27712 | }, .{ | 40656 | }, .{ |
| 27713 | .required_features = .{ .sse4_1, null, null, null }, | 40657 | .required_features = .{ .sse4_1, null, null, null }, |
| 27714 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 40658 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 27715 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }}, | 40659 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, |
| 27716 | .patterns = &.{ | 40660 | .patterns = &.{ |
| 27717 | .{ .src = .{ .to_mem, .none } }, | 40661 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27718 | }, | 40662 | }, |
| 27719 | .extra_temps = .{ | 40663 | .extra_temps = .{ |
| 27720 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40664 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27721 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 40665 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 27722 | .unused, | 40666 | .unused, |
| 27723 | .unused, | 40667 | .unused, |
| 27724 | .unused, | 40668 | .unused, |
| ... | @@ -27731,20 +40675,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27731,20 +40675,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27731 | .clobbers = .{ .eflags = true }, | 40675 | .clobbers = .{ .eflags = true }, |
| 27732 | .each = .{ .once = &.{ | 40676 | .each = .{ .once = &.{ |
| 27733 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40679 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 27736 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 40680 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27737 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40681 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27738 | } }, | 40682 | } }, |
| 27739 | }, .{ | 40683 | }, .{ |
| 27740 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 40684 | .required_features = .{ .@"64bit", null, null, null }, |
| 27741 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 40687 | .patterns = &.{ |
| 27743 | .{ .src = .{ .to_mem, .none } }, | 40688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27744 | }, | 40689 | }, |
| 27745 | .extra_temps = .{ | 40690 | .extra_temps = .{ |
| 27746 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40691 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27747 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 40692 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 27748 | .unused, | 40693 | .unused, |
| 27749 | .unused, | 40694 | .unused, |
| 27750 | .unused, | 40695 | .unused, |
| ... | @@ -27757,20 +40702,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27757,20 +40702,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27757 | .clobbers = .{ .eflags = true }, | 40702 | .clobbers = .{ .eflags = true }, |
| 27758 | .each = .{ .once = &.{ | 40703 | .each = .{ .once = &.{ |
| 27759 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27760 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 40705 | .{ .@"0:", ._, .movsxd, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27761 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 40706 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27762 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 40707 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27763 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40708 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27764 | } }, | 40709 | } }, |
| 27765 | }, .{ | 40710 | }, .{ |
| 27766 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 40711 | .required_features = .{ .@"64bit", null, null, null }, |
| 27767 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }}, | 40712 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| | 40713 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, |
| 27768 | .patterns = &.{ | 40714 | .patterns = &.{ |
| 27769 | .{ .src = .{ .to_mem, .none } }, | 40715 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27770 | }, | 40716 | }, |
| 27771 | .extra_temps = .{ | 40717 | .extra_temps = .{ |
| 27772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40718 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27773 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 40719 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 27774 | .unused, | 40720 | .unused, |
| 27775 | .unused, | 40721 | .unused, |
| 27776 | .unused, | 40722 | .unused, |
| ... | @@ -27783,68 +40729,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27783,68 +40729,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27783 | .clobbers = .{ .eflags = true }, | 40729 | .clobbers = .{ .eflags = true }, |
| 27784 | .each = .{ .once = &.{ | 40730 | .each = .{ .once = &.{ |
| 27785 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40731 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27786 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 40732 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27787 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 40733 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 27788 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 40734 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 27789 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40735 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27790 | } }, | 40736 | } }, |
| 27791 | }, .{ | 40737 | }, .{ |
| 27792 | .required_features = .{ .avx, null, null, null }, | 40738 | .required_features = .{ .avx, null, null, null }, |
| 27793 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, | 40739 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27794 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40740 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27795 | .patterns = &.{ | 40741 | .patterns = &.{ |
| 27796 | .{ .src = .{ .mem, .none } }, | 40742 | .{ .src = .{ .mem, .none, .none } }, |
| 27797 | .{ .src = .{ .to_sse, .none } }, | 40743 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27798 | }, | 40744 | }, |
| 27799 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40745 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27800 | .each = .{ .once = &.{ | 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 | .required_features = .{ .avx, null, null, null }, | 40751 | .required_features = .{ .avx, null, null, null }, |
| 27805 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any }, | 40752 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27806 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 40753 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27807 | .patterns = &.{ | 40754 | .patterns = &.{ |
| 27808 | .{ .src = .{ .mem, .none } }, | 40755 | .{ .src = .{ .mem, .none, .none } }, |
| 27809 | .{ .src = .{ .to_sse, .none } }, | 40756 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27810 | }, | 40757 | }, |
| 27811 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40758 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27812 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse4_1, null, null, null }, | 40764 | .required_features = .{ .sse4_1, null, null, null }, |
| 27817 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, | 40765 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27818 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40766 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27819 | .patterns = &.{ | 40767 | .patterns = &.{ |
| 27820 | .{ .src = .{ .mem, .none } }, | 40768 | .{ .src = .{ .mem, .none, .none } }, |
| 27821 | .{ .src = .{ .to_sse, .none } }, | 40769 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27822 | }, | 40770 | }, |
| 27823 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40771 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27824 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse4_1, null, null, null }, | 40777 | .required_features = .{ .sse4_1, null, null, null }, |
| 27829 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any }, | 40778 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27830 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 40779 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27831 | .patterns = &.{ | 40780 | .patterns = &.{ |
| 27832 | .{ .src = .{ .mem, .none } }, | 40781 | .{ .src = .{ .mem, .none, .none } }, |
| 27833 | .{ .src = .{ .to_sse, .none } }, | 40782 | .{ .src = .{ .to_sse, .none, .none } }, |
| 27834 | }, | 40783 | }, |
| 27835 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 40784 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 27836 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse2, null, null, null }, | 40790 | .required_features = .{ .sse2, null, null, null }, |
| 27841 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, | 40791 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27842 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40792 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 27843 | .patterns = &.{ | 40793 | .patterns = &.{ |
| 27844 | .{ .src = .{ .to_mut_sse, .none } }, | 40794 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27845 | }, | 40795 | }, |
| 27846 | .extra_temps = .{ | 40796 | .extra_temps = .{ |
| 27847 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, | 40797 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 27848 | .unused, | 40798 | .unused, |
| 27849 | .unused, | 40799 | .unused, |
| 27850 | .unused, | 40800 | .unused, |
| ... | @@ -27857,20 +40807,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27857,20 +40807,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27857 | .dst_temps = .{.{ .ref = .src0 }}, | 40807 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27858 | .each = .{ .once = &.{ | 40808 | .each = .{ .once = &.{ |
| 27859 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 40809 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27860 | .{ ._, .p_w, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 40810 | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, |
| 27861 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | | |
| 27862 | .{ ._, .p_, .unpcklwd, .tmp0x, .tmp0x, ._, ._ }, | | |
| 27863 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 40811 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| | 40812 | .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ }, |
| | 40813 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 27864 | } }, | 40814 | } }, |
| 27865 | }, .{ | 40815 | }, .{ |
| 27866 | .required_features = .{ .sse2, null, null, null }, | 40816 | .required_features = .{ .sse2, null, null, null }, |
| 27867 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any }, | 40817 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27868 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 40818 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, |
| 27869 | .patterns = &.{ | 40819 | .patterns = &.{ |
| 27870 | .{ .src = .{ .to_mut_sse, .none } }, | 40820 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 27871 | }, | 40821 | }, |
| 27872 | .extra_temps = .{ | 40822 | .extra_temps = .{ |
| 27873 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 40823 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 27874 | .unused, | 40824 | .unused, |
| 27875 | .unused, | 40825 | .unused, |
| 27876 | .unused, | 40826 | .unused, |
| ... | @@ -27883,45 +40833,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27883,45 +40833,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27883 | .dst_temps = .{.{ .ref = .src0 }}, | 40833 | .dst_temps = .{.{ .ref = .src0 }}, |
| 27884 | .each = .{ .once = &.{ | 40834 | .each = .{ .once = &.{ |
| 27885 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 40835 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| 27886 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | | |
| 27887 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 40836 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, |
| | 40837 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, |
| 27888 | } }, | 40838 | } }, |
| 27889 | }, .{ | 40839 | }, .{ |
| 27890 | .required_features = .{ .avx2, null, null, null }, | 40840 | .required_features = .{ .@"64bit", null, null, null }, |
| 27891 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any }, | 40841 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27892 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, | 40842 | .dst_constraints = .{.any_scalar_signed_int}, |
| 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 } }}, | | |
| 27917 | .patterns = &.{ | 40843 | .patterns = &.{ |
| 27918 | .{ .src = .{ .to_mem, .none } }, | 40844 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27919 | }, | 40845 | }, |
| 27920 | .extra_temps = .{ | 40846 | .extra_temps = .{ |
| 27921 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40847 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27922 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 40848 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 27923 | .unused, | 40849 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 27924 | .unused, | 40850 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27925 | .unused, | 40851 | .unused, |
| 27926 | .unused, | 40852 | .unused, |
| 27927 | .unused, | 40853 | .unused, |
| ... | @@ -27932,23 +40858,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27932,23 +40858,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27932 | .clobbers = .{ .eflags = true }, | 40858 | .clobbers = .{ .eflags = true }, |
| 27933 | .each = .{ .once = &.{ | 40859 | .each = .{ .once = &.{ |
| 27934 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40860 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27935 | .{ .@"0:", .vp_q, .movsxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 40861 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 27936 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 40862 | .{ .@"0:", ._, .movsxd, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27937 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40868 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27939 | } }, | 40869 | } }, |
| 27940 | }, .{ | 40870 | }, .{ |
| 27941 | .required_features = .{ .avx2, null, null, null }, | 40871 | .required_features = .{ .@"64bit", null, null, null }, |
| 27942 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .word } }, .any }, | 40872 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 27943 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, | 40873 | .dst_constraints = .{.any_scalar_int}, |
| 27944 | .patterns = &.{ | 40874 | .patterns = &.{ |
| 27945 | .{ .src = .{ .to_mem, .none } }, | 40875 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27946 | }, | 40876 | }, |
| 27947 | .extra_temps = .{ | 40877 | .extra_temps = .{ |
| 27948 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40878 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 27949 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 40879 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 27950 | .unused, | 40880 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 27951 | .unused, | 40881 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27952 | .unused, | 40882 | .unused, |
| 27953 | .unused, | 40883 | .unused, |
| 27954 | .unused, | 40884 | .unused, |
| ... | @@ -27959,24 +40889,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27959,24 +40889,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27959 | .clobbers = .{ .eflags = true }, | 40889 | .clobbers = .{ .eflags = true }, |
| 27960 | .each = .{ .once = &.{ | 40890 | .each = .{ .once = &.{ |
| 27961 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40891 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 27962 | .{ .@"0:", .vp_q, .movzxw, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 40892 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, |
| 27963 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 40893 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 27964 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 40899 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27966 | } }, | 40900 | } }, |
| 27967 | }, .{ | 40901 | }, .{ |
| 27968 | .required_features = .{ .avx, null, null, null }, | 40902 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 27969 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, | 40903 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 27970 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40904 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27971 | .patterns = &.{ | 40905 | .patterns = &.{ |
| 27972 | .{ .src = .{ .to_mem, .none } }, | 40906 | .{ .src = .{ .to_mem, .none, .none } }, |
| 27973 | }, | 40907 | }, |
| 27974 | .extra_temps = .{ | 40908 | .extra_temps = .{ |
| 27975 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40909 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 27976 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 40910 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 27977 | .unused, | 40911 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 27978 | .unused, | 40912 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 27979 | .unused, | 40913 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 27980 | .unused, | 40914 | .unused, |
| 27981 | .unused, | 40915 | .unused, |
| 27982 | .unused, | 40916 | .unused, |
| ... | @@ -27985,25 +40919,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27985,25 +40919,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27985 | .dst_temps = .{.mem}, | 40919 | .dst_temps = .{.mem}, |
| 27986 | .clobbers = .{ .eflags = true }, | 40920 | .clobbers = .{ .eflags = true }, |
| 27987 | .each = .{ .once = &.{ | 40921 | .each = .{ .once = &.{ |
| 27988 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40922 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 27989 | .{ .@"0:", .vp_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 40923 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 27990 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40924 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 27991 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 40925 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 27992 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 40936 | .required_features = .{ .@"64bit", null, null, null }, |
| 27996 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any }, | 40937 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 27997 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, | 40938 | .dst_constraints = .{.any_scalar_signed_int}, |
| 27998 | .patterns = &.{ | 40939 | .patterns = &.{ |
| 27999 | .{ .src = .{ .to_mem, .none } }, | 40940 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28000 | }, | 40941 | }, |
| 28001 | .extra_temps = .{ | 40942 | .extra_temps = .{ |
| 28002 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40943 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28003 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 40944 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28004 | .unused, | 40945 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28005 | .unused, | 40946 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28006 | .unused, | 40947 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 28007 | .unused, | 40948 | .unused, |
| 28008 | .unused, | 40949 | .unused, |
| 28009 | .unused, | 40950 | .unused, |
| ... | @@ -28012,25 +40953,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28012,25 +40953,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28012 | .dst_temps = .{.mem}, | 40953 | .dst_temps = .{.mem}, |
| 28013 | .clobbers = .{ .eflags = true }, | 40954 | .clobbers = .{ .eflags = true }, |
| 28014 | .each = .{ .once = &.{ | 40955 | .each = .{ .once = &.{ |
| 28015 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40956 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 28016 | .{ .@"0:", .vp_q, .movzxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 40957 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 28017 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40958 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 28018 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 40959 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 28019 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 40970 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 28023 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any }, | 40971 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 28024 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 40972 | .dst_constraints = .{.any_scalar_int}, |
| 28025 | .patterns = &.{ | 40973 | .patterns = &.{ |
| 28026 | .{ .src = .{ .to_mem, .none } }, | 40974 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28027 | }, | 40975 | }, |
| 28028 | .extra_temps = .{ | 40976 | .extra_temps = .{ |
| 28029 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 40977 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28030 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 40978 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28031 | .unused, | 40979 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28032 | .unused, | 40980 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28033 | .unused, | 40981 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28034 | .unused, | 40982 | .unused, |
| 28035 | .unused, | 40983 | .unused, |
| 28036 | .unused, | 40984 | .unused, |
| ... | @@ -28039,319 +40987,374 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28039,319 +40987,374 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28039 | .dst_temps = .{.mem}, | 40987 | .dst_temps = .{.mem}, |
| 28040 | .clobbers = .{ .eflags = true }, | 40988 | .clobbers = .{ .eflags = true }, |
| 28041 | .each = .{ .once = &.{ | 40989 | .each = .{ .once = &.{ |
| 28042 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 40990 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 28043 | .{ .@"0:", .p_q, .movsxw, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 40991 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 28044 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 40992 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 28045 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 40993 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| 28046 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 41002 | .required_features = .{ .@"64bit", null, null, null }, |
| 28050 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any }, | 41003 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 28051 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, | 41004 | .dst_constraints = .{.any_scalar_int}, |
| 28052 | .patterns = &.{ | 41005 | .patterns = &.{ |
| 28053 | .{ .src = .{ .to_mem, .none } }, | 41006 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28054 | }, | 41007 | }, |
| 28055 | .extra_temps = .{ | 41008 | .extra_temps = .{ |
| 28056 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41009 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28057 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 41010 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28058 | .unused, | 41011 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28059 | .unused, | 41012 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28060 | .unused, | 41013 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 28061 | .unused, | 41014 | .unused, |
| 28062 | .unused, | 41015 | .unused, |
| 28063 | .unused, | 41016 | .unused, |
| 28064 | .unused, | 41017 | .unused, |
| 28065 | }, | 41018 | }, |
| 28066 | .dst_temps = .{.mem}, | 41019 | .dst_temps = .{.mem}, |
| 28067 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 41161 | .each = .{ .once = &.{ |
| 28069 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41162 | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 28074 | } }, | 41163 | } }, |
| 28075 | }, .{ | 41164 | }, .{ |
| 28076 | .required_features = .{ .@"64bit", null, null, null }, | 41165 | .required_features = .{ .fast_imm16, null, null, null }, |
| 28077 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 41166 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 28078 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 41167 | .dst_constraints = .{.{ .unsigned_int = .word }}, |
| 28079 | .patterns = &.{ | 41168 | .patterns = &.{ |
| 28080 | .{ .src = .{ .to_mem, .none } }, | 41169 | .{ .src = .{ .to_mut_gpr, .none, .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, | | |
| 28092 | }, | 41170 | }, |
| 28093 | .dst_temps = .{.mem}, | 41171 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28094 | .clobbers = .{ .eflags = true }, | 41172 | .clobbers = .{ .eflags = true }, |
| 28095 | .each = .{ .once = &.{ | 41173 | .each = .{ .once = &.{ |
| 28096 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41174 | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 28101 | } }, | 41175 | } }, |
| 28102 | }, .{ | 41176 | }, .{ |
| 28103 | .required_features = .{ .@"64bit", null, null, null }, | 41177 | .required_features = .{ .fast_imm16, null, null, null }, |
| 28104 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 41178 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28105 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, | 41179 | .dst_constraints = .{.{ .unsigned_int = .word }}, |
| 28106 | .patterns = &.{ | 41180 | .patterns = &.{ |
| 28107 | .{ .src = .{ .to_mem, .none } }, | 41181 | .{ .src = .{ .to_mem, .none, .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, | | |
| 28119 | }, | 41182 | }, |
| 28120 | .dst_temps = .{.mem}, | 41183 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28121 | .clobbers = .{ .eflags = true }, | 41184 | .clobbers = .{ .eflags = true }, |
| 28122 | .each = .{ .once = &.{ | 41185 | .each = .{ .once = &.{ |
| 28123 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41186 | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, |
| 28124 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 41187 | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, |
| 28125 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | | |
| 28126 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 28127 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 28128 | } }, | 41188 | } }, |
| 28129 | }, .{ | 41189 | }, .{ |
| 28130 | .required_features = .{ .avx, null, null, null }, | 41190 | .src_constraints = .{ .{ .int = .gpr }, .any, .any }, |
| 28131 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 41191 | .dst_constraints = .{.{ .exact_int = 32 }}, |
| 28132 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | | |
| 28133 | .patterns = &.{ | 41192 | .patterns = &.{ |
| 28134 | .{ .src = .{ .mem, .none } }, | 41193 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28135 | .{ .src = .{ .to_sse, .none } }, | | |
| 28136 | }, | 41194 | }, |
| 28137 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41195 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28138 | .each = .{ .once = &.{ | 41196 | .each = .{ .once = &.{} }, |
| 28139 | .{ ._, .vp_q, .movsxw, .dst0x, .src0d, ._, ._ }, | | |
| 28140 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, | | |
| 28141 | } }, | | |
| 28142 | }, .{ | 41197 | }, .{ |
| 28143 | .required_features = .{ .avx, null, null, null }, | 41198 | .src_constraints = .{ .any_int, .any, .any }, |
| 28144 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any }, | 41199 | .dst_constraints = .{.{ .exact_int = 32 }}, |
| 28145 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | | |
| 28146 | .patterns = &.{ | 41200 | .patterns = &.{ |
| 28147 | .{ .src = .{ .mem, .none } }, | 41201 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28148 | .{ .src = .{ .to_sse, .none } }, | | |
| 28149 | }, | 41202 | }, |
| 28150 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41203 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28151 | .each = .{ .once = &.{ | 41204 | .each = .{ .once = &.{ |
| 28152 | .{ ._, .vp_q, .movzxw, .dst0x, .src0d, ._, ._ }, | 41205 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 28153 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, | | |
| 28154 | } }, | 41206 | } }, |
| 28155 | }, .{ | 41207 | }, .{ |
| 28156 | .required_features = .{ .sse4_1, null, null, null }, | 41208 | .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any }, |
| 28157 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 41209 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 28158 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | | |
| 28159 | .patterns = &.{ | 41210 | .patterns = &.{ |
| 28160 | .{ .src = .{ .mem, .none } }, | 41211 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28161 | .{ .src = .{ .to_sse, .none } }, | | |
| 28162 | }, | 41212 | }, |
| 28163 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41213 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 41214 | .clobbers = .{ .eflags = true }, |
| 28164 | .each = .{ .once = &.{ | 41215 | .each = .{ .once = &.{ |
| 28165 | .{ ._, .p_q, .movsxw, .dst0x, .src0d, ._, ._ }, | 41216 | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 28166 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, | 41217 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 28167 | } }, | 41218 | } }, |
| 28168 | }, .{ | 41219 | }, .{ |
| 28169 | .required_features = .{ .sse4_1, null, null, null }, | 41220 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 28170 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any }, | 41221 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 28171 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | | |
| 28172 | .patterns = &.{ | 41222 | .patterns = &.{ |
| 28173 | .{ .src = .{ .mem, .none } }, | 41223 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28174 | .{ .src = .{ .to_sse, .none } }, | | |
| 28175 | }, | 41224 | }, |
| 28176 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41225 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 41226 | .clobbers = .{ .eflags = true }, |
| 28177 | .each = .{ .once = &.{ | 41227 | .each = .{ .once = &.{ |
| 28178 | .{ ._, .p_q, .movzxw, .dst0x, .src0d, ._, ._ }, | 41228 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 28179 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, | 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 }, | 41233 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 28183 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 41234 | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 28184 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | | |
| 28185 | .patterns = &.{ | 41235 | .patterns = &.{ |
| 28186 | .{ .src = .{ .to_mut_sse, .none } }, | 41236 | .{ .src = .{ .to_mut_gpr, .none, .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, | | |
| 28198 | }, | 41237 | }, |
| 28199 | .dst_temps = .{.{ .ref = .src0 }}, | 41238 | .dst_temps = .{.{ .ref = .src0 }}, |
| | 41239 | .clobbers = .{ .eflags = true }, |
| 28200 | .each = .{ .once = &.{ | 41240 | .each = .{ .once = &.{ |
| 28201 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 41241 | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, |
| 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, ._, ._ }, | | |
| 28208 | } }, | 41242 | } }, |
| 28209 | }, .{ | 41243 | }, .{ |
| 28210 | .required_features = .{ .sse2, null, null, null }, | 41244 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28211 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .word } }, .any }, | 41245 | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 28212 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | | |
| 28213 | .patterns = &.{ | 41246 | .patterns = &.{ |
| 28214 | .{ .src = .{ .to_mut_sse, .none } }, | 41247 | .{ .src = .{ .to_mem, .none, .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, | | |
| 28226 | }, | 41248 | }, |
| 28227 | .dst_temps = .{.{ .ref = .src0 }}, | 41249 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 41250 | .clobbers = .{ .eflags = true }, |
| 28228 | .each = .{ .once = &.{ | 41251 | .each = .{ .once = &.{ |
| 28229 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 41252 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, |
| 28230 | .{ ._, .p_, .unpcklwd, .dst0x, .tmp0x, ._, ._ }, | 41253 | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, |
| 28231 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | | |
| 28232 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, | | |
| 28233 | } }, | 41254 | } }, |
| 28234 | }, .{ | 41255 | }, .{ |
| 28235 | .required_features = .{ .@"64bit", null, null, null }, | 41256 | .required_features = .{ .@"64bit", null, null, null }, |
| 28236 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 41257 | .src_constraints = .{ .any_int, .any, .any }, |
| 28237 | .dst_constraints = .{.any_scalar_signed_int}, | 41258 | .dst_constraints = .{.{ .exact_int = 64 }}, |
| 28238 | .patterns = &.{ | 41259 | .patterns = &.{ |
| 28239 | .{ .src = .{ .to_mem, .none } }, | 41260 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28240 | }, | 41261 | }, |
| 28241 | .extra_temps = .{ | 41262 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28242 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41263 | .each = .{ .once = &.{ |
| 28243 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41264 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 28244 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 41265 | } }, |
| 28245 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41266 | }, .{ |
| 28246 | .unused, | 41267 | .required_features = .{ .@"64bit", null, null, null }, |
| 28247 | .unused, | 41268 | .src_constraints = .{ .{ .signed_int = .gpr }, .any, .any }, |
| 28248 | .unused, | 41269 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 28249 | .unused, | 41270 | .patterns = &.{ |
| 28250 | .unused, | 41271 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 28251 | }, | 41272 | }, |
| 28252 | .dst_temps = .{.mem}, | 41273 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28253 | .clobbers = .{ .eflags = true }, | 41274 | .clobbers = .{ .eflags = true }, |
| 28254 | .each = .{ .once = &.{ | 41275 | .each = .{ .once = &.{ |
| 28255 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41276 | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 28256 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, | 41277 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 28264 | } }, | 41278 | } }, |
| 28265 | }, .{ | 41279 | }, .{ |
| 28266 | .required_features = .{ .@"64bit", null, null, null }, | 41280 | .required_features = .{ .@"64bit", null, null, null }, |
| 28267 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 41281 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 28268 | .dst_constraints = .{.any_scalar_int}, | 41282 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 28269 | .patterns = &.{ | 41283 | .patterns = &.{ |
| 28270 | .{ .src = .{ .to_mem, .none } }, | 41284 | .{ .src = .{ .to_mem, .none, .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, | | |
| 28282 | }, | 41285 | }, |
| 28283 | .dst_temps = .{.mem}, | 41286 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 28284 | .clobbers = .{ .eflags = true }, | 41287 | .clobbers = .{ .eflags = true }, |
| 28285 | .each = .{ .once = &.{ | 41288 | .each = .{ .once = &.{ |
| 28286 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41289 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, |
| 28287 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, | 41290 | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 28288 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 41291 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_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", ._, ._, ._ }, | | |
| 28295 | } }, | 41292 | } }, |
| 28296 | }, .{ | 41293 | }, .{ |
| 28297 | .required_features = .{ .avx, null, null, null }, | 41294 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 28298 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, | 41295 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 28299 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 41296 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28300 | .patterns = &.{ | 41297 | .patterns = &.{ |
| 28301 | .{ .src = .{ .mem, .none } }, | 41298 | .{ .src = .{ .mem, .none, .none } }, |
| 28302 | .{ .src = .{ .to_sse, .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 | .each = .{ .once = &.{ | 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 }, | 41308 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 28310 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, | 41309 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28311 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 41310 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28312 | .patterns = &.{ | 41311 | .patterns = &.{ |
| 28313 | .{ .src = .{ .mem, .none } }, | 41312 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28314 | .{ .src = .{ .to_sse, .none } }, | | |
| 28315 | }, | 41313 | }, |
| 28316 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41314 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 41315 | .clobbers = .{ .eflags = true }, |
| 28317 | .each = .{ .once = &.{ | 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 }, | 41321 | .required_features = .{ .@"64bit", null, null, null }, |
| 28322 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, | 41322 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any, .any }, |
| 28323 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 41323 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28324 | .patterns = &.{ | 41324 | .patterns = &.{ |
| 28325 | .{ .src = .{ .mem, .none } }, | 41325 | .{ .src = .{ .mem, .none, .none } }, |
| 28326 | .{ .src = .{ .to_sse, .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 | .each = .{ .once = &.{ | 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 }, | 41335 | .required_features = .{ .@"64bit", null, null, null }, |
| 28334 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, | 41336 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28335 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 41337 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 28336 | .patterns = &.{ | 41338 | .patterns = &.{ |
| 28337 | .{ .src = .{ .mem, .none } }, | 41339 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28338 | .{ .src = .{ .to_sse, .none } }, | | |
| 28339 | }, | 41340 | }, |
| 28340 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41341 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| | 41342 | .clobbers = .{ .eflags = true }, |
| 28341 | .each = .{ .once = &.{ | 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 }, | 41348 | .required_features = .{ .@"64bit", null, null, null }, |
| 28346 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, | 41349 | .src_constraints = .{ .any_int, .any, .any }, |
| 28347 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 41350 | .dst_constraints = .{.{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 28348 | .patterns = &.{ | 41351 | .patterns = &.{ |
| 28349 | .{ .src = .{ .to_mut_sse, .none } }, | 41352 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28350 | }, | 41353 | }, |
| 28351 | .extra_temps = .{ | 41354 | .extra_temps = .{ |
| 28352 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 41355 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28353 | .unused, | 41356 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28354 | .unused, | 41357 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28355 | .unused, | 41358 | .unused, |
| 28356 | .unused, | 41359 | .unused, |
| 28357 | .unused, | 41360 | .unused, |
| ... | @@ -28359,23 +41362,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28359,23 +41362,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28359 | .unused, | 41362 | .unused, |
| 28360 | .unused, | 41363 | .unused, |
| 28361 | }, | 41364 | }, |
| 28362 | .dst_temps = .{.{ .ref = .src0 }}, | 41365 | .dst_temps = .{.mem}, |
| 28363 | .each = .{ .once = &.{ | 41366 | .each = .{ .once = &.{ |
| 28364 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 41367 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28365 | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 41368 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28366 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 41369 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| | 41370 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28367 | } }, | 41371 | } }, |
| 28368 | }, .{ | 41372 | }, .{ |
| 28369 | .required_features = .{ .sse2, null, null, null }, | 41373 | .required_features = .{ .@"64bit", null, null, null }, |
| 28370 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any }, | 41374 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 28371 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .qword } }}, | 41375 | .dst_constraints = .{.{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 28372 | .patterns = &.{ | 41376 | .patterns = &.{ |
| 28373 | .{ .src = .{ .to_mut_sse, .none } }, | 41377 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28374 | }, | 41378 | }, |
| 28375 | .extra_temps = .{ | 41379 | .extra_temps = .{ |
| 28376 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 41380 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28377 | .unused, | 41381 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28378 | .unused, | 41382 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28379 | .unused, | 41383 | .unused, |
| 28380 | .unused, | 41384 | .unused, |
| 28381 | .unused, | 41385 | .unused, |
| ... | @@ -28383,46 +41387,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28383,46 +41387,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28383 | .unused, | 41387 | .unused, |
| 28384 | .unused, | 41388 | .unused, |
| 28385 | }, | 41389 | }, |
| 28386 | .dst_temps = .{.{ .ref = .src0 }}, | 41390 | .dst_temps = .{.mem}, |
| 28387 | .each = .{ .once = &.{ | 41391 | .clobbers = .{ .eflags = true }, |
| 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 } }}, | | |
| 28412 | .each = .{ .once = &.{ | 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 }, | 41403 | .required_features = .{ .@"64bit", null, null, null }, |
| 28417 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, | 41404 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 28418 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, | 41405 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 28419 | .patterns = &.{ | 41406 | .patterns = &.{ |
| 28420 | .{ .src = .{ .to_mem, .none } }, | 41407 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28421 | }, | 41408 | }, |
| 28422 | .extra_temps = .{ | 41409 | .extra_temps = .{ |
| 28423 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41410 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28424 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 41411 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28425 | .unused, | 41412 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28426 | .unused, | 41413 | .unused, |
| 28427 | .unused, | 41414 | .unused, |
| 28428 | .unused, | 41415 | .unused, |
| ... | @@ -28433,23 +41420,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28433,23 +41420,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28433 | .dst_temps = .{.mem}, | 41420 | .dst_temps = .{.mem}, |
| 28434 | .clobbers = .{ .eflags = true }, | 41421 | .clobbers = .{ .eflags = true }, |
| 28435 | .each = .{ .once = &.{ | 41422 | .each = .{ .once = &.{ |
| 28436 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41423 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28437 | .{ .@"0:", .vp_q, .movsxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 41424 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28438 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 41425 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 28439 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 41426 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28440 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 41435 | .required_features = .{ .@"64bit", null, null, null }, |
| 28444 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 41436 | .src_constraints = .{ .any_signed_int, .any, .any }, |
| 28445 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }}, | 41437 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 28446 | .patterns = &.{ | 41438 | .patterns = &.{ |
| 28447 | .{ .src = .{ .to_mem, .none } }, | 41439 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28448 | }, | 41440 | }, |
| 28449 | .extra_temps = .{ | 41441 | .extra_temps = .{ |
| 28450 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41442 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28451 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 41443 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28452 | .unused, | 41444 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28453 | .unused, | 41445 | .unused, |
| 28454 | .unused, | 41446 | .unused, |
| 28455 | .unused, | 41447 | .unused, |
| ... | @@ -28460,23 +41452,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28460,23 +41452,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28460 | .dst_temps = .{.mem}, | 41452 | .dst_temps = .{.mem}, |
| 28461 | .clobbers = .{ .eflags = true }, | 41453 | .clobbers = .{ .eflags = true }, |
| 28462 | .each = .{ .once = &.{ | 41454 | .each = .{ .once = &.{ |
| 28463 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41455 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28464 | .{ .@"0:", .vp_q, .movzxd, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 41456 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28465 | .{ ._, .v_dqa, .mov, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 41457 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 28466 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 41458 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28467 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 41465 | .required_features = .{ .@"64bit", null, null, null }, |
| 28471 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, | 41466 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28472 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 41467 | .dst_constraints = .{.{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 28473 | .patterns = &.{ | 41468 | .patterns = &.{ |
| 28474 | .{ .src = .{ .to_mem, .none } }, | 41469 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28475 | }, | 41470 | }, |
| 28476 | .extra_temps = .{ | 41471 | .extra_temps = .{ |
| 28477 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41472 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28478 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 41473 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28479 | .unused, | 41474 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28480 | .unused, | 41475 | .unused, |
| 28481 | .unused, | 41476 | .unused, |
| 28482 | .unused, | 41477 | .unused, |
| ... | @@ -28485,25 +41480,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28485,25 +41480,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28485 | .unused, | 41480 | .unused, |
| 28486 | }, | 41481 | }, |
| 28487 | .dst_temps = .{.mem}, | 41482 | .dst_temps = .{.mem}, |
| 28488 | .clobbers = .{ .eflags = true }, | | |
| 28489 | .each = .{ .once = &.{ | 41483 | .each = .{ .once = &.{ |
| 28490 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41484 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28491 | .{ .@"0:", .vp_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 41485 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28492 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 41486 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 28493 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 41487 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28494 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 41488 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 28495 | } }, | 41489 | } }, |
| 28496 | }, .{ | 41490 | }, .{ |
| 28497 | .required_features = .{ .avx, null, null, null }, | 41491 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 28498 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .word } }, .any }, | 41492 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28499 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, | 41493 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 28500 | .patterns = &.{ | 41494 | .patterns = &.{ |
| 28501 | .{ .src = .{ .to_mem, .none } }, | 41495 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28502 | }, | 41496 | }, |
| 28503 | .extra_temps = .{ | 41497 | .extra_temps = .{ |
| 28504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41498 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28505 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 41499 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28506 | .unused, | 41500 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28507 | .unused, | 41501 | .unused, |
| 28508 | .unused, | 41502 | .unused, |
| 28509 | .unused, | 41503 | .unused, |
| ... | @@ -28514,23 +41508,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28514,23 +41508,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28514 | .dst_temps = .{.mem}, | 41508 | .dst_temps = .{.mem}, |
| 28515 | .clobbers = .{ .eflags = true }, | 41509 | .clobbers = .{ .eflags = true }, |
| 28516 | .each = .{ .once = &.{ | 41510 | .each = .{ .once = &.{ |
| 28517 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41511 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28518 | .{ .@"0:", .vp_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 41512 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28519 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 41513 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 28520 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 41514 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28521 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 41521 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 28525 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any }, | 41522 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28526 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 41523 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 28527 | .patterns = &.{ | 41524 | .patterns = &.{ |
| 28528 | .{ .src = .{ .to_mem, .none } }, | 41525 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28529 | }, | 41526 | }, |
| 28530 | .extra_temps = .{ | 41527 | .extra_temps = .{ |
| 28531 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41528 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28532 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 41529 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28533 | .unused, | 41530 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28534 | .unused, | 41531 | .unused, |
| 28535 | .unused, | 41532 | .unused, |
| 28536 | .unused, | 41533 | .unused, |
| ... | @@ -28541,23 +41538,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28541,23 +41538,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28541 | .dst_temps = .{.mem}, | 41538 | .dst_temps = .{.mem}, |
| 28542 | .clobbers = .{ .eflags = true }, | 41539 | .clobbers = .{ .eflags = true }, |
| 28543 | .each = .{ .once = &.{ | 41540 | .each = .{ .once = &.{ |
| 28544 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41541 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28545 | .{ .@"0:", .p_q, .movsxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 41542 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28546 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 41543 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 28547 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 41544 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 41550 | .required_features = .{ .@"64bit", null, null, null }, |
| 28552 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .dword } }, .any }, | 41551 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28553 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }}, | 41552 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 28554 | .patterns = &.{ | 41553 | .patterns = &.{ |
| 28555 | .{ .src = .{ .to_mem, .none } }, | 41554 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28556 | }, | 41555 | }, |
| 28557 | .extra_temps = .{ | 41556 | .extra_temps = .{ |
| 28558 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41557 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28559 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 41558 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28560 | .unused, | 41559 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28561 | .unused, | 41560 | .unused, |
| 28562 | .unused, | 41561 | .unused, |
| 28563 | .unused, | 41562 | .unused, |
| ... | @@ -28568,23 +41567,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28568,23 +41567,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28568 | .dst_temps = .{.mem}, | 41567 | .dst_temps = .{.mem}, |
| 28569 | .clobbers = .{ .eflags = true }, | 41568 | .clobbers = .{ .eflags = true }, |
| 28570 | .each = .{ .once = &.{ | 41569 | .each = .{ .once = &.{ |
| 28571 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41570 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28572 | .{ .@"0:", .p_q, .movzxd, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 41571 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28573 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 41572 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 28574 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 41573 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28575 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .@"64bit", null, null, null }, | 41580 | .required_features = .{ .@"64bit", null, null, null }, |
| 28579 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 41581 | .src_constraints = .{ .any_unsigned_int, .any, .any }, |
| 28580 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 41582 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 28581 | .patterns = &.{ | 41583 | .patterns = &.{ |
| 28582 | .{ .src = .{ .to_mem, .none } }, | 41584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28583 | }, | 41585 | }, |
| 28584 | .extra_temps = .{ | 41586 | .extra_temps = .{ |
| 28585 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41587 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 28586 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 41588 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 28587 | .unused, | 41589 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28588 | .unused, | 41590 | .unused, |
| 28589 | .unused, | 41591 | .unused, |
| 28590 | .unused, | 41592 | .unused, |
| ... | @@ -28595,23 +41597,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28595,23 +41597,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28595 | .dst_temps = .{.mem}, | 41597 | .dst_temps = .{.mem}, |
| 28596 | .clobbers = .{ .eflags = true }, | 41598 | .clobbers = .{ .eflags = true }, |
| 28597 | .each = .{ .once = &.{ | 41599 | .each = .{ .once = &.{ |
| 28598 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41600 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 28599 | .{ .@"0:", ._, .movsxd, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 41601 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 28600 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 41602 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, |
| 28601 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 41603 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 28602 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 41609 | .required_features = .{ .avx, null, null, null }, |
| 28606 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 41610 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28607 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }}, | 41611 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28608 | .patterns = &.{ | 41612 | .patterns = &.{ |
| 28609 | .{ .src = .{ .to_mem, .none } }, | 41613 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28610 | }, | 41614 | }, |
| 28611 | .extra_temps = .{ | 41615 | .extra_temps = .{ |
| 28612 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41616 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28613 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 41617 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28614 | .unused, | 41618 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28615 | .unused, | 41619 | .unused, |
| 28616 | .unused, | 41620 | .unused, |
| 28617 | .unused, | 41621 | .unused, |
| ... | @@ -28619,77 +41623,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28619,77 +41623,73 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28619 | .unused, | 41623 | .unused, |
| 28620 | .unused, | 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 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41626 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28640 | .each = .{ .once = &.{ | 41627 | .each = .{ .once = &.{ |
| 28641 | .{ ._, .vp_q, .movsxd, .dst0x, .src0q, ._, ._ }, | 41628 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28642 | .{ ._, .vp_q, .movsxd, .dst0x, .dst0q, ._, ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 41635 | .required_features = .{ .avx, null, null, null }, |
| 28646 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 41636 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28647 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 41637 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28648 | .patterns = &.{ | 41638 | .patterns = &.{ |
| 28649 | .{ .src = .{ .mem, .none } }, | 41639 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28650 | .{ .src = .{ .to_sse, .none } }, | | |
| 28651 | }, | 41640 | }, |
| 28652 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41641 | .extra_temps = .{ |
| 28653 | .each = .{ .once = &.{ | 41642 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28654 | .{ ._, .vp_q, .movzxd, .dst0x, .src0q, ._, ._ }, | 41643 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 28655 | .{ ._, .vp_q, .movzxd, .dst0x, .dst0q, ._, ._ }, | 41644 | .unused, |
| 28656 | } }, | 41645 | .unused, |
| 28657 | }, .{ | 41646 | .unused, |
| 28658 | .required_features = .{ .sse4_1, null, null, null }, | 41647 | .unused, |
| 28659 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 41648 | .unused, |
| 28660 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | 41649 | .unused, |
| 28661 | .patterns = &.{ | 41650 | .unused, |
| 28662 | .{ .src = .{ .mem, .none } }, | | |
| 28663 | .{ .src = .{ .to_sse, .none } }, | | |
| 28664 | }, | 41651 | }, |
| 28665 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 41652 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28666 | .each = .{ .once = &.{ | 41653 | .each = .{ .once = &.{ |
| 28667 | .{ ._, .p_q, .movsxd, .dst0x, .src0q, ._, ._ }, | 41654 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28668 | .{ ._, .p_q, .movsxd, .dst0x, .dst0q, ._, ._ }, | 41655 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 28669 | } }, | 41656 | } }, |
| 28670 | }, .{ | 41657 | }, .{ |
| 28671 | .required_features = .{ .sse4_1, null, null, null }, | 41658 | .required_features = .{ .sse2, null, null, null }, |
| 28672 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 41659 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28673 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 41660 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28674 | .patterns = &.{ | 41661 | .patterns = &.{ |
| 28675 | .{ .src = .{ .mem, .none } }, | 41662 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28676 | .{ .src = .{ .to_sse, .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 | .each = .{ .once = &.{ | 41676 | .each = .{ .once = &.{ |
| 28680 | .{ ._, .p_q, .movzxd, .dst0x, .src0q, ._, ._ }, | 41677 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28681 | .{ ._, .p_q, .movzxd, .dst0x, .dst0q, ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 41684 | .required_features = .{ .sse2, null, null, null }, |
| 28685 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 41685 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28686 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .xword } }}, | 41686 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28687 | .patterns = &.{ | 41687 | .patterns = &.{ |
| 28688 | .{ .src = .{ .to_mut_sse, .none } }, | 41688 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28689 | }, | 41689 | }, |
| 28690 | .extra_temps = .{ | 41690 | .extra_temps = .{ |
| 28691 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 41691 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28692 | .unused, | 41692 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 28693 | .unused, | 41693 | .unused, |
| 28694 | .unused, | 41694 | .unused, |
| 28695 | .unused, | 41695 | .unused, |
| ... | @@ -28700,22 +41700,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28700,22 +41700,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28700 | }, | 41700 | }, |
| 28701 | .dst_temps = .{.{ .ref = .src0 }}, | 41701 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28702 | .each = .{ .once = &.{ | 41702 | .each = .{ .once = &.{ |
| 28703 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 41703 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28704 | .{ ._, .p_d, .cmpgt, .tmp0x, .src0x, ._, ._ }, | 41704 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 28705 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | | |
| 28706 | .{ ._, .p_, .unpckldq, .tmp0x, .tmp0x, ._, ._ }, | | |
| 28707 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, | | |
| 28708 | } }, | 41705 | } }, |
| 28709 | }, .{ | 41706 | }, .{ |
| 28710 | .required_features = .{ .sse2, null, null, null }, | 41707 | .required_features = .{ .sse, null, null, null }, |
| 28711 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 41708 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28712 | .dst_constraints = .{.{ .scalar_int = .{ .of = .xword, .is = .xword } }}, | 41709 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28713 | .patterns = &.{ | 41710 | .patterns = &.{ |
| 28714 | .{ .src = .{ .to_mut_sse, .none } }, | 41711 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 28715 | }, | 41712 | }, |
| 28716 | .extra_temps = .{ | 41713 | .extra_temps = .{ |
| 28717 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 41714 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28718 | .unused, | 41715 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 28719 | .unused, | 41716 | .unused, |
| 28720 | .unused, | 41717 | .unused, |
| 28721 | .unused, | 41718 | .unused, |
| ... | @@ -28726,86 +41723,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28726,86 +41723,72 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28726 | }, | 41723 | }, |
| 28727 | .dst_temps = .{.{ .ref = .src0 }}, | 41724 | .dst_temps = .{.{ .ref = .src0 }}, |
| 28728 | .each = .{ .once = &.{ | 41725 | .each = .{ .once = &.{ |
| 28729 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 41726 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28730 | .{ ._, .p_, .unpckldq, .dst0x, .tmp0x, ._, ._ }, | 41727 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 28731 | .{ ._, .p_, .unpcklqdq, .dst0x, .tmp0x, ._, ._ }, | | |
| 28732 | } }, | 41728 | } }, |
| 28733 | }, .{ | 41729 | }, .{ |
| 28734 | .required_features = .{ .@"64bit", null, null, null }, | 41730 | .required_features = .{ .avx2, null, null, null }, |
| 28735 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 41731 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 28736 | .dst_constraints = .{.any_scalar_signed_int}, | 41732 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }}, |
| 28737 | .patterns = &.{ | 41733 | .patterns = &.{ |
| 28738 | .{ .src = .{ .to_mem, .none } }, | 41734 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28739 | }, | 41735 | }, |
| 28740 | .extra_temps = .{ | 41736 | .extra_temps = .{ |
| 28741 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41737 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28742 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41738 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28743 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 41739 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28744 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41740 | .unused, |
| 28745 | .unused, | 41741 | .unused, |
| 28746 | .unused, | 41742 | .unused, |
| 28747 | .unused, | 41743 | .unused, |
| 28748 | .unused, | 41744 | .unused, |
| 28749 | .unused, | 41745 | .unused, |
| 28750 | }, | 41746 | }, |
| 28751 | .dst_temps = .{.mem}, | 41747 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28752 | .clobbers = .{ .eflags = true }, | | |
| 28753 | .each = .{ .once = &.{ | 41748 | .each = .{ .once = &.{ |
| 28754 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41749 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28755 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, | 41750 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 28756 | .{ .@"0:", ._, .movsxd, .tmp2q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 41751 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 28757 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 41752 | .{ ._, .vp_b, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 28758 | .{ ._, ._r, .sa, .tmp2q, .si(63), ._, ._ }, | 41753 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| 28759 | .{ ._, ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | | |
| 28760 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | | |
| 28761 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | | |
| 28762 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 28763 | } }, | 41754 | } }, |
| 28764 | }, .{ | 41755 | }, .{ |
| 28765 | .required_features = .{ .@"64bit", null, null, null }, | 41756 | .required_features = .{ .avx2, null, null, null }, |
| 28766 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 41757 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 28767 | .dst_constraints = .{.any_scalar_int}, | 41758 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, |
| 28768 | .patterns = &.{ | 41759 | .patterns = &.{ |
| 28769 | .{ .src = .{ .to_mem, .none } }, | 41760 | .{ .src = .{ .to_sse, .none, .none } }, |
| 28770 | }, | 41761 | }, |
| 28771 | .extra_temps = .{ | 41762 | .extra_temps = .{ |
| 28772 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 41763 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28773 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41764 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 28774 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 41765 | .unused, |
| 28775 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41766 | .unused, |
| 28776 | .unused, | 41767 | .unused, |
| 28777 | .unused, | 41768 | .unused, |
| 28778 | .unused, | 41769 | .unused, |
| 28779 | .unused, | 41770 | .unused, |
| 28780 | .unused, | 41771 | .unused, |
| 28781 | }, | 41772 | }, |
| 28782 | .dst_temps = .{.mem}, | 41773 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 28783 | .clobbers = .{ .eflags = true }, | | |
| 28784 | .each = .{ .once = &.{ | 41774 | .each = .{ .once = &.{ |
| 28785 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 41775 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 28786 | .{ ._, ._, .lea, .tmp1q, .mem(.dst0), ._, ._ }, | 41776 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 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", ._, ._, ._ }, | | |
| 28794 | } }, | 41777 | } }, |
| 28795 | }, .{ | 41778 | }, .{ |
| 28796 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 41779 | .required_features = .{ .avx2, null, null, null }, |
| 28797 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 41780 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 28798 | .dst_constraints = .{.any_scalar_signed_int}, | 41781 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }}, |
| 28799 | .patterns = &.{ | 41782 | .patterns = &.{ |
| 28800 | .{ .src = .{ .to_mem, .none } }, | 41783 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28801 | }, | 41784 | }, |
| 28802 | .extra_temps = .{ | 41785 | .extra_temps = .{ |
| 28803 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 41786 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28804 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 41787 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 28805 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41788 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 28806 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41789 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| 28807 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 41790 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28808 | .unused, | 41791 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28809 | .unused, | 41792 | .unused, |
| 28810 | .unused, | 41793 | .unused, |
| 28811 | .unused, | 41794 | .unused, |
| ... | @@ -28813,32 +41796,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28813,32 +41796,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28813 | .dst_temps = .{.mem}, | 41796 | .dst_temps = .{.mem}, |
| 28814 | .clobbers = .{ .eflags = true }, | 41797 | .clobbers = .{ .eflags = true }, |
| 28815 | .each = .{ .once = &.{ | 41798 | .each = .{ .once = &.{ |
| 28816 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 41799 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 28817 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 41800 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 28818 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 41801 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 28819 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, | 41802 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, |
| 28820 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 41803 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 28821 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, | 41804 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 28822 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 41805 | .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 28823 | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, | 41806 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 28824 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, | 41807 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 28825 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 41808 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 28826 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | 41809 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28827 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, | | |
| 28828 | } }, | 41810 | } }, |
| 28829 | }, .{ | 41811 | }, .{ |
| 28830 | .required_features = .{ .@"64bit", null, null, null }, | 41812 | .required_features = .{ .avx2, null, null, null }, |
| 28831 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 41813 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| 28832 | .dst_constraints = .{.any_scalar_signed_int}, | 41814 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, |
| 28833 | .patterns = &.{ | 41815 | .patterns = &.{ |
| 28834 | .{ .src = .{ .to_mem, .none } }, | 41816 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28835 | }, | 41817 | }, |
| 28836 | .extra_temps = .{ | 41818 | .extra_temps = .{ |
| 28837 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 41819 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28838 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 41820 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 28839 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41821 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 28840 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41822 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28841 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 41823 | .unused, |
| 28842 | .unused, | 41824 | .unused, |
| 28843 | .unused, | 41825 | .unused, |
| 28844 | .unused, | 41826 | .unused, |
| ... | @@ -28847,33 +41829,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28847,33 +41829,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28847 | .dst_temps = .{.mem}, | 41829 | .dst_temps = .{.mem}, |
| 28848 | .clobbers = .{ .eflags = true }, | 41830 | .clobbers = .{ .eflags = true }, |
| 28849 | .each = .{ .once = &.{ | 41831 | .each = .{ .once = &.{ |
| 28850 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 41832 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 28851 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 41833 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 28852 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 41834 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 28853 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, | 41835 | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 28854 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 41836 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 28855 | .{ ._, ._sq, .lod, ._, ._, ._, ._ }, | 41837 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 28856 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 41838 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 28862 | } }, | 41839 | } }, |
| 28863 | }, .{ | 41840 | }, .{ |
| 28864 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 41841 | .required_features = .{ .avx, null, null, null }, |
| 28865 | .src_constraints = .{ .any_scalar_int, .any }, | 41842 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28866 | .dst_constraints = .{.any_scalar_int}, | 41843 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, |
| 28867 | .patterns = &.{ | 41844 | .patterns = &.{ |
| 28868 | .{ .src = .{ .to_mem, .none } }, | 41845 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28869 | }, | 41846 | }, |
| 28870 | .extra_temps = .{ | 41847 | .extra_temps = .{ |
| 28871 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 41848 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28872 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 41849 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 28873 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41850 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 28874 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41851 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 28875 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 41852 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28876 | .unused, | 41853 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28877 | .unused, | 41854 | .unused, |
| 28878 | .unused, | 41855 | .unused, |
| 28879 | .unused, | 41856 | .unused, |
| ... | @@ -28881,30 +41858,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28881,30 +41858,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28881 | .dst_temps = .{.mem}, | 41858 | .dst_temps = .{.mem}, |
| 28882 | .clobbers = .{ .eflags = true }, | 41859 | .clobbers = .{ .eflags = true }, |
| 28883 | .each = .{ .once = &.{ | 41860 | .each = .{ .once = &.{ |
| 28884 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 41861 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 28885 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 41862 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 28886 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 41863 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, |
| 28887 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, | 41864 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 28888 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 41865 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 28889 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, | 41866 | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 28890 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, | 41867 | .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 28891 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 41868 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 28892 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | 41869 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 28893 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, | 41870 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 41871 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28894 | } }, | 41872 | } }, |
| 28895 | }, .{ | 41873 | }, .{ |
| 28896 | .required_features = .{ .@"64bit", null, null, null }, | 41874 | .required_features = .{ .avx, null, null, null }, |
| 28897 | .src_constraints = .{ .any_scalar_int, .any }, | 41875 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| 28898 | .dst_constraints = .{.any_scalar_int}, | 41876 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, |
| 28899 | .patterns = &.{ | 41877 | .patterns = &.{ |
| 28900 | .{ .src = .{ .to_mem, .none } }, | 41878 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28901 | }, | 41879 | }, |
| 28902 | .extra_temps = .{ | 41880 | .extra_temps = .{ |
| 28903 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 41881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28904 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 41882 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 28905 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 41883 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 28906 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 41884 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28907 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 41885 | .unused, |
| 28908 | .unused, | 41886 | .unused, |
| 28909 | .unused, | 41887 | .unused, |
| 28910 | .unused, | 41888 | .unused, |
| ... | @@ -28913,342 +41891,425 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28913,342 +41891,425 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28913 | .dst_temps = .{.mem}, | 41891 | .dst_temps = .{.mem}, |
| 28914 | .clobbers = .{ .eflags = true }, | 41892 | .clobbers = .{ .eflags = true }, |
| 28915 | .each = .{ .once = &.{ | 41893 | .each = .{ .once = &.{ |
| 28916 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 41894 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 28917 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 41895 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 28918 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 41896 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 28919 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, | 41897 | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 28920 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 41898 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 28921 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, | 41899 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 28922 | .{ ._, ._, .mov, .tmp3d, .sa2(.dst0, .src0, .add_delta_elem_size_div_8), ._, ._ }, | 41900 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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), ._, ._ }, | | |
| 28984 | } }, | 41901 | } }, |
| 28985 | }, .{ | 41902 | }, .{ |
| 28986 | .src_constraints = .{ .any_unsigned_int, .any }, | 41903 | .required_features = .{ .sse2, null, null, null }, |
| 28987 | .dst_constraints = .{.{ .exact_unsigned_int = 8 }}, | 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 | .patterns = &.{ | 41906 | .patterns = &.{ |
| 28989 | .{ .src = .{ .to_mem, .none } }, | 41907 | .{ .src = .{ .to_mem, .none, .none } }, |
| 28990 | }, | 41908 | }, |
| 28991 | .dst_temps = .{.{ .rc = .general_purpose }}, | 41909 | .extra_temps = .{ |
| 28992 | .each = .{ .once = &.{ | 41910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28993 | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, | 41911 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 28994 | } }, | 41912 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 28995 | }, .{ | 41913 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| 28996 | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, | 41914 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 28997 | .dst_constraints = .{.{ .signed_int = .byte }}, | 41915 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 28998 | .patterns = &.{ | 41916 | .unused, |
| 28999 | .{ .src = .{ .to_mut_gpr, .none } }, | 41917 | .unused, |
| | 41918 | .unused, |
| 29000 | }, | 41919 | }, |
| 29001 | .dst_temps = .{.{ .ref = .src0 }}, | 41920 | .dst_temps = .{.mem}, |
| 29002 | .clobbers = .{ .eflags = true }, | 41921 | .clobbers = .{ .eflags = true }, |
| 29003 | .each = .{ .once = &.{ | 41922 | .each = .{ .once = &.{ |
| 29004 | .{ ._, ._l, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 41923 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, |
| 29005 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 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 }, | 41937 | .required_features = .{ .sse2, null, null, null }, |
| 29009 | .dst_constraints = .{.{ .unsigned_int = .byte }}, | 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 | .patterns = &.{ | 41940 | .patterns = &.{ |
| 29011 | .{ .src = .{ .to_mut_gpr, .none } }, | 41941 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29012 | }, | 41942 | }, |
| 29013 | .dst_temps = .{.{ .ref = .src0 }}, | 41943 | .extra_temps = .{ |
| 29014 | .clobbers = .{ .eflags = true }, | 41944 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29015 | .each = .{ .once = &.{ | 41945 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29016 | .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ }, | 41946 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29017 | } }, | 41947 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29018 | }, .{ | 41948 | .unused, |
| 29019 | .src_constraints = .{ .any_int, .any }, | 41949 | .unused, |
| 29020 | .dst_constraints = .{.{ .unsigned_int = .byte }}, | 41950 | .unused, |
| 29021 | .patterns = &.{ | 41951 | .unused, |
| 29022 | .{ .src = .{ .to_mem, .none } }, | 41952 | .unused, |
| 29023 | }, | 41953 | }, |
| 29024 | .dst_temps = .{.{ .rc = .general_purpose }}, | 41954 | .dst_temps = .{.mem}, |
| 29025 | .clobbers = .{ .eflags = true }, | 41955 | .clobbers = .{ .eflags = true }, |
| 29026 | .each = .{ .once = &.{ | 41956 | .each = .{ .once = &.{ |
| 29027 | .{ ._, ._, .movzx, .dst0d, .mem(.src0b), ._, ._ }, | 41957 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| 29028 | .{ ._, ._, .@"and", .dst0b, .sa(.dst0, .add_umax), ._, ._ }, | 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 }, | 41967 | .required_features = .{ .sse, null, null, null }, |
| 29032 | .dst_constraints = .{.{ .exact_int = 16 }}, | 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 | .patterns = &.{ | 41970 | .patterns = &.{ |
| 29034 | .{ .src = .{ .to_mut_gpr, .none } }, | 41971 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29035 | }, | 41972 | }, |
| 29036 | .dst_temps = .{.{ .ref = .src0 }}, | 41973 | .extra_temps = .{ |
| 29037 | .each = .{ .once = &.{} }, | 41974 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29038 | }, .{ | 41975 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29039 | .src_constraints = .{ .any_signed_int, .any }, | 41976 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 29040 | .dst_constraints = .{.{ .exact_signed_int = 16 }}, | 41977 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 29041 | .patterns = &.{ | 41978 | .unused, |
| 29042 | .{ .src = .{ .to_mem, .none } }, | 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 | .each = .{ .once = &.{ | 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 }, | 41997 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29050 | .dst_constraints = .{.{ .exact_unsigned_int = 16 }}, | 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 | .patterns = &.{ | 42000 | .patterns = &.{ |
| 29052 | .{ .src = .{ .to_mem, .none } }, | 42001 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29053 | }, | 42002 | }, |
| 29054 | .dst_temps = .{.{ .rc = .general_purpose }}, | 42003 | .extra_temps = .{ |
| 29055 | .each = .{ .once = &.{ | 42004 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29056 | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, | 42005 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29057 | } }, | 42006 | .unused, |
| 29058 | }, .{ | 42007 | .unused, |
| 29059 | .required_features = .{ .fast_imm16, null, null, null }, | 42008 | .unused, |
| 29060 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, | 42009 | .unused, |
| 29061 | .dst_constraints = .{.{ .unsigned_int = .word }}, | 42010 | .unused, |
| 29062 | .patterns = &.{ | 42011 | .unused, |
| 29063 | .{ .src = .{ .to_mut_gpr, .none } }, | 42012 | .unused, |
| 29064 | }, | 42013 | }, |
| 29065 | .dst_temps = .{.{ .ref = .src0 }}, | 42014 | .dst_temps = .{.mem}, |
| 29066 | .clobbers = .{ .eflags = true }, | 42015 | .clobbers = .{ .eflags = true }, |
| 29067 | .each = .{ .once = &.{ | 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 }, | 42026 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 29072 | .src_constraints = .{ .any_unsigned_int, .any }, | 42027 | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, |
| 29073 | .dst_constraints = .{.{ .unsigned_int = .word }}, | | |
| 29074 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 42043 | .clobbers = .{ .eflags = true }, |
| 29079 | .each = .{ .once = &.{ | 42044 | .each = .{ .once = &.{ |
| 29080 | .{ ._, ._, .movzx, .dst0d, .mem(.src0w), ._, ._ }, | 42045 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29081 | .{ ._, ._, .@"and", .dst0w, .sa(.dst0, .add_umax), ._, ._ }, | 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 }, | 42054 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29085 | .dst_constraints = .{.{ .exact_int = 32 }}, | 42055 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 29086 | .patterns = &.{ | 42056 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 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 }}, | | |
| 29094 | .patterns = &.{ | 42057 | .patterns = &.{ |
| 29095 | .{ .src = .{ .to_mem, .none } }, | 42058 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29096 | }, | 42059 | }, |
| 29097 | .dst_temps = .{.{ .rc = .general_purpose }}, | 42060 | .extra_temps = .{ |
| 29098 | .each = .{ .once = &.{ | 42061 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29099 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, | 42062 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29100 | } }, | 42063 | .unused, |
| 29101 | }, .{ | 42064 | .unused, |
| 29102 | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, | 42065 | .unused, |
| 29103 | .dst_constraints = .{.{ .signed_int = .dword }}, | 42066 | .unused, |
| 29104 | .patterns = &.{ | 42067 | .unused, |
| 29105 | .{ .src = .{ .to_mut_gpr, .none } }, | 42068 | .unused, |
| | 42069 | .unused, |
| 29106 | }, | 42070 | }, |
| 29107 | .dst_temps = .{.{ .ref = .src0 }}, | 42071 | .dst_temps = .{.mem}, |
| 29108 | .clobbers = .{ .eflags = true }, | 42072 | .clobbers = .{ .eflags = true }, |
| 29109 | .each = .{ .once = &.{ | 42073 | .each = .{ .once = &.{ |
| 29110 | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 42074 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29111 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_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 }, | 42083 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 29115 | .dst_constraints = .{.{ .signed_int = .dword }}, | 42084 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29116 | .patterns = &.{ | 42085 | .patterns = &.{ |
| 29117 | .{ .src = .{ .to_mem, .none } }, | 42086 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29118 | }, | 42087 | }, |
| 29119 | .dst_temps = .{.{ .rc = .general_purpose }}, | 42088 | .extra_temps = .{ |
| 29120 | .clobbers = .{ .eflags = true }, | 42089 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29121 | .each = .{ .once = &.{ | 42090 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29122 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, | 42091 | .unused, |
| 29123 | .{ ._, ._l, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 42092 | .unused, |
| 29124 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 42093 | .unused, |
| 29125 | } }, | 42094 | .unused, |
| 29126 | }, .{ | 42095 | .unused, |
| 29127 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, | 42096 | .unused, |
| 29128 | .dst_constraints = .{.{ .unsigned_int = .dword }}, | 42097 | .unused, |
| 29129 | .patterns = &.{ | | |
| 29130 | .{ .src = .{ .to_mut_gpr, .none } }, | | |
| 29131 | }, | 42098 | }, |
| 29132 | .dst_temps = .{.{ .ref = .src0 }}, | 42099 | .dst_temps = .{.mem}, |
| 29133 | .clobbers = .{ .eflags = true }, | 42100 | .clobbers = .{ .eflags = true }, |
| 29134 | .each = .{ .once = &.{ | 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 }, | 42111 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29139 | .dst_constraints = .{.{ .unsigned_int = .dword }}, | 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 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 42129 | .clobbers = .{ .eflags = true }, |
| 29145 | .each = .{ .once = &.{ | 42130 | .each = .{ .once = &.{ |
| 29146 | .{ ._, ._, .mov, .dst0d, .mem(.src0d), ._, ._ }, | 42131 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29147 | .{ ._, ._, .@"and", .dst0d, .sa(.dst0, .add_umax), ._, ._ }, | 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 }, | 42139 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 29151 | .src_constraints = .{ .any_int, .any }, | 42140 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29152 | .dst_constraints = .{.{ .exact_int = 64 }}, | | |
| 29153 | .patterns = &.{ | 42141 | .patterns = &.{ |
| 29154 | .{ .src = .{ .to_mem, .none } }, | 42142 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29155 | }, | 42143 | }, |
| 29156 | .dst_temps = .{.{ .rc = .general_purpose }}, | 42144 | .extra_temps = .{ |
| 29157 | .each = .{ .once = &.{ | 42145 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29158 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, | 42146 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29159 | } }, | 42147 | .unused, |
| 29160 | }, .{ | 42148 | .unused, |
| 29161 | .required_features = .{ .@"64bit", null, null, null }, | 42149 | .unused, |
| 29162 | .src_constraints = .{ .{ .signed_int = .gpr }, .any }, | 42150 | .unused, |
| 29163 | .dst_constraints = .{.{ .signed_int = .qword }}, | 42151 | .unused, |
| 29164 | .patterns = &.{ | 42152 | .unused, |
| 29165 | .{ .src = .{ .to_mut_gpr, .none } }, | 42153 | .unused, |
| 29166 | }, | 42154 | }, |
| 29167 | .dst_temps = .{.{ .ref = .src0 }}, | 42155 | .dst_temps = .{.mem}, |
| 29168 | .clobbers = .{ .eflags = true }, | 42156 | .clobbers = .{ .eflags = true }, |
| 29169 | .each = .{ .once = &.{ | 42157 | .each = .{ .once = &.{ |
| 29170 | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, | 42158 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29171 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_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 }, | 42166 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29175 | .src_constraints = .{ .any_signed_int, .any }, | 42167 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29176 | .dst_constraints = .{.{ .signed_int = .qword }}, | 42168 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29177 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 42184 | .clobbers = .{ .eflags = true }, |
| 29182 | .each = .{ .once = &.{ | 42185 | .each = .{ .once = &.{ |
| 29183 | .{ ._, ._, .mov, .dst0q, .mem(.src0q), ._, ._ }, | 42186 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29184 | .{ ._, ._l, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, | 42187 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29185 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_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 }, | 42193 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29189 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, | 42194 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29190 | .dst_constraints = .{.{ .unsigned_int = .qword }}, | | |
| 29191 | .patterns = &.{ | 42195 | .patterns = &.{ |
| 29192 | .{ .src = .{ .mem, .none } }, | 42196 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29193 | .{ .src = .{ .to_gpr, .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 | .clobbers = .{ .eflags = true }, | 42210 | .clobbers = .{ .eflags = true }, |
| 29197 | .each = .{ .once = &.{ | 42211 | .each = .{ .once = &.{ |
| 29198 | .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ }, | 42212 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29199 | .{ ._, ._, .bzhi, .dst0q, .src0q, .dst0q, ._ }, | 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 }, | 42219 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29203 | .src_constraints = .{ .any_unsigned_int, .any }, | 42220 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29204 | .dst_constraints = .{.{ .unsigned_int = .qword }}, | 42221 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29205 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 42237 | .clobbers = .{ .eflags = true }, |
| 29210 | .each = .{ .once = &.{ | 42238 | .each = .{ .once = &.{ |
| 29211 | .{ ._, ._, .mov, .dst0d, .sa(.dst0, .add_bit_size), ._, ._ }, | 42239 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29212 | .{ ._, ._, .bzhi, .dst0q, .mem(.src0q), .dst0q, ._ }, | 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 }, | 42248 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29216 | .src_constraints = .{ .{ .unsigned_int = .gpr }, .any }, | 42249 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29217 | .dst_constraints = .{.{ .unsigned_int = .qword }}, | | |
| 29218 | .patterns = &.{ | 42250 | .patterns = &.{ |
| 29219 | .{ .src = .{ .mem, .none } }, | 42251 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29220 | .{ .src = .{ .to_gpr, .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 | .clobbers = .{ .eflags = true }, | 42265 | .clobbers = .{ .eflags = true }, |
| 29224 | .each = .{ .once = &.{ | 42266 | .each = .{ .once = &.{ |
| 29225 | .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ }, | 42267 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29226 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, | 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 }, | 42276 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29230 | .src_constraints = .{ .any_unsigned_int, .any }, | 42277 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29231 | .dst_constraints = .{.{ .unsigned_int = .qword }}, | 42278 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29232 | .patterns = &.{ | 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 | .clobbers = .{ .eflags = true }, | 42294 | .clobbers = .{ .eflags = true }, |
| 29237 | .each = .{ .once = &.{ | 42295 | .each = .{ .once = &.{ |
| 29238 | .{ ._, ._, .mov, .dst0q, .ua(.dst0, .add_umax), ._, ._ }, | 42296 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29239 | .{ ._, ._, .@"and", .dst0q, .mem(.src0q), ._, ._ }, | 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 }, | 42304 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 29243 | .src_constraints = .{ .any_int, .any }, | 42305 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29244 | .dst_constraints = .{.{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }}, | | |
| 29245 | .patterns = &.{ | 42306 | .patterns = &.{ |
| 29246 | .{ .src = .{ .to_mem, .none } }, | 42307 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29247 | }, | 42308 | }, |
| 29248 | .extra_temps = .{ | 42309 | .extra_temps = .{ |
| 29249 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42310 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29250 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42311 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29251 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42312 | .unused, |
| 29252 | .unused, | 42313 | .unused, |
| 29253 | .unused, | 42314 | .unused, |
| 29254 | .unused, | 42315 | .unused, |
| ... | @@ -29257,23 +42318,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29257,23 +42318,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29257 | .unused, | 42318 | .unused, |
| 29258 | }, | 42319 | }, |
| 29259 | .dst_temps = .{.mem}, | 42320 | .dst_temps = .{.mem}, |
| | 42321 | .clobbers = .{ .eflags = true }, |
| 29260 | .each = .{ .once = &.{ | 42322 | .each = .{ .once = &.{ |
| 29261 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42323 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29262 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42324 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29263 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_size_div_8), ._, ._ }, | 42325 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29264 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 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 }, | 42331 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29268 | .src_constraints = .{ .any_signed_int, .any }, | 42332 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29269 | .dst_constraints = .{.{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, | 42333 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29270 | .patterns = &.{ | 42334 | .patterns = &.{ |
| 29271 | .{ .src = .{ .to_mem, .none } }, | 42335 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29272 | }, | 42336 | }, |
| 29273 | .extra_temps = .{ | 42337 | .extra_temps = .{ |
| 29274 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42338 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29275 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42339 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29276 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42340 | .unused, |
| 29277 | .unused, | 42341 | .unused, |
| 29278 | .unused, | 42342 | .unused, |
| 29279 | .unused, | 42343 | .unused, |
| ... | @@ -29284,26 +42348,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29284,26 +42348,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29284 | .dst_temps = .{.mem}, | 42348 | .dst_temps = .{.mem}, |
| 29285 | .clobbers = .{ .eflags = true }, | 42349 | .clobbers = .{ .eflags = true }, |
| 29286 | .each = .{ .once = &.{ | 42350 | .each = .{ .once = &.{ |
| 29287 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42351 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29288 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42352 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29289 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, | 42353 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29290 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42354 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29291 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, | 42355 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29292 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, | | |
| 29293 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | | |
| 29294 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, | | |
| 29295 | } }, | 42356 | } }, |
| 29296 | }, .{ | 42357 | }, .{ |
| 29297 | .required_features = .{ .@"64bit", null, null, null }, | 42358 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29298 | .src_constraints = .{ .any_signed_int, .any }, | 42359 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29299 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }}, | | |
| 29300 | .patterns = &.{ | 42360 | .patterns = &.{ |
| 29301 | .{ .src = .{ .to_mem, .none } }, | 42361 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29302 | }, | 42362 | }, |
| 29303 | .extra_temps = .{ | 42363 | .extra_temps = .{ |
| 29304 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42364 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29305 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42365 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29306 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42366 | .unused, |
| 29307 | .unused, | 42367 | .unused, |
| 29308 | .unused, | 42368 | .unused, |
| 29309 | .unused, | 42369 | .unused, |
| ... | @@ -29314,28 +42374,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29314,28 +42374,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29314 | .dst_temps = .{.mem}, | 42374 | .dst_temps = .{.mem}, |
| 29315 | .clobbers = .{ .eflags = true }, | 42375 | .clobbers = .{ .eflags = true }, |
| 29316 | .each = .{ .once = &.{ | 42376 | .each = .{ .once = &.{ |
| 29317 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42377 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29318 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42378 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29319 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, | 42379 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29320 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42380 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29321 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, | 42381 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._ }, | | |
| 29327 | } }, | 42382 | } }, |
| 29328 | }, .{ | 42383 | }, .{ |
| 29329 | .required_features = .{ .@"64bit", null, null, null }, | 42384 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29330 | .src_constraints = .{ .any_signed_int, .any }, | 42385 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29331 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }}, | 42386 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29332 | .patterns = &.{ | 42387 | .patterns = &.{ |
| 29333 | .{ .src = .{ .to_mem, .none } }, | 42388 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29334 | }, | 42389 | }, |
| 29335 | .extra_temps = .{ | 42390 | .extra_temps = .{ |
| 29336 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42391 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29337 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42392 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29338 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42393 | .unused, |
| 29339 | .unused, | 42394 | .unused, |
| 29340 | .unused, | 42395 | .unused, |
| 29341 | .unused, | 42396 | .unused, |
| ... | @@ -29346,26 +42401,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29346,26 +42401,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29346 | .dst_temps = .{.mem}, | 42401 | .dst_temps = .{.mem}, |
| 29347 | .clobbers = .{ .eflags = true }, | 42402 | .clobbers = .{ .eflags = true }, |
| 29348 | .each = .{ .once = &.{ | 42403 | .each = .{ .once = &.{ |
| 29349 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42404 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29350 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42405 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29351 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 42406 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29352 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42407 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29353 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, | 42408 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29354 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, | 42409 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29355 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, | 42410 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29356 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, | | |
| 29357 | } }, | 42411 | } }, |
| 29358 | }, .{ | 42412 | }, .{ |
| 29359 | .required_features = .{ .@"64bit", null, null, null }, | 42413 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29360 | .src_constraints = .{ .any_unsigned_int, .any }, | 42414 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29361 | .dst_constraints = .{.{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | | |
| 29362 | .patterns = &.{ | 42415 | .patterns = &.{ |
| 29363 | .{ .src = .{ .to_mem, .none } }, | 42416 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29364 | }, | 42417 | }, |
| 29365 | .extra_temps = .{ | 42418 | .extra_temps = .{ |
| 29366 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42419 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29367 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42420 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29368 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42421 | .unused, |
| 29369 | .unused, | 42422 | .unused, |
| 29370 | .unused, | 42423 | .unused, |
| 29371 | .unused, | 42424 | .unused, |
| ... | @@ -29374,24 +42427,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29374,24 +42427,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29374 | .unused, | 42427 | .unused, |
| 29375 | }, | 42428 | }, |
| 29376 | .dst_temps = .{.mem}, | 42429 | .dst_temps = .{.mem}, |
| | 42430 | .clobbers = .{ .eflags = true }, |
| 29377 | .each = .{ .once = &.{ | 42431 | .each = .{ .once = &.{ |
| 29378 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42432 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29379 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42433 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29380 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 42434 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29381 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42435 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29382 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, | 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 }, | 42441 | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 29386 | .src_constraints = .{ .any_unsigned_int, .any }, | 42442 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29387 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 42443 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29388 | .patterns = &.{ | 42444 | .patterns = &.{ |
| 29389 | .{ .src = .{ .to_mem, .none } }, | 42445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29390 | }, | 42446 | }, |
| 29391 | .extra_temps = .{ | 42447 | .extra_temps = .{ |
| 29392 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42448 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29393 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42449 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29394 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42450 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29395 | .unused, | 42451 | .unused, |
| 29396 | .unused, | 42452 | .unused, |
| 29397 | .unused, | 42453 | .unused, |
| ... | @@ -29402,26 +42458,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29402,26 +42458,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29402 | .dst_temps = .{.mem}, | 42458 | .dst_temps = .{.mem}, |
| 29403 | .clobbers = .{ .eflags = true }, | 42459 | .clobbers = .{ .eflags = true }, |
| 29404 | .each = .{ .once = &.{ | 42460 | .each = .{ .once = &.{ |
| 29405 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42461 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29406 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42462 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29407 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, | 42463 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 29408 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42464 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 29409 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, | 42465 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29410 | .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_size, -16), .tmp2q, ._ }, | 42466 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29411 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp2q, ._, ._ }, | | |
| 29412 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, | | |
| 29413 | } }, | 42467 | } }, |
| 29414 | }, .{ | 42468 | }, .{ |
| 29415 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 42469 | .required_features = .{ .bmi2, null, null, null }, |
| 29416 | .src_constraints = .{ .any_unsigned_int, .any }, | 42470 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29417 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, | 42471 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29418 | .patterns = &.{ | 42472 | .patterns = &.{ |
| 29419 | .{ .src = .{ .to_mem, .none } }, | 42473 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29420 | }, | 42474 | }, |
| 29421 | .extra_temps = .{ | 42475 | .extra_temps = .{ |
| 29422 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29423 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42477 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29424 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42478 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29425 | .unused, | 42479 | .unused, |
| 29426 | .unused, | 42480 | .unused, |
| 29427 | .unused, | 42481 | .unused, |
| ... | @@ -29432,25 +42486,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29432,25 +42486,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29432 | .dst_temps = .{.mem}, | 42486 | .dst_temps = .{.mem}, |
| 29433 | .clobbers = .{ .eflags = true }, | 42487 | .clobbers = .{ .eflags = true }, |
| 29434 | .each = .{ .once = &.{ | 42488 | .each = .{ .once = &.{ |
| 29435 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42489 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29436 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42490 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29437 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 42491 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 29438 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42492 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 29439 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, | 42493 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29440 | .{ ._, ._, .bzhi, .tmp2q, .memad(.src0q, .add_size, -8), .tmp2q, ._ }, | 42494 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29441 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, | | |
| 29442 | } }, | 42495 | } }, |
| 29443 | }, .{ | 42496 | }, .{ |
| 29444 | .required_features = .{ .@"64bit", null, null, null }, | 42497 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29445 | .src_constraints = .{ .any_unsigned_int, .any }, | 42498 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29446 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 42499 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29447 | .patterns = &.{ | 42500 | .patterns = &.{ |
| 29448 | .{ .src = .{ .to_mem, .none } }, | 42501 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29449 | }, | 42502 | }, |
| 29450 | .extra_temps = .{ | 42503 | .extra_temps = .{ |
| 29451 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29452 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42505 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29453 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42506 | .unused, |
| 29454 | .unused, | 42507 | .unused, |
| 29455 | .unused, | 42508 | .unused, |
| 29456 | .unused, | 42509 | .unused, |
| ... | @@ -29461,26 +42514,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29461,26 +42514,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29461 | .dst_temps = .{.mem}, | 42514 | .dst_temps = .{.mem}, |
| 29462 | .clobbers = .{ .eflags = true }, | 42515 | .clobbers = .{ .eflags = true }, |
| 29463 | .each = .{ .once = &.{ | 42516 | .each = .{ .once = &.{ |
| 29464 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42517 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29465 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42518 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29466 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, | 42519 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29467 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42520 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29468 | .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ }, | 42521 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29469 | .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, | 42522 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29470 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp0q, ._, ._ }, | | |
| 29471 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, | | |
| 29472 | } }, | 42523 | } }, |
| 29473 | }, .{ | 42524 | }, .{ |
| 29474 | .required_features = .{ .@"64bit", null, null, null }, | 42525 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 29475 | .src_constraints = .{ .any_unsigned_int, .any }, | 42526 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29476 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, | | |
| 29477 | .patterns = &.{ | 42527 | .patterns = &.{ |
| 29478 | .{ .src = .{ .to_mem, .none } }, | 42528 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29479 | }, | 42529 | }, |
| 29480 | .extra_temps = .{ | 42530 | .extra_temps = .{ |
| 29481 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 42531 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29482 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 42532 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29483 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 42533 | .unused, |
| 29484 | .unused, | 42534 | .unused, |
| 29485 | .unused, | 42535 | .unused, |
| 29486 | .unused, | 42536 | .unused, |
| ... | @@ -29491,25 +42541,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29491,25 +42541,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29491 | .dst_temps = .{.mem}, | 42541 | .dst_temps = .{.mem}, |
| 29492 | .clobbers = .{ .eflags = true }, | 42542 | .clobbers = .{ .eflags = true }, |
| 29493 | .each = .{ .once = &.{ | 42543 | .each = .{ .once = &.{ |
| 29494 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 42544 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29495 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, | 42545 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29496 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .dst0, .add_size_div_8), ._, ._ }, | 42546 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29497 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 42547 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29498 | .{ ._, ._, .mov, .tmp0q, .ua(.dst0, .add_umax), ._, ._ }, | 42548 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29499 | .{ ._, ._, .@"and", .tmp0q, .memad(.src0q, .add_size, -8), ._, ._ }, | 42549 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29500 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, | | |
| 29501 | } }, | 42550 | } }, |
| 29502 | }, .{ | 42551 | }, .{ |
| 29503 | .required_features = .{ .avx, null, null, null }, | 42552 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29504 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, | 42553 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29505 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, | 42554 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29506 | .patterns = &.{ | 42555 | .patterns = &.{ |
| 29507 | .{ .src = .{ .to_sse, .none } }, | 42556 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29508 | }, | 42557 | }, |
| 29509 | .extra_temps = .{ | 42558 | .extra_temps = .{ |
| 29510 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29511 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42560 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29512 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 42561 | .unused, |
| 29513 | .unused, | 42562 | .unused, |
| 29514 | .unused, | 42563 | .unused, |
| 29515 | .unused, | 42564 | .unused, |
| ... | @@ -29517,24 +42566,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29517,24 +42566,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29517 | .unused, | 42566 | .unused, |
| 29518 | .unused, | 42567 | .unused, |
| 29519 | }, | 42568 | }, |
| 29520 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 42569 | .dst_temps = .{.mem}, |
| | 42570 | .clobbers = .{ .eflags = true }, |
| 29521 | .each = .{ .once = &.{ | 42571 | .each = .{ .once = &.{ |
| 29522 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42572 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29523 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, | 42573 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29524 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 42574 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29525 | .{ ._, .vp_b, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ }, | 42575 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29526 | .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ }, | 42576 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29527 | } }, | 42577 | } }, |
| 29528 | }, .{ | 42578 | }, .{ |
| 29529 | .required_features = .{ .avx, null, null, null }, | 42579 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29530 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, | 42580 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29531 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, | | |
| 29532 | .patterns = &.{ | 42581 | .patterns = &.{ |
| 29533 | .{ .src = .{ .to_sse, .none } }, | 42582 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29534 | }, | 42583 | }, |
| 29535 | .extra_temps = .{ | 42584 | .extra_temps = .{ |
| 29536 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42585 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29537 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 42586 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29538 | .unused, | 42587 | .unused, |
| 29539 | .unused, | 42588 | .unused, |
| 29540 | .unused, | 42589 | .unused, |
| ... | @@ -29543,22 +42592,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29543,22 +42592,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29543 | .unused, | 42592 | .unused, |
| 29544 | .unused, | 42593 | .unused, |
| 29545 | }, | 42594 | }, |
| 29546 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 42595 | .dst_temps = .{.mem}, |
| | 42596 | .clobbers = .{ .eflags = true }, |
| 29547 | .each = .{ .once = &.{ | 42597 | .each = .{ .once = &.{ |
| 29548 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42598 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29549 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, | 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 }, | 42605 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29553 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, | 42606 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29554 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }}, | 42607 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29555 | .patterns = &.{ | 42608 | .patterns = &.{ |
| 29556 | .{ .src = .{ .to_mut_sse, .none } }, | 42609 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29557 | }, | 42610 | }, |
| 29558 | .extra_temps = .{ | 42611 | .extra_temps = .{ |
| 29559 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42612 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29560 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42613 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29561 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 42614 | .unused, |
| 29562 | .unused, | 42615 | .unused, |
| 29563 | .unused, | 42616 | .unused, |
| 29564 | .unused, | 42617 | .unused, |
| ... | @@ -29566,24 +42619,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29566,24 +42619,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29566 | .unused, | 42619 | .unused, |
| 29567 | .unused, | 42620 | .unused, |
| 29568 | }, | 42621 | }, |
| 29569 | .dst_temps = .{.{ .ref = .src0 }}, | 42622 | .dst_temps = .{.mem}, |
| | 42623 | .clobbers = .{ .eflags = true }, |
| 29570 | .each = .{ .once = &.{ | 42624 | .each = .{ .once = &.{ |
| 29571 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42625 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29572 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 42626 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29573 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 42627 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29574 | .{ ._, .p_b, .add, .dst0x, .lea(.tmp0x), ._, ._ }, | 42628 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29575 | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, | 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 }, | 42634 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29579 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, | 42635 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29580 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, | | |
| 29581 | .patterns = &.{ | 42636 | .patterns = &.{ |
| 29582 | .{ .src = .{ .to_mut_sse, .none } }, | 42637 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29583 | }, | 42638 | }, |
| 29584 | .extra_temps = .{ | 42639 | .extra_temps = .{ |
| 29585 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42640 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29586 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 42641 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29587 | .unused, | 42642 | .unused, |
| 29588 | .unused, | 42643 | .unused, |
| 29589 | .unused, | 42644 | .unused, |
| ... | @@ -29592,22 +42647,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29592,22 +42647,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29592 | .unused, | 42647 | .unused, |
| 29593 | .unused, | 42648 | .unused, |
| 29594 | }, | 42649 | }, |
| 29595 | .dst_temps = .{.{ .ref = .src0 }}, | 42650 | .dst_temps = .{.mem}, |
| | 42651 | .clobbers = .{ .eflags = true }, |
| 29596 | .each = .{ .once = &.{ | 42652 | .each = .{ .once = &.{ |
| 29597 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42653 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29598 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 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 }, | 42662 | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 29602 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, | 42663 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29603 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, | 42664 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29604 | .patterns = &.{ | 42665 | .patterns = &.{ |
| 29605 | .{ .src = .{ .to_mut_sse, .none } }, | 42666 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29606 | }, | 42667 | }, |
| 29607 | .extra_temps = .{ | 42668 | .extra_temps = .{ |
| 29608 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42669 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29609 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 42670 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29610 | .unused, | 42671 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29611 | .unused, | 42672 | .unused, |
| 29612 | .unused, | 42673 | .unused, |
| 29613 | .unused, | 42674 | .unused, |
| ... | @@ -29615,22 +42676,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29615,22 +42676,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29615 | .unused, | 42676 | .unused, |
| 29616 | .unused, | 42677 | .unused, |
| 29617 | }, | 42678 | }, |
| 29618 | .dst_temps = .{.{ .ref = .src0 }}, | 42679 | .dst_temps = .{.mem}, |
| | 42680 | .clobbers = .{ .eflags = true }, |
| 29619 | .each = .{ .once = &.{ | 42681 | .each = .{ .once = &.{ |
| 29620 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42682 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29621 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 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 }, | 42690 | .required_features = .{ .bmi2, null, null, null }, |
| 29625 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any }, | 42691 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29626 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }}, | 42692 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29627 | .patterns = &.{ | 42693 | .patterns = &.{ |
| 29628 | .{ .src = .{ .to_sse, .none } }, | 42694 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29629 | }, | 42695 | }, |
| 29630 | .extra_temps = .{ | 42696 | .extra_temps = .{ |
| 29631 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42697 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29632 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42698 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29633 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 42699 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29634 | .unused, | 42700 | .unused, |
| 29635 | .unused, | 42701 | .unused, |
| 29636 | .unused, | 42702 | .unused, |
| ... | @@ -29638,24 +42704,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29638,24 +42704,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29638 | .unused, | 42704 | .unused, |
| 29639 | .unused, | 42705 | .unused, |
| 29640 | }, | 42706 | }, |
| 29641 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 42707 | .dst_temps = .{.mem}, |
| | 42708 | .clobbers = .{ .eflags = true }, |
| 29642 | .each = .{ .once = &.{ | 42709 | .each = .{ .once = &.{ |
| 29643 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42710 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29644 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, | 42711 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29645 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 42712 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 29646 | .{ ._, .vp_b, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, | 42713 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 29647 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, | 42714 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 42715 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29648 | } }, | 42716 | } }, |
| 29649 | }, .{ | 42717 | }, .{ |
| 29650 | .required_features = .{ .avx2, null, null, null }, | 42718 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29651 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any }, | 42719 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29652 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, | 42720 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29653 | .patterns = &.{ | 42721 | .patterns = &.{ |
| 29654 | .{ .src = .{ .to_sse, .none } }, | 42722 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29655 | }, | 42723 | }, |
| 29656 | .extra_temps = .{ | 42724 | .extra_temps = .{ |
| 29657 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 42725 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29658 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 42726 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29659 | .unused, | 42727 | .unused, |
| 29660 | .unused, | 42728 | .unused, |
| 29661 | .unused, | 42729 | .unused, |
| ... | @@ -29664,25 +42732,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29664,25 +42732,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29664 | .unused, | 42732 | .unused, |
| 29665 | .unused, | 42733 | .unused, |
| 29666 | }, | 42734 | }, |
| 29667 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 42735 | .dst_temps = .{.mem}, |
| | 42736 | .clobbers = .{ .eflags = true }, |
| 29668 | .each = .{ .once = &.{ | 42737 | .each = .{ .once = &.{ |
| 29669 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 42738 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29670 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, | 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 }, | 42746 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 29674 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, .any }, | 42747 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29675 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }}, | | |
| 29676 | .patterns = &.{ | 42748 | .patterns = &.{ |
| 29677 | .{ .src = .{ .to_mem, .none } }, | 42749 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29678 | }, | 42750 | }, |
| 29679 | .extra_temps = .{ | 42751 | .extra_temps = .{ |
| 29680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42752 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29681 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, | 42753 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29682 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, | 42754 | .unused, |
| 29683 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, | 42755 | .unused, |
| 29684 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42756 | .unused, |
| 29685 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 42757 | .unused, |
| 29686 | .unused, | 42758 | .unused, |
| 29687 | .unused, | 42759 | .unused, |
| 29688 | .unused, | 42760 | .unused, |
| ... | @@ -29690,30 +42762,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29690,30 +42762,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29690 | .dst_temps = .{.mem}, | 42762 | .dst_temps = .{.mem}, |
| 29691 | .clobbers = .{ .eflags = true }, | 42763 | .clobbers = .{ .eflags = true }, |
| 29692 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42765 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29698 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, | 42766 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 29699 | .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, | 42767 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29700 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, | 42768 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 29701 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, | 42769 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29702 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 42770 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29703 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 29704 | } }, | 42771 | } }, |
| 29705 | }, .{ | 42772 | }, .{ |
| 29706 | .required_features = .{ .avx2, null, null, null }, | 42773 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29707 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, .any }, | 42774 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 29708 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }}, | 42775 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29709 | .patterns = &.{ | 42776 | .patterns = &.{ |
| 29710 | .{ .src = .{ .to_mem, .none } }, | 42777 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29711 | }, | 42778 | }, |
| 29712 | .extra_temps = .{ | 42779 | .extra_temps = .{ |
| 29713 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42780 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29714 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, | 42781 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29715 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, | 42782 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29716 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42783 | .unused, |
| 29717 | .unused, | 42784 | .unused, |
| 29718 | .unused, | 42785 | .unused, |
| 29719 | .unused, | 42786 | .unused, |
| ... | @@ -29723,28 +42790,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29723,28 +42790,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29723 | .dst_temps = .{.mem}, | 42790 | .dst_temps = .{.mem}, |
| 29724 | .clobbers = .{ .eflags = true }, | 42791 | .clobbers = .{ .eflags = true }, |
| 29725 | .each = .{ .once = &.{ | 42792 | .each = .{ .once = &.{ |
| 29726 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | | |
| 29727 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, | | |
| 29728 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42793 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29729 | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, | 42794 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29730 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, | 42795 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 29731 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 42796 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 42797 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| | 42798 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29732 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42799 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29733 | } }, | 42800 | } }, |
| 29734 | }, .{ | 42801 | }, .{ |
| 29735 | .required_features = .{ .avx, null, null, null }, | 42802 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 29736 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, | 42803 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, |
| 29737 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, | | |
| 29738 | .patterns = &.{ | 42804 | .patterns = &.{ |
| 29739 | .{ .src = .{ .to_mem, .none } }, | 42805 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29740 | }, | 42806 | }, |
| 29741 | .extra_temps = .{ | 42807 | .extra_temps = .{ |
| 29742 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42808 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29743 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 42809 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29744 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 42810 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29745 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 42811 | .unused, |
| 29746 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42812 | .unused, |
| 29747 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 42813 | .unused, |
| 29748 | .unused, | 42814 | .unused, |
| 29749 | .unused, | 42815 | .unused, |
| 29750 | .unused, | 42816 | .unused, |
| ... | @@ -29752,30 +42818,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29752,30 +42818,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29752 | .dst_temps = .{.mem}, | 42818 | .dst_temps = .{.mem}, |
| 29753 | .clobbers = .{ .eflags = true }, | 42819 | .clobbers = .{ .eflags = true }, |
| 29754 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42821 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29760 | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, | 42822 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29761 | .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, | 42823 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 29762 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, | 42824 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 29763 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, | 42825 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 29764 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 42826 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29765 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42827 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29766 | } }, | 42828 | } }, |
| 29767 | }, .{ | 42829 | }, .{ |
| 29768 | .required_features = .{ .avx, null, null, null }, | 42830 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29769 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, | 42831 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 29770 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, | 42832 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29771 | .patterns = &.{ | 42833 | .patterns = &.{ |
| 29772 | .{ .src = .{ .to_mem, .none } }, | 42834 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29773 | }, | 42835 | }, |
| 29774 | .extra_temps = .{ | 42836 | .extra_temps = .{ |
| 29775 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42837 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29776 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 42838 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29777 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 42839 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29778 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42840 | .unused, |
| 29779 | .unused, | 42841 | .unused, |
| 29780 | .unused, | 42842 | .unused, |
| 29781 | .unused, | 42843 | .unused, |
| ... | @@ -29785,28 +42847,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29785,28 +42847,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29785 | .dst_temps = .{.mem}, | 42847 | .dst_temps = .{.mem}, |
| 29786 | .clobbers = .{ .eflags = true }, | 42848 | .clobbers = .{ .eflags = true }, |
| 29787 | .each = .{ .once = &.{ | 42849 | .each = .{ .once = &.{ |
| 29788 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | | |
| 29789 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, | | |
| 29790 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42850 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29791 | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, | 42851 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29792 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, | 42852 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 29793 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42858 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29795 | } }, | 42859 | } }, |
| 29796 | }, .{ | 42860 | }, .{ |
| 29797 | .required_features = .{ .sse2, null, null, null }, | 42861 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 29798 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, .any }, | 42862 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 29799 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }}, | | |
| 29800 | .patterns = &.{ | 42863 | .patterns = &.{ |
| 29801 | .{ .src = .{ .to_mem, .none } }, | 42864 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29802 | }, | 42865 | }, |
| 29803 | .extra_temps = .{ | 42866 | .extra_temps = .{ |
| 29804 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42867 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29805 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 42868 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29806 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 42869 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 29807 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, | 42870 | .unused, |
| 29808 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42871 | .unused, |
| 29809 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 42872 | .unused, |
| 29810 | .unused, | 42873 | .unused, |
| 29811 | .unused, | 42874 | .unused, |
| 29812 | .unused, | 42875 | .unused, |
| ... | @@ -29814,31 +42877,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29814,31 +42877,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29814 | .dst_temps = .{.mem}, | 42877 | .dst_temps = .{.mem}, |
| 29815 | .clobbers = .{ .eflags = true }, | 42878 | .clobbers = .{ .eflags = true }, |
| 29816 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42880 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29822 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ }, | 42881 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29823 | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 42882 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 29824 | .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ }, | 42883 | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29825 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, | 42884 | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| 29826 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, | 42885 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| 29827 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 42886 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 29828 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42887 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 42888 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29829 | } }, | 42889 | } }, |
| 29830 | }, .{ | 42890 | }, .{ |
| 29831 | .required_features = .{ .sse2, null, null, null }, | 42891 | .required_features = .{ .bmi2, .slow_incdec, null, null }, |
| 29832 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, | 42892 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 29833 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, | 42893 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29834 | .patterns = &.{ | 42894 | .patterns = &.{ |
| 29835 | .{ .src = .{ .to_mem, .none } }, | 42895 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29836 | }, | 42896 | }, |
| 29837 | .extra_temps = .{ | 42897 | .extra_temps = .{ |
| 29838 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42898 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29839 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 42899 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29840 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 42900 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29841 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42901 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29842 | .unused, | 42902 | .unused, |
| 29843 | .unused, | 42903 | .unused, |
| 29844 | .unused, | 42904 | .unused, |
| ... | @@ -29848,27 +42908,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29848,27 +42908,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29848 | .dst_temps = .{.mem}, | 42908 | .dst_temps = .{.mem}, |
| 29849 | .clobbers = .{ .eflags = true }, | 42909 | .clobbers = .{ .eflags = true }, |
| 29850 | .each = .{ .once = &.{ | 42910 | .each = .{ .once = &.{ |
| 29851 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | | |
| 29852 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, | | |
| 29853 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42911 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29854 | .{ .@"0:", ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, | 42912 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29855 | .{ ._, .p_, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 42913 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29856 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, | 42914 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 29857 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 42915 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| | 42916 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| | 42917 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29858 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42918 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29859 | } }, | 42919 | } }, |
| 29860 | }, .{ | 42920 | }, .{ |
| 29861 | .required_features = .{ .sse, null, null, null }, | 42921 | .required_features = .{ .bmi2, null, null, null }, |
| 29862 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, .any }, | 42922 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 29863 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }}, | 42923 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29864 | .patterns = &.{ | 42924 | .patterns = &.{ |
| 29865 | .{ .src = .{ .to_mem, .none } }, | 42925 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29866 | }, | 42926 | }, |
| 29867 | .extra_temps = .{ | 42927 | .extra_temps = .{ |
| 29868 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42928 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29869 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 42929 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29870 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 42930 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29871 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 42931 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29872 | .unused, | 42932 | .unused, |
| 29873 | .unused, | 42933 | .unused, |
| 29874 | .unused, | 42934 | .unused, |
| ... | @@ -29878,26 +42938,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29878,26 +42938,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29878 | .dst_temps = .{.mem}, | 42938 | .dst_temps = .{.mem}, |
| 29879 | .clobbers = .{ .eflags = true }, | 42939 | .clobbers = .{ .eflags = true }, |
| 29880 | .each = .{ .once = &.{ | 42940 | .each = .{ .once = &.{ |
| 29881 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | | |
| 29882 | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, | | |
| 29883 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42941 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29884 | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, | 42942 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29885 | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 42943 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 29886 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, | 42944 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, |
| 29887 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 42945 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 29888 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42946 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| | 42947 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 42948 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29889 | } }, | 42949 | } }, |
| 29890 | }, .{ | 42950 | }, .{ |
| 29891 | .required_features = .{ .slow_incdec, null, null, null }, | 42951 | .required_features = .{ .slow_incdec, null, null, null }, |
| 29892 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 42952 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 29893 | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, | 42953 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29894 | .patterns = &.{ | 42954 | .patterns = &.{ |
| 29895 | .{ .src = .{ .to_mem, .none } }, | 42955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29896 | }, | 42956 | }, |
| 29897 | .extra_temps = .{ | 42957 | .extra_temps = .{ |
| 29898 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29899 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 42959 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29900 | .unused, | 42960 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29901 | .unused, | 42961 | .unused, |
| 29902 | .unused, | 42962 | .unused, |
| 29903 | .unused, | 42963 | .unused, |
| ... | @@ -29909,23 +42969,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29909,23 +42969,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29909 | .clobbers = .{ .eflags = true }, | 42969 | .clobbers = .{ .eflags = true }, |
| 29910 | .each = .{ .once = &.{ | 42970 | .each = .{ .once = &.{ |
| 29911 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 42971 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29912 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 42972 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29913 | .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ }, | 42973 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 29914 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, | 42974 | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29915 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 42975 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 42976 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 29916 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 42977 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 29917 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 42978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 29918 | } }, | 42979 | } }, |
| 29919 | }, .{ | 42980 | }, .{ |
| 29920 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 42981 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 29921 | .dst_constraints = .{.{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 1 } }}, | 42982 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 29922 | .patterns = &.{ | 42983 | .patterns = &.{ |
| 29923 | .{ .src = .{ .to_mem, .none } }, | 42984 | .{ .src = .{ .to_mem, .none, .none } }, |
| 29924 | }, | 42985 | }, |
| 29925 | .extra_temps = .{ | 42986 | .extra_temps = .{ |
| 29926 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 42987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 29927 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 42988 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 29928 | .unused, | 42989 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 29929 | .unused, | 42990 | .unused, |
| 29930 | .unused, | 42991 | .unused, |
| 29931 | .unused, | 42992 | .unused, |
| ... | @@ -29937,23 +42998,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29937,23 +42998,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29937 | .clobbers = .{ .eflags = true }, | 42998 | .clobbers = .{ .eflags = true }, |
| 29938 | .each = .{ .once = &.{ | 42999 | .each = .{ .once = &.{ |
| 29939 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43000 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 29940 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 43001 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 29941 | .{ ._, ._, .@"and", .tmp1b, .si(1), ._, ._ }, | 43002 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 29942 | .{ ._, ._, .neg, .tmp1b, ._, ._, ._ }, | 43003 | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, |
| 29943 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43004 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 43005 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 29944 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43006 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 29945 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43007 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 29946 | } }, | 43008 | } }, |
| 29947 | }, .{ | 43009 | }, .{ |
| 29948 | .required_features = .{ .slow_incdec, null, null, null }, | 43010 | .required_features = .{ .avx, null, null, null }, |
| 29949 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 43011 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 29950 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43025 | .patterns = &.{ |
| 29952 | .{ .src = .{ .to_mem, .none } }, | 43026 | .{ .src = .{ .to_sse, .none, .none } }, |
| 29953 | }, | 43027 | }, |
| 29954 | .extra_temps = .{ | 43028 | .extra_temps = .{ |
| 29955 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43029 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29956 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43030 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 29957 | .unused, | 43031 | .unused, |
| 29958 | .unused, | 43032 | .unused, |
| 29959 | .unused, | 43033 | .unused, |
| ... | @@ -29962,26 +43036,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29962,26 +43036,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29962 | .unused, | 43036 | .unused, |
| 29963 | .unused, | 43037 | .unused, |
| 29964 | }, | 43038 | }, |
| 29965 | .dst_temps = .{.mem}, | 43039 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 29966 | .clobbers = .{ .eflags = true }, | | |
| 29967 | .each = .{ .once = &.{ | 43040 | .each = .{ .once = &.{ |
| 29968 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43041 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29969 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 43042 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| 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", ._, ._, ._ }, | | |
| 29975 | } }, | 43043 | } }, |
| 29976 | }, .{ | 43044 | }, .{ |
| 29977 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any }, | 43045 | .required_features = .{ .sse2, null, null, null }, |
| 29978 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43060 | .patterns = &.{ |
| 29980 | .{ .src = .{ .to_mem, .none } }, | 43061 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 29981 | }, | 43062 | }, |
| 29982 | .extra_temps = .{ | 43063 | .extra_temps = .{ |
| 29983 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43064 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 29984 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43065 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 29985 | .unused, | 43066 | .unused, |
| 29986 | .unused, | 43067 | .unused, |
| 29987 | .unused, | 43068 | .unused, |
| ... | @@ -29990,27 +43071,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -29990,27 +43071,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 29990 | .unused, | 43071 | .unused, |
| 29991 | .unused, | 43072 | .unused, |
| 29992 | }, | 43073 | }, |
| 29993 | .dst_temps = .{.mem}, | 43074 | .dst_temps = .{.{ .ref = .src0 }}, |
| 29994 | .clobbers = .{ .eflags = true }, | | |
| 29995 | .each = .{ .once = &.{ | 43075 | .each = .{ .once = &.{ |
| 29996 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43076 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 29997 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 43077 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 30003 | } }, | 43078 | } }, |
| 30004 | }, .{ | 43079 | }, .{ |
| 30005 | .required_features = .{ .slow_incdec, null, null, null }, | 43080 | .required_features = .{ .sse, null, null, null }, |
| 30006 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any }, | 43081 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 30007 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43082 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, |
| 30008 | .patterns = &.{ | 43083 | .patterns = &.{ |
| 30009 | .{ .src = .{ .to_mem, .none } }, | 43084 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30010 | }, | 43085 | }, |
| 30011 | .extra_temps = .{ | 43086 | .extra_temps = .{ |
| 30012 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43087 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30013 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43088 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 30014 | .unused, | 43089 | .unused, |
| 30015 | .unused, | 43090 | .unused, |
| 30016 | .unused, | 43091 | .unused, |
| ... | @@ -30019,25 +43094,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30019,25 +43094,33 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30019 | .unused, | 43094 | .unused, |
| 30020 | .unused, | 43095 | .unused, |
| 30021 | }, | 43096 | }, |
| 30022 | .dst_temps = .{.mem}, | 43097 | .dst_temps = .{.{ .ref = .src0 }}, |
| 30023 | .clobbers = .{ .eflags = true }, | | |
| 30024 | .each = .{ .once = &.{ | 43098 | .each = .{ .once = &.{ |
| 30025 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43099 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30026 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 43100 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 30031 | } }, | 43101 | } }, |
| 30032 | }, .{ | 43102 | }, .{ |
| 30033 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any }, | 43103 | .required_features = .{ .avx2, null, null, null }, |
| 30034 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43118 | .patterns = &.{ |
| 30036 | .{ .src = .{ .to_mem, .none } }, | 43119 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30037 | }, | 43120 | }, |
| 30038 | .extra_temps = .{ | 43121 | .extra_temps = .{ |
| 30039 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43122 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 30040 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43123 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, |
| 30041 | .unused, | 43124 | .unused, |
| 30042 | .unused, | 43125 | .unused, |
| 30043 | .unused, | 43126 | .unused, |
| ... | @@ -30046,26 +43129,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30046,26 +43129,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30046 | .unused, | 43129 | .unused, |
| 30047 | .unused, | 43130 | .unused, |
| 30048 | }, | 43131 | }, |
| 30049 | .dst_temps = .{.mem}, | 43132 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30050 | .clobbers = .{ .eflags = true }, | | |
| 30051 | .each = .{ .once = &.{ | 43133 | .each = .{ .once = &.{ |
| 30052 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43134 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 30053 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 43135 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| 30054 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | | |
| 30055 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | | |
| 30056 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | | |
| 30057 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 30058 | } }, | 43136 | } }, |
| 30059 | }, .{ | 43137 | }, .{ |
| 30060 | .required_features = .{ .slow_incdec, null, null, null }, | 43138 | .required_features = .{ .avx2, null, null, null }, |
| 30061 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 43139 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| 30062 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | 43140 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, |
| 30063 | .patterns = &.{ | 43141 | .patterns = &.{ |
| 30064 | .{ .src = .{ .to_mem, .none } }, | 43142 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30065 | }, | 43143 | }, |
| 30066 | .extra_temps = .{ | 43144 | .extra_temps = .{ |
| 30067 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43145 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30068 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43146 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| 30069 | .unused, | 43147 | .unused, |
| 30070 | .unused, | 43148 | .unused, |
| 30071 | .unused, | 43149 | .unused, |
| ... | @@ -30078,22 +43156,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30078,22 +43156,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30078 | .clobbers = .{ .eflags = true }, | 43156 | .clobbers = .{ .eflags = true }, |
| 30079 | .each = .{ .once = &.{ | 43157 | .each = .{ .once = &.{ |
| 30080 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43158 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30081 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 43159 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30082 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43160 | .{ ._, .vp_w, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 30083 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43164 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30085 | } }, | 43165 | } }, |
| 30086 | }, .{ | 43166 | }, .{ |
| 30087 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 43167 | .required_features = .{ .avx2, null, null, null }, |
| 30088 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | 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 | .patterns = &.{ | 43170 | .patterns = &.{ |
| 30090 | .{ .src = .{ .to_mem, .none } }, | 43171 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30091 | }, | 43172 | }, |
| 30092 | .extra_temps = .{ | 43173 | .extra_temps = .{ |
| 30093 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43174 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30094 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43175 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 30095 | .unused, | 43176 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| 30096 | .unused, | 43177 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 30097 | .unused, | 43178 | .unused, |
| 30098 | .unused, | 43179 | .unused, |
| 30099 | .unused, | 43180 | .unused, |
| ... | @@ -30103,22 +43184,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30103,22 +43184,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30103 | .dst_temps = .{.mem}, | 43184 | .dst_temps = .{.mem}, |
| 30104 | .clobbers = .{ .eflags = true }, | 43185 | .clobbers = .{ .eflags = true }, |
| 30105 | .each = .{ .once = &.{ | 43186 | .each = .{ .once = &.{ |
| | 43187 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| | 43188 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, |
| 30106 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43189 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30107 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 43190 | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 30108 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43191 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| 30109 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43192 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 30110 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43193 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30111 | } }, | 43194 | } }, |
| 30112 | }, .{ | 43195 | }, .{ |
| 30113 | .required_features = .{ .slow_incdec, null, null, null }, | 43196 | .required_features = .{ .avx, null, null, null }, |
| 30114 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 43197 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 30115 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 43198 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 30116 | .patterns = &.{ | 43199 | .patterns = &.{ |
| 30117 | .{ .src = .{ .to_mem, .none } }, | 43200 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30118 | }, | 43201 | }, |
| 30119 | .extra_temps = .{ | 43202 | .extra_temps = .{ |
| 30120 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30121 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43204 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 30122 | .unused, | 43205 | .unused, |
| 30123 | .unused, | 43206 | .unused, |
| 30124 | .unused, | 43207 | .unused, |
| ... | @@ -30131,24 +43214,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30131,24 +43214,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30131 | .clobbers = .{ .eflags = true }, | 43214 | .clobbers = .{ .eflags = true }, |
| 30132 | .each = .{ .once = &.{ | 43215 | .each = .{ .once = &.{ |
| 30133 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43216 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30134 | .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 43217 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30135 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43218 | .{ ._, .vp_w, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 30136 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43219 | .{ ._, .vp_w, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 30137 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43220 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 30138 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43221 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30139 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43222 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30140 | } }, | 43223 | } }, |
| 30141 | }, .{ | 43224 | }, .{ |
| 30142 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 43225 | .required_features = .{ .avx, null, null, null }, |
| 30143 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43228 | .patterns = &.{ |
| 30145 | .{ .src = .{ .to_mem, .none } }, | 43229 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30146 | }, | 43230 | }, |
| 30147 | .extra_temps = .{ | 43231 | .extra_temps = .{ |
| 30148 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30149 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43233 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 30150 | .unused, | 43234 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 30151 | .unused, | 43235 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 30152 | .unused, | 43236 | .unused, |
| 30153 | .unused, | 43237 | .unused, |
| 30154 | .unused, | 43238 | .unused, |
| ... | @@ -30158,24 +43242,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30158,24 +43242,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30158 | .dst_temps = .{.mem}, | 43242 | .dst_temps = .{.mem}, |
| 30159 | .clobbers = .{ .eflags = true }, | 43243 | .clobbers = .{ .eflags = true }, |
| 30160 | .each = .{ .once = &.{ | 43244 | .each = .{ .once = &.{ |
| | 43245 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| | 43246 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 30161 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43247 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30162 | .{ .@"0:", ._, .movsx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 43248 | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 30163 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43249 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 30164 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43250 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30165 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43251 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30166 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | | |
| 30167 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 30168 | } }, | 43252 | } }, |
| 30169 | }, .{ | 43253 | }, .{ |
| 30170 | .required_features = .{ .slow_incdec, null, null, null }, | 43254 | .required_features = .{ .sse2, null, null, null }, |
| 30171 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, | 43255 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 30172 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43256 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, |
| 30173 | .patterns = &.{ | 43257 | .patterns = &.{ |
| 30174 | .{ .src = .{ .to_mem, .none } }, | 43258 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30175 | }, | 43259 | }, |
| 30176 | .extra_temps = .{ | 43260 | .extra_temps = .{ |
| 30177 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30178 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43262 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 30179 | .unused, | 43263 | .unused, |
| 30180 | .unused, | 43264 | .unused, |
| 30181 | .unused, | 43265 | .unused, |
| ... | @@ -30188,24 +43272,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30188,24 +43272,56 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30188 | .clobbers = .{ .eflags = true }, | 43272 | .clobbers = .{ .eflags = true }, |
| 30189 | .each = .{ .once = &.{ | 43273 | .each = .{ .once = &.{ |
| 30190 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43274 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30191 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 43275 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30192 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | 43276 | .{ ._, .p_w, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 30193 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43277 | .{ ._, .p_w, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 30194 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43278 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 43279 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30195 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43280 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30196 | } }, | 43281 | } }, |
| 30197 | }, .{ | 43282 | }, .{ |
| 30198 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, | 43283 | .required_features = .{ .sse2, null, null, null }, |
| 30199 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43286 | .patterns = &.{ |
| 30201 | .{ .src = .{ .to_mem, .none } }, | 43287 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30202 | }, | 43288 | }, |
| 30203 | .extra_temps = .{ | 43289 | .extra_temps = .{ |
| 30204 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 43296 | .unused, |
| 30207 | .unused, | 43297 | .unused, |
| 30208 | .unused, | 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 | .unused, | 43325 | .unused, |
| 30210 | .unused, | 43326 | .unused, |
| 30211 | .unused, | 43327 | .unused, |
| ... | @@ -30214,23 +43330,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30214,23 +43330,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30214 | .dst_temps = .{.mem}, | 43330 | .dst_temps = .{.mem}, |
| 30215 | .clobbers = .{ .eflags = true }, | 43331 | .clobbers = .{ .eflags = true }, |
| 30216 | .each = .{ .once = &.{ | 43332 | .each = .{ .once = &.{ |
| | 43333 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| | 43334 | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, |
| 30217 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43335 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30218 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0b, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 43336 | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 30219 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | 43337 | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30220 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43338 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| 30221 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43339 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 30222 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43340 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30223 | } }, | 43341 | } }, |
| 30224 | }, .{ | 43342 | }, .{ |
| 30225 | .required_features = .{ .slow_incdec, null, null, null }, | 43343 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 30226 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 43344 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30227 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | | |
| 30228 | .patterns = &.{ | 43345 | .patterns = &.{ |
| 30229 | .{ .src = .{ .to_mem, .none } }, | 43346 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30230 | }, | 43347 | }, |
| 30231 | .extra_temps = .{ | 43348 | .extra_temps = .{ |
| 30232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43349 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30233 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43350 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30234 | .unused, | 43351 | .unused, |
| 30235 | .unused, | 43352 | .unused, |
| 30236 | .unused, | 43353 | .unused, |
| ... | @@ -30243,20 +43360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30243,20 +43360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30243 | .clobbers = .{ .eflags = true }, | 43360 | .clobbers = .{ .eflags = true }, |
| 30244 | .each = .{ .once = &.{ | 43361 | .each = .{ .once = &.{ |
| 30245 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43362 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30246 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 43363 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30247 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43364 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30248 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43365 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30249 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43366 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30250 | } }, | 43367 | } }, |
| 30251 | }, .{ | 43368 | }, .{ |
| 30252 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 43369 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 30253 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | 43370 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30254 | .patterns = &.{ | 43371 | .patterns = &.{ |
| 30255 | .{ .src = .{ .to_mem, .none } }, | 43372 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30256 | }, | 43373 | }, |
| 30257 | .extra_temps = .{ | 43374 | .extra_temps = .{ |
| 30258 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43375 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30259 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43376 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30260 | .unused, | 43377 | .unused, |
| 30261 | .unused, | 43378 | .unused, |
| 30262 | .unused, | 43379 | .unused, |
| ... | @@ -30269,21 +43386,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30269,21 +43386,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30269 | .clobbers = .{ .eflags = true }, | 43386 | .clobbers = .{ .eflags = true }, |
| 30270 | .each = .{ .once = &.{ | 43387 | .each = .{ .once = &.{ |
| 30271 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43388 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30272 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 43389 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30273 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43390 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30274 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43391 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30275 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 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 }, | 43397 | .required_features = .{ .fast_imm16, null, null, null }, |
| 30279 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 43398 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 30280 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 43399 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30281 | .patterns = &.{ | 43400 | .patterns = &.{ |
| 30282 | .{ .src = .{ .to_mem, .none } }, | 43401 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30283 | }, | 43402 | }, |
| 30284 | .extra_temps = .{ | 43403 | .extra_temps = .{ |
| 30285 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43404 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30286 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43405 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30287 | .unused, | 43406 | .unused, |
| 30288 | .unused, | 43407 | .unused, |
| 30289 | .unused, | 43408 | .unused, |
| ... | @@ -30296,22 +43415,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30296,22 +43415,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30296 | .clobbers = .{ .eflags = true }, | 43415 | .clobbers = .{ .eflags = true }, |
| 30297 | .each = .{ .once = &.{ | 43416 | .each = .{ .once = &.{ |
| 30298 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43417 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30299 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 43418 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30300 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43419 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 30301 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43420 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30302 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43421 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30303 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 30304 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43422 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30305 | } }, | 43423 | } }, |
| 30306 | }, .{ | 43424 | }, .{ |
| 30307 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 43425 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 30308 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 43426 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30309 | .patterns = &.{ | 43427 | .patterns = &.{ |
| 30310 | .{ .src = .{ .to_mem, .none } }, | 43428 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30311 | }, | 43429 | }, |
| 30312 | .extra_temps = .{ | 43430 | .extra_temps = .{ |
| 30313 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43431 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30314 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43432 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30315 | .unused, | 43433 | .unused, |
| 30316 | .unused, | 43434 | .unused, |
| 30317 | .unused, | 43435 | .unused, |
| ... | @@ -30324,24 +43442,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30324,24 +43442,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30324 | .clobbers = .{ .eflags = true }, | 43442 | .clobbers = .{ .eflags = true }, |
| 30325 | .each = .{ .once = &.{ | 43443 | .each = .{ .once = &.{ |
| 30326 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43444 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30327 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 43445 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 30328 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43446 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 30329 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43447 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30330 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43448 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30331 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43449 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30332 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 30333 | } }, | 43450 | } }, |
| 30334 | }, .{ | 43451 | }, .{ |
| 30335 | .required_features = .{ .bmi2, .slow_incdec, null, null }, | 43452 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 30336 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 43453 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30337 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30338 | .patterns = &.{ | 43454 | .patterns = &.{ |
| 30339 | .{ .src = .{ .to_mem, .none } }, | 43455 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30340 | }, | 43456 | }, |
| 30341 | .extra_temps = .{ | 43457 | .extra_temps = .{ |
| 30342 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43458 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30343 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43459 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30344 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43460 | .unused, |
| 30345 | .unused, | 43461 | .unused, |
| 30346 | .unused, | 43462 | .unused, |
| 30347 | .unused, | 43463 | .unused, |
| ... | @@ -30353,23 +43469,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30353,23 +43469,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30353 | .clobbers = .{ .eflags = true }, | 43469 | .clobbers = .{ .eflags = true }, |
| 30354 | .each = .{ .once = &.{ | 43470 | .each = .{ .once = &.{ |
| 30355 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43471 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30356 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 43472 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30357 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 43473 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30358 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43474 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30359 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 30360 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43475 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30361 | } }, | 43476 | } }, |
| 30362 | }, .{ | 43477 | }, .{ |
| 30363 | .required_features = .{ .bmi2, null, null, null }, | 43478 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 30364 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 43479 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30365 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30366 | .patterns = &.{ | 43480 | .patterns = &.{ |
| 30367 | .{ .src = .{ .to_mem, .none } }, | 43481 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30368 | }, | 43482 | }, |
| 30369 | .extra_temps = .{ | 43483 | .extra_temps = .{ |
| 30370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43484 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30371 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43485 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30372 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43486 | .unused, |
| 30373 | .unused, | 43487 | .unused, |
| 30374 | .unused, | 43488 | .unused, |
| 30375 | .unused, | 43489 | .unused, |
| ... | @@ -30381,23 +43495,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30381,23 +43495,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30381 | .clobbers = .{ .eflags = true }, | 43495 | .clobbers = .{ .eflags = true }, |
| 30382 | .each = .{ .once = &.{ | 43496 | .each = .{ .once = &.{ |
| 30383 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43497 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30384 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 43498 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30385 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 43499 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30386 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43500 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30387 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43501 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30388 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43502 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 43503 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30389 | } }, | 43504 | } }, |
| 30390 | }, .{ | 43505 | }, .{ |
| 30391 | .required_features = .{ .slow_incdec, null, null, null }, | 43506 | .required_features = .{ .bmi2, null, null, null }, |
| 30392 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 43507 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 30393 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43508 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30394 | .patterns = &.{ | 43509 | .patterns = &.{ |
| 30395 | .{ .src = .{ .to_mem, .none } }, | 43510 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30396 | }, | 43511 | }, |
| 30397 | .extra_temps = .{ | 43512 | .extra_temps = .{ |
| 30398 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43513 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30399 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43514 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30400 | .unused, | 43515 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30401 | .unused, | 43516 | .unused, |
| 30402 | .unused, | 43517 | .unused, |
| 30403 | .unused, | 43518 | .unused, |
| ... | @@ -30409,21 +43524,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30409,21 +43524,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30409 | .clobbers = .{ .eflags = true }, | 43524 | .clobbers = .{ .eflags = true }, |
| 30410 | .each = .{ .once = &.{ | 43525 | .each = .{ .once = &.{ |
| 30411 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43526 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30412 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 43527 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30413 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | 43528 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30414 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43529 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30415 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43530 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30416 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30417 | } }, | 43532 | } }, |
| 30418 | }, .{ | 43533 | }, .{ |
| 30419 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 43534 | .required_features = .{ .fast_imm16, null, null, null }, |
| 30420 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43537 | .patterns = &.{ |
| 30422 | .{ .src = .{ .to_mem, .none } }, | 43538 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30423 | }, | 43539 | }, |
| 30424 | .extra_temps = .{ | 43540 | .extra_temps = .{ |
| 30425 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43541 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30426 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43542 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30427 | .unused, | 43543 | .unused, |
| 30428 | .unused, | 43544 | .unused, |
| 30429 | .unused, | 43545 | .unused, |
| ... | @@ -30436,22 +43552,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30436,22 +43552,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30436 | .clobbers = .{ .eflags = true }, | 43552 | .clobbers = .{ .eflags = true }, |
| 30437 | .each = .{ .once = &.{ | 43553 | .each = .{ .once = &.{ |
| 30438 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43554 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30439 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 43555 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30440 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | 43556 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 30441 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43557 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30442 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43558 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30443 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43559 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30444 | } }, | 43560 | } }, |
| 30445 | }, .{ | 43561 | }, .{ |
| 30446 | .required_features = .{ .slow_incdec, null, null, null }, | 43562 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 30447 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 43563 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30448 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | | |
| 30449 | .patterns = &.{ | 43564 | .patterns = &.{ |
| 30450 | .{ .src = .{ .to_mem, .none } }, | 43565 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30451 | }, | 43566 | }, |
| 30452 | .extra_temps = .{ | 43567 | .extra_temps = .{ |
| 30453 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43568 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30454 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43569 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30455 | .unused, | 43570 | .unused, |
| 30456 | .unused, | 43571 | .unused, |
| 30457 | .unused, | 43572 | .unused, |
| ... | @@ -30464,20 +43579,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30464,20 +43579,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30464 | .clobbers = .{ .eflags = true }, | 43579 | .clobbers = .{ .eflags = true }, |
| 30465 | .each = .{ .once = &.{ | 43580 | .each = .{ .once = &.{ |
| 30466 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43581 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30467 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 43582 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30468 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43583 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 30469 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43584 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 43585 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30470 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43586 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30471 | } }, | 43587 | } }, |
| 30472 | }, .{ | 43588 | }, .{ |
| 30473 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 43589 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 30474 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | 43590 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30475 | .patterns = &.{ | 43591 | .patterns = &.{ |
| 30476 | .{ .src = .{ .to_mem, .none } }, | 43592 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30477 | }, | 43593 | }, |
| 30478 | .extra_temps = .{ | 43594 | .extra_temps = .{ |
| 30479 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43595 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30480 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43596 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30481 | .unused, | 43597 | .unused, |
| 30482 | .unused, | 43598 | .unused, |
| 30483 | .unused, | 43599 | .unused, |
| ... | @@ -30490,21 +43606,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30490,21 +43606,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30490 | .clobbers = .{ .eflags = true }, | 43606 | .clobbers = .{ .eflags = true }, |
| 30491 | .each = .{ .once = &.{ | 43607 | .each = .{ .once = &.{ |
| 30492 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43608 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30493 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 43609 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30494 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43610 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30495 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43611 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30496 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43612 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30497 | } }, | 43613 | } }, |
| 30498 | }, .{ | 43614 | }, .{ |
| 30499 | .required_features = .{ .slow_incdec, null, null, null }, | 43615 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 30500 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, | 43616 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30501 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30502 | .patterns = &.{ | 43617 | .patterns = &.{ |
| 30503 | .{ .src = .{ .to_mem, .none } }, | 43618 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30504 | }, | 43619 | }, |
| 30505 | .extra_temps = .{ | 43620 | .extra_temps = .{ |
| 30506 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43621 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30507 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43622 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30508 | .unused, | 43623 | .unused, |
| 30509 | .unused, | 43624 | .unused, |
| 30510 | .unused, | 43625 | .unused, |
| ... | @@ -30517,23 +43632,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30517,23 +43632,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30517 | .clobbers = .{ .eflags = true }, | 43632 | .clobbers = .{ .eflags = true }, |
| 30518 | .each = .{ .once = &.{ | 43633 | .each = .{ .once = &.{ |
| 30519 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43634 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30520 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 43635 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30521 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43636 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30522 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43637 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30523 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43638 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30524 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43639 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30525 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43640 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30526 | } }, | 43641 | } }, |
| 30527 | }, .{ | 43642 | }, .{ |
| 30528 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, | 43643 | .required_features = .{ .bmi2, null, null, null }, |
| 30529 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 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 | .patterns = &.{ | 43646 | .patterns = &.{ |
| 30531 | .{ .src = .{ .to_mem, .none } }, | 43647 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30532 | }, | 43648 | }, |
| 30533 | .extra_temps = .{ | 43649 | .extra_temps = .{ |
| 30534 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43650 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30535 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43651 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30536 | .unused, | 43652 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30537 | .unused, | 43653 | .unused, |
| 30538 | .unused, | 43654 | .unused, |
| 30539 | .unused, | 43655 | .unused, |
| ... | @@ -30545,24 +43661,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30545,24 +43661,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30545 | .clobbers = .{ .eflags = true }, | 43661 | .clobbers = .{ .eflags = true }, |
| 30546 | .each = .{ .once = &.{ | 43662 | .each = .{ .once = &.{ |
| 30547 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43663 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30548 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 43664 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30549 | .{ ._, ._l, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43665 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30550 | .{ ._, ._r, .sa, .tmp1b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43666 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30551 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43667 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30552 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43668 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30553 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 30554 | } }, | 43669 | } }, |
| 30555 | }, .{ | 43670 | }, .{ |
| 30556 | .required_features = .{ .bmi2, .slow_incdec, null, null }, | 43671 | .required_features = .{ .fast_imm16, null, null, null }, |
| 30557 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 43672 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 30558 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43673 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30559 | .patterns = &.{ | 43674 | .patterns = &.{ |
| 30560 | .{ .src = .{ .to_mem, .none } }, | 43675 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30561 | }, | 43676 | }, |
| 30562 | .extra_temps = .{ | 43677 | .extra_temps = .{ |
| 30563 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43678 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30564 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43679 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30565 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43680 | .unused, |
| 30566 | .unused, | 43681 | .unused, |
| 30567 | .unused, | 43682 | .unused, |
| 30568 | .unused, | 43683 | .unused, |
| ... | @@ -30574,23 +43689,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30574,23 +43689,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30574 | .clobbers = .{ .eflags = true }, | 43689 | .clobbers = .{ .eflags = true }, |
| 30575 | .each = .{ .once = &.{ | 43690 | .each = .{ .once = &.{ |
| 30576 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43691 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30577 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 43692 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30578 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 43693 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 30579 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43694 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30580 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43695 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30581 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43696 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30582 | } }, | 43697 | } }, |
| 30583 | }, .{ | 43698 | }, .{ |
| 30584 | .required_features = .{ .bmi2, null, null, null }, | 43699 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 30585 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 43700 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30586 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30587 | .patterns = &.{ | 43701 | .patterns = &.{ |
| 30588 | .{ .src = .{ .to_mem, .none } }, | 43702 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30589 | }, | 43703 | }, |
| 30590 | .extra_temps = .{ | 43704 | .extra_temps = .{ |
| 30591 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30592 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43706 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30593 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43707 | .unused, |
| 30594 | .unused, | 43708 | .unused, |
| 30595 | .unused, | 43709 | .unused, |
| 30596 | .unused, | 43710 | .unused, |
| ... | @@ -30602,22 +43716,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30602,22 +43716,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30602 | .clobbers = .{ .eflags = true }, | 43716 | .clobbers = .{ .eflags = true }, |
| 30603 | .each = .{ .once = &.{ | 43717 | .each = .{ .once = &.{ |
| 30604 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43718 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30605 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 43719 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30606 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 43720 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 30607 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43721 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30608 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43722 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30609 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43723 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30610 | } }, | 43724 | } }, |
| 30611 | }, .{ | 43725 | }, .{ |
| 30612 | .required_features = .{ .slow_incdec, null, null, null }, | 43726 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 30613 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 43727 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30614 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30615 | .patterns = &.{ | 43728 | .patterns = &.{ |
| 30616 | .{ .src = .{ .to_mem, .none } }, | 43729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30617 | }, | 43730 | }, |
| 30618 | .extra_temps = .{ | 43731 | .extra_temps = .{ |
| 30619 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43732 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30620 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43733 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30621 | .unused, | 43734 | .unused, |
| 30622 | .unused, | 43735 | .unused, |
| 30623 | .unused, | 43736 | .unused, |
| ... | @@ -30631,20 +43744,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30631,20 +43744,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30631 | .each = .{ .once = &.{ | 43744 | .each = .{ .once = &.{ |
| 30632 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43745 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30633 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 43746 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30634 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | 43747 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30635 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43748 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30636 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 30637 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30638 | } }, | 43750 | } }, |
| 30639 | }, .{ | 43751 | }, .{ |
| 30640 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 43752 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 30641 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43753 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30642 | .patterns = &.{ | 43754 | .patterns = &.{ |
| 30643 | .{ .src = .{ .to_mem, .none } }, | 43755 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30644 | }, | 43756 | }, |
| 30645 | .extra_temps = .{ | 43757 | .extra_temps = .{ |
| 30646 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43758 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30647 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43759 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30648 | .unused, | 43760 | .unused, |
| 30649 | .unused, | 43761 | .unused, |
| 30650 | .unused, | 43762 | .unused, |
| ... | @@ -30658,22 +43770,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30658,22 +43770,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30658 | .each = .{ .once = &.{ | 43770 | .each = .{ .once = &.{ |
| 30659 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43771 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30660 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 43772 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30661 | .{ ._, ._, .@"and", .tmp1b, .sa(.dst0, .add_umax), ._, ._ }, | 43773 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30662 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, | 43774 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30663 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43775 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30664 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43776 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 43777 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30665 | } }, | 43778 | } }, |
| 30666 | }, .{ | 43779 | }, .{ |
| 30667 | .required_features = .{ .slow_incdec, null, null, null }, | 43780 | .required_features = .{ .bmi2, null, null, null }, |
| 30668 | .src_constraints = .{ .any_scalar_int, .any }, | 43781 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 30669 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | 43782 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30670 | .patterns = &.{ | 43783 | .patterns = &.{ |
| 30671 | .{ .src = .{ .to_mem, .none } }, | 43784 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30672 | }, | 43785 | }, |
| 30673 | .extra_temps = .{ | 43786 | .extra_temps = .{ |
| 30674 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43787 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30675 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 30676 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43788 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 43789 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30677 | .unused, | 43790 | .unused, |
| 30678 | .unused, | 43791 | .unused, |
| 30679 | .unused, | 43792 | .unused, |
| ... | @@ -30685,23 +43798,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30685,23 +43798,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30685 | .clobbers = .{ .eflags = true }, | 43798 | .clobbers = .{ .eflags = true }, |
| 30686 | .each = .{ .once = &.{ | 43799 | .each = .{ .once = &.{ |
| 30687 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43800 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30688 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43801 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30689 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 43802 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 30690 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43803 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30691 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 43804 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30692 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 30693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43805 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30694 | } }, | 43806 | } }, |
| 30695 | }, .{ | 43807 | }, .{ |
| 30696 | .src_constraints = .{ .any_scalar_int, .any }, | 43808 | .required_features = .{ .fast_imm16, null, null, null }, |
| 30697 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .byte, .is = 8 } }}, | 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 | .patterns = &.{ | 43811 | .patterns = &.{ |
| 30699 | .{ .src = .{ .to_mem, .none } }, | 43812 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30700 | }, | 43813 | }, |
| 30701 | .extra_temps = .{ | 43814 | .extra_temps = .{ |
| 30702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43815 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30703 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43816 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30704 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43817 | .unused, |
| 30705 | .unused, | 43818 | .unused, |
| 30706 | .unused, | 43819 | .unused, |
| 30707 | .unused, | 43820 | .unused, |
| ... | @@ -30713,24 +43826,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30713,24 +43826,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30713 | .clobbers = .{ .eflags = true }, | 43826 | .clobbers = .{ .eflags = true }, |
| 30714 | .each = .{ .once = &.{ | 43827 | .each = .{ .once = &.{ |
| 30715 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43828 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30716 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43829 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30717 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 43830 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, |
| 30718 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43831 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30719 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 43832 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30720 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43833 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30721 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 30722 | } }, | 43834 | } }, |
| 30723 | }, .{ | 43835 | }, .{ |
| 30724 | .required_features = .{ .slow_incdec, null, null, null }, | 43836 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 30725 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 43837 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30726 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30727 | .patterns = &.{ | 43838 | .patterns = &.{ |
| 30728 | .{ .src = .{ .to_mem, .none } }, | 43839 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30729 | }, | 43840 | }, |
| 30730 | .extra_temps = .{ | 43841 | .extra_temps = .{ |
| 30731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43842 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30732 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43843 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30733 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43844 | .unused, |
| 30734 | .unused, | 43845 | .unused, |
| 30735 | .unused, | 43846 | .unused, |
| 30736 | .unused, | 43847 | .unused, |
| ... | @@ -30742,25 +43853,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30742,25 +43853,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30742 | .clobbers = .{ .eflags = true }, | 43853 | .clobbers = .{ .eflags = true }, |
| 30743 | .each = .{ .once = &.{ | 43854 | .each = .{ .once = &.{ |
| 30744 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43855 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30745 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43856 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 30746 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 43857 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 30747 | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43858 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 30748 | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43859 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30749 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | | |
| 30750 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | | |
| 30751 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | | |
| 30752 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43860 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30753 | } }, | 43861 | } }, |
| 30754 | }, .{ | 43862 | }, .{ |
| 30755 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 43863 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 30756 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, | 43864 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, |
| 30757 | .patterns = &.{ | 43865 | .patterns = &.{ |
| 30758 | .{ .src = .{ .to_mem, .none } }, | 43866 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30759 | }, | 43867 | }, |
| 30760 | .extra_temps = .{ | 43868 | .extra_temps = .{ |
| 30761 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30762 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43870 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30763 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 43871 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30764 | .unused, | 43872 | .unused, |
| 30765 | .unused, | 43873 | .unused, |
| 30766 | .unused, | 43874 | .unused, |
| ... | @@ -30774,25 +43882,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30774,25 +43882,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30774 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43882 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30775 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43883 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30776 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 43884 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30777 | .{ ._, ._l, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | 43885 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30778 | .{ ._, ._r, .sa, .tmp2b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, | | |
| 30779 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | | |
| 30780 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 43886 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30781 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43887 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30782 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43888 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30783 | } }, | 43889 | } }, |
| 30784 | }, .{ | 43890 | }, .{ |
| 30785 | .required_features = .{ .bmi2, .slow_incdec, null, null }, | 43891 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 30786 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 43892 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 30787 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | | |
| 30788 | .patterns = &.{ | 43893 | .patterns = &.{ |
| 30789 | .{ .src = .{ .to_mem, .none } }, | 43894 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30790 | }, | 43895 | }, |
| 30791 | .extra_temps = .{ | 43896 | .extra_temps = .{ |
| 30792 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43897 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30793 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43898 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30794 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43899 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 30795 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43900 | .unused, |
| 30796 | .unused, | 43901 | .unused, |
| 30797 | .unused, | 43902 | .unused, |
| 30798 | .unused, | 43903 | .unused, |
| ... | @@ -30804,25 +43909,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30804,25 +43909,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30804 | .each = .{ .once = &.{ | 43909 | .each = .{ .once = &.{ |
| 30805 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43910 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30806 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43911 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30807 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, | 43912 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30808 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, | 43913 | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30809 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, | 43914 | .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 43915 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30810 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 43916 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30811 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43917 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30812 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43918 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30813 | } }, | 43919 | } }, |
| 30814 | }, .{ | 43920 | }, .{ |
| 30815 | .required_features = .{ .bmi2, null, null, null }, | 43921 | .required_features = .{ .bmi2, null, null, null }, |
| 30816 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 43922 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 30817 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43923 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30818 | .patterns = &.{ | 43924 | .patterns = &.{ |
| 30819 | .{ .src = .{ .to_mem, .none } }, | 43925 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30820 | }, | 43926 | }, |
| 30821 | .extra_temps = .{ | 43927 | .extra_temps = .{ |
| 30822 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43928 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30823 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43929 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30824 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43930 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 30825 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43931 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30826 | .unused, | 43932 | .unused, |
| 30827 | .unused, | 43933 | .unused, |
| 30828 | .unused, | 43934 | .unused, |
| ... | @@ -30836,22 +43942,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30836,22 +43942,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30836 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43942 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30837 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, | 43943 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 30838 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, | 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 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 43946 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30841 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 43947 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30842 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 43948 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30843 | } }, | 43949 | } }, |
| 30844 | }, .{ | 43950 | }, .{ |
| 30845 | .required_features = .{ .slow_incdec, null, null, null }, | 43951 | .required_features = .{ .fast_imm16, null, null, null }, |
| 30846 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 43952 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 30847 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43953 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30848 | .patterns = &.{ | 43954 | .patterns = &.{ |
| 30849 | .{ .src = .{ .to_mem, .none } }, | 43955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30850 | }, | 43956 | }, |
| 30851 | .extra_temps = .{ | 43957 | .extra_temps = .{ |
| 30852 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30853 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43959 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30854 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43960 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30855 | .unused, | 43961 | .unused, |
| 30856 | .unused, | 43962 | .unused, |
| 30857 | .unused, | 43963 | .unused, |
| ... | @@ -30865,22 +43971,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30865,22 +43971,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30865 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 43971 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30866 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 43972 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30867 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 43973 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30868 | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, | 43974 | .{ ._, ._, .@"and", .tmp2w, .sa(.dst0, .add_umax), ._, ._ }, |
| 30869 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 43975 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30870 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 43976 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30871 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, | 43977 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30872 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 43978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30873 | } }, | 43979 | } }, |
| 30874 | }, .{ | 43980 | }, .{ |
| 30875 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 43981 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 30876 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, | 43982 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 30877 | .patterns = &.{ | 43983 | .patterns = &.{ |
| 30878 | .{ .src = .{ .to_mem, .none } }, | 43984 | .{ .src = .{ .to_mem, .none, .none } }, |
| 30879 | }, | 43985 | }, |
| 30880 | .extra_temps = .{ | 43986 | .extra_temps = .{ |
| 30881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 43987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 30882 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 43988 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 30883 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 43989 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 30884 | .unused, | 43990 | .unused, |
| 30885 | .unused, | 43991 | .unused, |
| 30886 | .unused, | 43992 | .unused, |
| ... | @@ -30894,30 +44000,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30894,30 +44000,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30894 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44000 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 30895 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 44001 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 30896 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 44002 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 30897 | .{ ._, ._, .@"and", .tmp2b, .sa(.dst0, .add_umax), ._, ._ }, | 44003 | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, |
| 30898 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, | 44004 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 30899 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 44005 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 30900 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 44006 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 30901 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 44007 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 30902 | } }, | 44008 | } }, |
| 30903 | }, .{ | 44009 | }, .{ |
| 30904 | .required_features = .{ .avx, null, null, null }, | 44010 | .required_features = .{ .avx, null, null, null }, |
| 30905 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, | 44011 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30906 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 44012 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 30907 | .patterns = &.{ | 44013 | .patterns = &.{ |
| 30908 | .{ .src = .{ .to_sse, .none } }, | 44014 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30909 | }, | 44015 | }, |
| 30910 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 44016 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 30911 | .each = .{ .once = &.{ | 44017 | .each = .{ .once = &.{ |
| 30912 | .{ ._, .vp_w, .sll, .dst0x, .src0x, .uia(16, .dst0, .sub_bit_size), ._ }, | 44018 | .{ ._, .vp_d, .sll, .dst0x, .src0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 30913 | .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, | 44019 | .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 30914 | } }, | 44020 | } }, |
| 30915 | }, .{ | 44021 | }, .{ |
| 30916 | .required_features = .{ .avx, null, null, null }, | 44022 | .required_features = .{ .avx, null, null, null }, |
| 30917 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, | 44023 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30918 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, | 44024 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 30919 | .patterns = &.{ | 44025 | .patterns = &.{ |
| 30920 | .{ .src = .{ .to_sse, .none } }, | 44026 | .{ .src = .{ .to_sse, .none, .none } }, |
| 30921 | }, | 44027 | }, |
| 30922 | .extra_temps = .{ | 44028 | .extra_temps = .{ |
| 30923 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 44029 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -30937,22 +44043,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30937,22 +44043,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30937 | } }, | 44043 | } }, |
| 30938 | }, .{ | 44044 | }, .{ |
| 30939 | .required_features = .{ .sse2, null, null, null }, | 44045 | .required_features = .{ .sse2, null, null, null }, |
| 30940 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, | 44046 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30941 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 44047 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 30942 | .patterns = &.{ | 44048 | .patterns = &.{ |
| 30943 | .{ .src = .{ .to_mut_sse, .none } }, | 44049 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30944 | }, | 44050 | }, |
| 30945 | .dst_temps = .{.{ .ref = .src0 }}, | 44051 | .dst_temps = .{.{ .ref = .src0 }}, |
| 30946 | .each = .{ .once = &.{ | 44052 | .each = .{ .once = &.{ |
| 30947 | .{ ._, .p_w, .sll, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, | 44053 | .{ ._, .p_d, .sll, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30948 | .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, | 44054 | .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 30949 | } }, | 44055 | } }, |
| 30950 | }, .{ | 44056 | }, .{ |
| 30951 | .required_features = .{ .sse2, null, null, null }, | 44057 | .required_features = .{ .sse2, null, null, null }, |
| 30952 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, | 44058 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30953 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, | 44059 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 30954 | .patterns = &.{ | 44060 | .patterns = &.{ |
| 30955 | .{ .src = .{ .to_mut_sse, .none } }, | 44061 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30956 | }, | 44062 | }, |
| 30957 | .extra_temps = .{ | 44063 | .extra_temps = .{ |
| 30958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 44064 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -30972,10 +44078,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30972,10 +44078,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30972 | } }, | 44078 | } }, |
| 30973 | }, .{ | 44079 | }, .{ |
| 30974 | .required_features = .{ .sse, null, null, null }, | 44080 | .required_features = .{ .sse, null, null, null }, |
| 30975 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, | 44081 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 30976 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, | 44082 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 30977 | .patterns = &.{ | 44083 | .patterns = &.{ |
| 30978 | .{ .src = .{ .to_mut_sse, .none } }, | 44084 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 30979 | }, | 44085 | }, |
| 30980 | .extra_temps = .{ | 44086 | .extra_temps = .{ |
| 30981 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 44087 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -30995,22 +44101,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -30995,22 +44101,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 30995 | } }, | 44101 | } }, |
| 30996 | }, .{ | 44102 | }, .{ |
| 30997 | .required_features = .{ .avx2, null, null, null }, | 44103 | .required_features = .{ .avx2, null, null, null }, |
| 30998 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, .any }, | 44104 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 30999 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .word } }}, | 44105 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 31000 | .patterns = &.{ | 44106 | .patterns = &.{ |
| 31001 | .{ .src = .{ .to_sse, .none } }, | 44107 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31002 | }, | 44108 | }, |
| 31003 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 44109 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31004 | .each = .{ .once = &.{ | 44110 | .each = .{ .once = &.{ |
| 31005 | .{ ._, .vp_w, .sll, .dst0y, .src0y, .uia(16, .dst0, .sub_bit_size), ._ }, | 44111 | .{ ._, .vp_d, .sll, .dst0y, .src0y, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 31006 | .{ ._, .vp_w, .sra, .dst0y, .dst0y, .uia(16, .dst0, .sub_bit_size), ._ }, | 44112 | .{ ._, .vp_d, .sra, .dst0y, .dst0y, .uia(32, .dst0, .sub_bit_size), ._ }, |
| 31007 | } }, | 44113 | } }, |
| 31008 | }, .{ | 44114 | }, .{ |
| 31009 | .required_features = .{ .avx2, null, null, null }, | 44115 | .required_features = .{ .avx2, null, null, null }, |
| 31010 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any }, | 44116 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 31011 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }}, | 44117 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, |
| 31012 | .patterns = &.{ | 44118 | .patterns = &.{ |
| 31013 | .{ .src = .{ .to_sse, .none } }, | 44119 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31014 | }, | 44120 | }, |
| 31015 | .extra_temps = .{ | 44121 | .extra_temps = .{ |
| 31016 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 44122 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -31030,14 +44136,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31030,14 +44136,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31030 | } }, | 44136 | } }, |
| 31031 | }, .{ | 44137 | }, .{ |
| 31032 | .required_features = .{ .avx2, null, null, null }, | 44138 | .required_features = .{ .avx2, null, null, null }, |
| 31033 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, .any }, | 44139 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 31034 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }}, | 44140 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, |
| 31035 | .patterns = &.{ | 44141 | .patterns = &.{ |
| 31036 | .{ .src = .{ .to_mem, .none } }, | 44142 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31037 | }, | 44143 | }, |
| 31038 | .extra_temps = .{ | 44144 | .extra_temps = .{ |
| 31039 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44145 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31040 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, | 44146 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 31041 | .unused, | 44147 | .unused, |
| 31042 | .unused, | 44148 | .unused, |
| 31043 | .unused, | 44149 | .unused, |
| ... | @@ -31051,23 +44157,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31051,23 +44157,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31051 | .each = .{ .once = &.{ | 44157 | .each = .{ .once = &.{ |
| 31052 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44158 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31053 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 44159 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31054 | .{ ._, .vp_w, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, | 44160 | .{ ._, .vp_d, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31055 | .{ ._, .vp_w, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, | 44161 | .{ ._, .vp_d, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31056 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 44162 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 31057 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 44163 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 31058 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44164 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31059 | } }, | 44165 | } }, |
| 31060 | }, .{ | 44166 | }, .{ |
| 31061 | .required_features = .{ .avx2, null, null, null }, | 44167 | .required_features = .{ .avx2, null, null, null }, |
| 31062 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, .any }, | 44168 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 31063 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }}, | 44169 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, |
| 31064 | .patterns = &.{ | 44170 | .patterns = &.{ |
| 31065 | .{ .src = .{ .to_mem, .none } }, | 44171 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31066 | }, | 44172 | }, |
| 31067 | .extra_temps = .{ | 44173 | .extra_temps = .{ |
| 31068 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44174 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31069 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, | 44175 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 31070 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, | 44176 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| 31071 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 44177 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31072 | .unused, | 44178 | .unused, |
| 31073 | .unused, | 44179 | .unused, |
| ... | @@ -31088,14 +44194,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31088,14 +44194,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31088 | } }, | 44194 | } }, |
| 31089 | }, .{ | 44195 | }, .{ |
| 31090 | .required_features = .{ .avx, null, null, null }, | 44196 | .required_features = .{ .avx, null, null, null }, |
| 31091 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, | 44197 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31092 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 44198 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 31093 | .patterns = &.{ | 44199 | .patterns = &.{ |
| 31094 | .{ .src = .{ .to_mem, .none } }, | 44200 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31095 | }, | 44201 | }, |
| 31096 | .extra_temps = .{ | 44202 | .extra_temps = .{ |
| 31097 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31098 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, | 44204 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 31099 | .unused, | 44205 | .unused, |
| 31100 | .unused, | 44206 | .unused, |
| 31101 | .unused, | 44207 | .unused, |
| ... | @@ -31109,23 +44215,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31109,23 +44215,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31109 | .each = .{ .once = &.{ | 44215 | .each = .{ .once = &.{ |
| 31110 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44216 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31111 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 44217 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31112 | .{ ._, .vp_w, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, | 44218 | .{ ._, .vp_d, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31113 | .{ ._, .vp_w, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, | 44219 | .{ ._, .vp_d, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| 31114 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 44220 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31115 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 44221 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31116 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44222 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31117 | } }, | 44223 | } }, |
| 31118 | }, .{ | 44224 | }, .{ |
| 31119 | .required_features = .{ .avx, null, null, null }, | 44225 | .required_features = .{ .avx, null, null, null }, |
| 31120 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, | 44226 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31121 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, | 44227 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 31122 | .patterns = &.{ | 44228 | .patterns = &.{ |
| 31123 | .{ .src = .{ .to_mem, .none } }, | 44229 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31124 | }, | 44230 | }, |
| 31125 | .extra_temps = .{ | 44231 | .extra_temps = .{ |
| 31126 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44232 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31127 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 44233 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31128 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 44234 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31129 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 44235 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31130 | .unused, | 44236 | .unused, |
| 31131 | .unused, | 44237 | .unused, |
| ... | @@ -31146,14 +44252,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31146,14 +44252,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31146 | } }, | 44252 | } }, |
| 31147 | }, .{ | 44253 | }, .{ |
| 31148 | .required_features = .{ .sse2, null, null, null }, | 44254 | .required_features = .{ .sse2, null, null, null }, |
| 31149 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any }, | 44255 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31150 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }}, | 44256 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 31151 | .patterns = &.{ | 44257 | .patterns = &.{ |
| 31152 | .{ .src = .{ .to_mem, .none } }, | 44258 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31153 | }, | 44259 | }, |
| 31154 | .extra_temps = .{ | 44260 | .extra_temps = .{ |
| 31155 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31156 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, | 44262 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 31157 | .unused, | 44263 | .unused, |
| 31158 | .unused, | 44264 | .unused, |
| 31159 | .unused, | 44265 | .unused, |
| ... | @@ -31167,23 +44273,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31167,23 +44273,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31167 | .each = .{ .once = &.{ | 44273 | .each = .{ .once = &.{ |
| 31168 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44274 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31169 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 44275 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31170 | .{ ._, .p_w, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, | 44276 | .{ ._, .p_d, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 31171 | .{ ._, .p_w, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, | 44277 | .{ ._, .p_d, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| 31172 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 44278 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 31173 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 44279 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 31174 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44280 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31175 | } }, | 44281 | } }, |
| 31176 | }, .{ | 44282 | }, .{ |
| 31177 | .required_features = .{ .sse2, null, null, null }, | 44283 | .required_features = .{ .sse2, null, null, null }, |
| 31178 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, | 44284 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31179 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, | 44285 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 31180 | .patterns = &.{ | 44286 | .patterns = &.{ |
| 31181 | .{ .src = .{ .to_mem, .none } }, | 44287 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31182 | }, | 44288 | }, |
| 31183 | .extra_temps = .{ | 44289 | .extra_temps = .{ |
| 31184 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44290 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31185 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 44291 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31186 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 44292 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31187 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 44293 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31188 | .unused, | 44294 | .unused, |
| 31189 | .unused, | 44295 | .unused, |
| ... | @@ -31205,15 +44311,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31205,15 +44311,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31205 | } }, | 44311 | } }, |
| 31206 | }, .{ | 44312 | }, .{ |
| 31207 | .required_features = .{ .sse, null, null, null }, | 44313 | .required_features = .{ .sse, null, null, null }, |
| 31208 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any }, | 44314 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 31209 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }}, | 44315 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, |
| 31210 | .patterns = &.{ | 44316 | .patterns = &.{ |
| 31211 | .{ .src = .{ .to_mem, .none } }, | 44317 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31212 | }, | 44318 | }, |
| 31213 | .extra_temps = .{ | 44319 | .extra_temps = .{ |
| 31214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44320 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31215 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 44321 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31216 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 44322 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| 31217 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 44323 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31218 | .unused, | 44324 | .unused, |
| 31219 | .unused, | 44325 | .unused, |
| ... | @@ -31234,14 +44340,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31234,14 +44340,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31234 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44340 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31235 | } }, | 44341 | } }, |
| 31236 | }, .{ | 44342 | }, .{ |
| 31237 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .word, .is = .word } }, .any }, | 44343 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31238 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, | 44344 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31239 | .patterns = &.{ | 44345 | .patterns = &.{ |
| 31240 | .{ .src = .{ .to_mem, .none } }, | 44346 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31241 | }, | 44347 | }, |
| 31242 | .extra_temps = .{ | 44348 | .extra_temps = .{ |
| 31243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44349 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31244 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44350 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31245 | .unused, | 44351 | .unused, |
| 31246 | .unused, | 44352 | .unused, |
| 31247 | .unused, | 44353 | .unused, |
| ... | @@ -31254,20 +44360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31254,20 +44360,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31254 | .clobbers = .{ .eflags = true }, | 44360 | .clobbers = .{ .eflags = true }, |
| 31255 | .each = .{ .once = &.{ | 44361 | .each = .{ .once = &.{ |
| 31256 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44362 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31257 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 44363 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 31258 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44364 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31259 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44365 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31260 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44366 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31261 | } }, | 44367 | } }, |
| 31262 | }, .{ | 44368 | }, .{ |
| 31263 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any }, | 44369 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31264 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 44370 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31265 | .patterns = &.{ | 44371 | .patterns = &.{ |
| 31266 | .{ .src = .{ .to_mem, .none } }, | 44372 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31267 | }, | 44373 | }, |
| 31268 | .extra_temps = .{ | 44374 | .extra_temps = .{ |
| 31269 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44375 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31270 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 44376 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31271 | .unused, | 44377 | .unused, |
| 31272 | .unused, | 44378 | .unused, |
| 31273 | .unused, | 44379 | .unused, |
| ... | @@ -31280,24 +44386,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31280,24 +44386,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31280 | .clobbers = .{ .eflags = true }, | 44386 | .clobbers = .{ .eflags = true }, |
| 31281 | .each = .{ .once = &.{ | 44387 | .each = .{ .once = &.{ |
| 31282 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44390 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31285 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44391 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31286 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44392 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31287 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44393 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31288 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44394 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31289 | } }, | 44395 | } }, |
| 31290 | }, .{ | 44396 | }, .{ |
| 31291 | .required_features = .{ .fast_imm16, null, null, null }, | 44397 | .required_features = .{ .bmi2, null, null, null }, |
| 31292 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, | 44398 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31293 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44399 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31294 | .patterns = &.{ | 44400 | .patterns = &.{ |
| 31295 | .{ .src = .{ .to_mem, .none } }, | 44401 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31296 | }, | 44402 | }, |
| 31297 | .extra_temps = .{ | 44403 | .extra_temps = .{ |
| 31298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44404 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31299 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44405 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31300 | .unused, | 44406 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31301 | .unused, | 44407 | .unused, |
| 31302 | .unused, | 44408 | .unused, |
| 31303 | .unused, | 44409 | .unused, |
| ... | @@ -31309,21 +44415,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31309,21 +44415,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31309 | .clobbers = .{ .eflags = true }, | 44415 | .clobbers = .{ .eflags = true }, |
| 31310 | .each = .{ .once = &.{ | 44416 | .each = .{ .once = &.{ |
| 31311 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44417 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31312 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 44418 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31313 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, | 44419 | .{ .@"0:", ._, .bzhi, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31314 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44420 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31315 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44421 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31316 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44422 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31317 | } }, | 44423 | } }, |
| 31318 | }, .{ | 44424 | }, .{ |
| 31319 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any }, | 44425 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 31320 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44426 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31321 | .patterns = &.{ | 44427 | .patterns = &.{ |
| 31322 | .{ .src = .{ .to_mem, .none } }, | 44428 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31323 | }, | 44429 | }, |
| 31324 | .extra_temps = .{ | 44430 | .extra_temps = .{ |
| 31325 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44431 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31326 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44432 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31327 | .unused, | 44433 | .unused, |
| 31328 | .unused, | 44434 | .unused, |
| 31329 | .unused, | 44435 | .unused, |
| ... | @@ -31336,21 +44442,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31336,21 +44442,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31336 | .clobbers = .{ .eflags = true }, | 44442 | .clobbers = .{ .eflags = true }, |
| 31337 | .each = .{ .once = &.{ | 44443 | .each = .{ .once = &.{ |
| 31338 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 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 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 44446 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31341 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44447 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31342 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44448 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31343 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44449 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31344 | } }, | 44450 | } }, |
| 31345 | }, .{ | 44451 | }, .{ |
| 31346 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 44452 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31347 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, | 44453 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31348 | .patterns = &.{ | 44454 | .patterns = &.{ |
| 31349 | .{ .src = .{ .to_mem, .none } }, | 44455 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31350 | }, | 44456 | }, |
| 31351 | .extra_temps = .{ | 44457 | .extra_temps = .{ |
| 31352 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44458 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31353 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44459 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31354 | .unused, | 44460 | .unused, |
| 31355 | .unused, | 44461 | .unused, |
| 31356 | .unused, | 44462 | .unused, |
| ... | @@ -31364,19 +44470,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31364,19 +44470,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31364 | .each = .{ .once = &.{ | 44470 | .each = .{ .once = &.{ |
| 31365 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44471 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31366 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 44472 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31367 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44473 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31368 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44474 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31369 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44475 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31370 | } }, | 44476 | } }, |
| 31371 | }, .{ | 44477 | }, .{ |
| 31372 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 44478 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31373 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 44479 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31374 | .patterns = &.{ | 44480 | .patterns = &.{ |
| 31375 | .{ .src = .{ .to_mem, .none } }, | 44481 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31376 | }, | 44482 | }, |
| 31377 | .extra_temps = .{ | 44483 | .extra_temps = .{ |
| 31378 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44484 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31379 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 44485 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31380 | .unused, | 44486 | .unused, |
| 31381 | .unused, | 44487 | .unused, |
| 31382 | .unused, | 44488 | .unused, |
| ... | @@ -31392,21 +44498,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31392,21 +44498,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31392 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 44498 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31393 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44499 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31394 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44500 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31395 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44501 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31396 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44502 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31397 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44503 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31398 | } }, | 44504 | } }, |
| 31399 | }, .{ | 44505 | }, .{ |
| 31400 | .required_features = .{ .bmi2, null, null, null }, | 44506 | .required_features = .{ .bmi2, null, null, null }, |
| 31401 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 44507 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31402 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44508 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31403 | .patterns = &.{ | 44509 | .patterns = &.{ |
| 31404 | .{ .src = .{ .to_mem, .none } }, | 44510 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31405 | }, | 44511 | }, |
| 31406 | .extra_temps = .{ | 44512 | .extra_temps = .{ |
| 31407 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44513 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31408 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 44514 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31409 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44515 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31410 | .unused, | 44516 | .unused, |
| 31411 | .unused, | 44517 | .unused, |
| 31412 | .unused, | 44518 | .unused, |
| ... | @@ -31420,47 +44526,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31420,47 +44526,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31420 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44526 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31421 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 44527 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31422 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 44528 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31423 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, | 44529 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31424 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44530 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 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), ._, ._ }, | | |
| 31453 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44531 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31454 | } }, | 44532 | } }, |
| 31455 | }, .{ | 44533 | }, .{ |
| 31456 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 44534 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 31457 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44535 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31458 | .patterns = &.{ | 44536 | .patterns = &.{ |
| 31459 | .{ .src = .{ .to_mem, .none } }, | 44537 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31460 | }, | 44538 | }, |
| 31461 | .extra_temps = .{ | 44539 | .extra_temps = .{ |
| 31462 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44540 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31463 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44541 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31464 | .unused, | 44542 | .unused, |
| 31465 | .unused, | 44543 | .unused, |
| 31466 | .unused, | 44544 | .unused, |
| ... | @@ -31475,45 +44553,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31475,45 +44553,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31475 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44553 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31476 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 44554 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31477 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 44555 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31478 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44556 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31479 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44557 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 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), ._, ._ }, | | |
| 31506 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44558 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31507 | } }, | 44559 | } }, |
| 31508 | }, .{ | 44560 | }, .{ |
| 31509 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, | 44561 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 31510 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 44562 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31511 | .patterns = &.{ | 44563 | .patterns = &.{ |
| 31512 | .{ .src = .{ .to_mem, .none } }, | 44564 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31513 | }, | 44565 | }, |
| 31514 | .extra_temps = .{ | 44566 | .extra_temps = .{ |
| 31515 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44567 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31516 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 44568 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31517 | .unused, | 44569 | .unused, |
| 31518 | .unused, | 44570 | .unused, |
| 31519 | .unused, | 44571 | .unused, |
| ... | @@ -31527,23 +44579,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31527,23 +44579,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31527 | .each = .{ .once = &.{ | 44579 | .each = .{ .once = &.{ |
| 31528 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44580 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31529 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 44581 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31530 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44582 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31531 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44583 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31532 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | | |
| 31533 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | | |
| 31534 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44584 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31535 | } }, | 44585 | } }, |
| 31536 | }, .{ | 44586 | }, .{ |
| 31537 | .required_features = .{ .bmi2, null, null, null }, | 44587 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 31538 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 44588 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31539 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | | |
| 31540 | .patterns = &.{ | 44589 | .patterns = &.{ |
| 31541 | .{ .src = .{ .to_mem, .none } }, | 44590 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31542 | }, | 44591 | }, |
| 31543 | .extra_temps = .{ | 44592 | .extra_temps = .{ |
| 31544 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44593 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31545 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 44594 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31546 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44595 | .unused, |
| 31547 | .unused, | 44596 | .unused, |
| 31548 | .unused, | 44597 | .unused, |
| 31549 | .unused, | 44598 | .unused, |
| ... | @@ -31555,23 +44604,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31555,23 +44604,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31555 | .clobbers = .{ .eflags = true }, | 44604 | .clobbers = .{ .eflags = true }, |
| 31556 | .each = .{ .once = &.{ | 44605 | .each = .{ .once = &.{ |
| 31557 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44606 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31558 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 44607 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31559 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 44608 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31560 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, | 44609 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31561 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44610 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 44611 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31562 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44612 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31563 | } }, | 44613 | } }, |
| 31564 | }, .{ | 44614 | }, .{ |
| 31565 | .required_features = .{ .fast_imm16, null, null, null }, | 44615 | .required_features = .{ .bmi2, null, null, null }, |
| 31566 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 44616 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 31567 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44617 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31568 | .patterns = &.{ | 44618 | .patterns = &.{ |
| 31569 | .{ .src = .{ .to_mem, .none } }, | 44619 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31570 | }, | 44620 | }, |
| 31571 | .extra_temps = .{ | 44621 | .extra_temps = .{ |
| 31572 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31573 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44623 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31574 | .unused, | 44624 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31575 | .unused, | 44625 | .unused, |
| 31576 | .unused, | 44626 | .unused, |
| 31577 | .unused, | 44627 | .unused, |
| ... | @@ -31583,21 +44633,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31583,21 +44633,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31583 | .clobbers = .{ .eflags = true }, | 44633 | .clobbers = .{ .eflags = true }, |
| 31584 | .each = .{ .once = &.{ | 44634 | .each = .{ .once = &.{ |
| 31585 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44635 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31586 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 44636 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31587 | .{ ._, ._, .@"and", .tmp1w, .sa(.dst0, .add_umax), ._, ._ }, | 44637 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31588 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44638 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31589 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44639 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31590 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44640 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31591 | } }, | 44641 | } }, |
| 31592 | }, .{ | 44642 | }, .{ |
| 31593 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 44643 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 31594 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44644 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31595 | .patterns = &.{ | 44645 | .patterns = &.{ |
| 31596 | .{ .src = .{ .to_mem, .none } }, | 44646 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31597 | }, | 44647 | }, |
| 31598 | .extra_temps = .{ | 44648 | .extra_temps = .{ |
| 31599 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44649 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31600 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44650 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31601 | .unused, | 44651 | .unused, |
| 31602 | .unused, | 44652 | .unused, |
| 31603 | .unused, | 44653 | .unused, |
| ... | @@ -31612,19 +44662,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31612,19 +44662,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31612 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44662 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31613 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 44663 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31614 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 44664 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31615 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44665 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31616 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44666 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31617 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44667 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31618 | } }, | 44668 | } }, |
| 31619 | }, .{ | 44669 | }, .{ |
| 31620 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, | 44670 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 31621 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, | 44671 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31622 | .patterns = &.{ | 44672 | .patterns = &.{ |
| 31623 | .{ .src = .{ .to_mem, .none } }, | 44673 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31624 | }, | 44674 | }, |
| 31625 | .extra_temps = .{ | 44675 | .extra_temps = .{ |
| 31626 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44676 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31627 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44677 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31628 | .unused, | 44678 | .unused, |
| 31629 | .unused, | 44679 | .unused, |
| 31630 | .unused, | 44680 | .unused, |
| ... | @@ -31638,19 +44688,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31638,19 +44688,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31638 | .each = .{ .once = &.{ | 44688 | .each = .{ .once = &.{ |
| 31639 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44689 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31640 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 44690 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31641 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44691 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31642 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44692 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31643 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31644 | } }, | 44694 | } }, |
| 31645 | }, .{ | 44695 | }, .{ |
| 31646 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, | 44696 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 31647 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 44697 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31648 | .patterns = &.{ | 44698 | .patterns = &.{ |
| 31649 | .{ .src = .{ .to_mem, .none } }, | 44699 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31650 | }, | 44700 | }, |
| 31651 | .extra_temps = .{ | 44701 | .extra_temps = .{ |
| 31652 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31653 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 44703 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31654 | .unused, | 44704 | .unused, |
| 31655 | .unused, | 44705 | .unused, |
| 31656 | .unused, | 44706 | .unused, |
| ... | @@ -31666,21 +44716,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31666,21 +44716,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31666 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 44716 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31667 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44717 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31668 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44718 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31669 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44719 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31670 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44720 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31671 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44721 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31672 | } }, | 44722 | } }, |
| 31673 | }, .{ | 44723 | }, .{ |
| 31674 | .required_features = .{ .bmi2, null, null, null }, | 44724 | .required_features = .{ .bmi2, null, null, null }, |
| 31675 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, | 44725 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 31676 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44726 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31677 | .patterns = &.{ | 44727 | .patterns = &.{ |
| 31678 | .{ .src = .{ .to_mem, .none } }, | 44728 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31679 | }, | 44729 | }, |
| 31680 | .extra_temps = .{ | 44730 | .extra_temps = .{ |
| 31681 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31682 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 44732 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31683 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44733 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31684 | .unused, | 44734 | .unused, |
| 31685 | .unused, | 44735 | .unused, |
| 31686 | .unused, | 44736 | .unused, |
| ... | @@ -31694,47 +44744,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31694,47 +44744,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31694 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44744 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31695 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 44745 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31696 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 44746 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, |
| 31697 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, | 44747 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31698 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44748 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 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), ._, ._ }, | | |
| 31727 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31728 | } }, | 44750 | } }, |
| 31729 | }, .{ | 44751 | }, .{ |
| 31730 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, | 44752 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 31731 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44753 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31732 | .patterns = &.{ | 44754 | .patterns = &.{ |
| 31733 | .{ .src = .{ .to_mem, .none } }, | 44755 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31734 | }, | 44756 | }, |
| 31735 | .extra_temps = .{ | 44757 | .extra_temps = .{ |
| 31736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44758 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31737 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44759 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31738 | .unused, | 44760 | .unused, |
| 31739 | .unused, | 44761 | .unused, |
| 31740 | .unused, | 44762 | .unused, |
| ... | @@ -31749,20 +44771,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31749,20 +44771,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31749 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44771 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31750 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 44772 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 31751 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 44773 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31752 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, | 44774 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 31753 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44775 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31754 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44776 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31755 | } }, | 44777 | } }, |
| 31756 | }, .{ | 44778 | }, .{ |
| 31757 | .src_constraints = .{ .any_scalar_int, .any }, | 44779 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 31758 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .word, .is = 16 } }}, | 44780 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, |
| 31759 | .patterns = &.{ | 44781 | .patterns = &.{ |
| 31760 | .{ .src = .{ .to_mem, .none } }, | 44782 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31761 | }, | 44783 | }, |
| 31762 | .extra_temps = .{ | 44784 | .extra_temps = .{ |
| 31763 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44785 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31764 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 44786 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31765 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44787 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31766 | .unused, | 44788 | .unused, |
| 31767 | .unused, | 44789 | .unused, |
| 31768 | .unused, | 44790 | .unused, |
| ... | @@ -31776,21 +44798,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31776,21 +44798,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31776 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44798 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31777 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 44799 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31778 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 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 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 44802 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31781 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44803 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31782 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44804 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31783 | } }, | 44805 | } }, |
| 31784 | }, .{ | 44806 | }, .{ |
| 31785 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 44807 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 31786 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, | 44808 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 31787 | .patterns = &.{ | 44809 | .patterns = &.{ |
| 31788 | .{ .src = .{ .to_mem, .none } }, | 44810 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31789 | }, | 44811 | }, |
| 31790 | .extra_temps = .{ | 44812 | .extra_temps = .{ |
| 31791 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31792 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 44814 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31793 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, | 44815 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 31794 | .unused, | 44816 | .unused, |
| 31795 | .unused, | 44817 | .unused, |
| 31796 | .unused, | 44818 | .unused, |
| ... | @@ -31806,23 +44828,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31806,23 +44828,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31806 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 44828 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 31807 | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44829 | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| 31808 | .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 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 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 44832 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31811 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44833 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31812 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44834 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31813 | } }, | 44835 | } }, |
| 31814 | }, .{ | 44836 | }, .{ |
| 31815 | .required_features = .{ .bmi2, null, null, null }, | 44837 | .required_features = .{ .bmi2, null, null, null }, |
| 31816 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 44838 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 31817 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44839 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31818 | .patterns = &.{ | 44840 | .patterns = &.{ |
| 31819 | .{ .src = .{ .to_mem, .none } }, | 44841 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31820 | }, | 44842 | }, |
| 31821 | .extra_temps = .{ | 44843 | .extra_temps = .{ |
| 31822 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44844 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31823 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 44845 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31824 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 44846 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 31825 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44847 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31826 | .unused, | 44848 | .unused, |
| 31827 | .unused, | 44849 | .unused, |
| 31828 | .unused, | 44850 | .unused, |
| ... | @@ -31836,22 +44858,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31836,22 +44858,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31836 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 44858 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31837 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, | 44859 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 31838 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, | 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 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 44862 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31841 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44863 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44864 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31843 | } }, | 44865 | } }, |
| 31844 | }, .{ | 44866 | }, .{ |
| 31845 | .required_features = .{ .fast_imm16, null, null, null }, | 44867 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 31846 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 44868 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 31847 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | | |
| 31848 | .patterns = &.{ | 44869 | .patterns = &.{ |
| 31849 | .{ .src = .{ .to_mem, .none } }, | 44870 | .{ .src = .{ .to_mem, .none, .none } }, |
| 31850 | }, | 44871 | }, |
| 31851 | .extra_temps = .{ | 44872 | .extra_temps = .{ |
| 31852 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44873 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 31853 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 44874 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31854 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44875 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 31855 | .unused, | 44876 | .unused, |
| 31856 | .unused, | 44877 | .unused, |
| 31857 | .unused, | 44878 | .unused, |
| ... | @@ -31865,22 +44886,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31865,22 +44886,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31865 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 44886 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 31866 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 44887 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 31867 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 44888 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, |
| 31868 | .{ ._, ._, .@"and", .tmp2w, .sa(.dst0, .add_umax), ._, ._ }, | 44889 | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, |
| 31869 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, | 44890 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 31870 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 44891 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| 31871 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 44892 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 31872 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 44893 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 31873 | } }, | 44894 | } }, |
| 31874 | }, .{ | 44895 | }, .{ |
| 31875 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 44896 | .required_features = .{ .avx, null, null, null }, |
| 31876 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, | 44897 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 44898 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 31877 | .patterns = &.{ | 44899 | .patterns = &.{ |
| 31878 | .{ .src = .{ .to_mem, .none } }, | 44900 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31879 | }, | 44901 | }, |
| 31880 | .extra_temps = .{ | 44902 | .extra_temps = .{ |
| 31881 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 44903 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 31882 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 44904 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 31883 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, | 44905 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 31884 | .unused, | 44906 | .unused, |
| 31885 | .unused, | 44907 | .unused, |
| 31886 | .unused, | 44908 | .unused, |
| ... | @@ -31888,36 +44910,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31888,36 +44910,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31888 | .unused, | 44910 | .unused, |
| 31889 | .unused, | 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 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 44913 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 31911 | .each = .{ .once = &.{ | 44914 | .each = .{ .once = &.{ |
| 31912 | .{ ._, .vp_d, .sll, .dst0x, .src0x, .uia(32, .dst0, .sub_bit_size), ._ }, | 44915 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31913 | .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ }, | 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 | .required_features = .{ .avx, null, null, null }, | 44922 | .required_features = .{ .avx, null, null, null }, |
| 31917 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, | 44923 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31918 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, | 44924 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 31919 | .patterns = &.{ | 44925 | .patterns = &.{ |
| 31920 | .{ .src = .{ .to_sse, .none } }, | 44926 | .{ .src = .{ .to_sse, .none, .none } }, |
| 31921 | }, | 44927 | }, |
| 31922 | .extra_temps = .{ | 44928 | .extra_temps = .{ |
| 31923 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 44929 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -31937,22 +44943,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31937,22 +44943,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31937 | } }, | 44943 | } }, |
| 31938 | }, .{ | 44944 | }, .{ |
| 31939 | .required_features = .{ .sse2, null, null, null }, | 44945 | .required_features = .{ .sse2, null, null, null }, |
| 31940 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, | 44946 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31941 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 44947 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 31942 | .patterns = &.{ | 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 | .dst_temps = .{.{ .ref = .src0 }}, | 44962 | .dst_temps = .{.{ .ref = .src0 }}, |
| 31946 | .each = .{ .once = &.{ | 44963 | .each = .{ .once = &.{ |
| 31947 | .{ ._, .p_d, .sll, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 44964 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 31948 | .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 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 | .required_features = .{ .sse2, null, null, null }, | 44971 | .required_features = .{ .sse2, null, null, null }, |
| 31952 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, | 44972 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31953 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, | 44973 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 31954 | .patterns = &.{ | 44974 | .patterns = &.{ |
| 31955 | .{ .src = .{ .to_mut_sse, .none } }, | 44975 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 31956 | }, | 44976 | }, |
| 31957 | .extra_temps = .{ | 44977 | .extra_temps = .{ |
| 31958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 44978 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -31972,10 +44992,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31972,10 +44992,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31972 | } }, | 44992 | } }, |
| 31973 | }, .{ | 44993 | }, .{ |
| 31974 | .required_features = .{ .sse, null, null, null }, | 44994 | .required_features = .{ .sse, null, null, null }, |
| 31975 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, | 44995 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 31976 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, | 44996 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 31977 | .patterns = &.{ | 44997 | .patterns = &.{ |
| 31978 | .{ .src = .{ .to_mut_sse, .none } }, | 44998 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 31979 | }, | 44999 | }, |
| 31980 | .extra_temps = .{ | 45000 | .extra_temps = .{ |
| 31981 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 45001 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -31995,22 +45015,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -31995,22 +45015,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 31995 | } }, | 45015 | } }, |
| 31996 | }, .{ | 45016 | }, .{ |
| 31997 | .required_features = .{ .avx2, null, null, null }, | 45017 | .required_features = .{ .avx2, null, null, null }, |
| 31998 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any }, | 45018 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 31999 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }}, | 45019 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 32000 | .patterns = &.{ | 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 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 45034 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 32004 | .each = .{ .once = &.{ | 45035 | .each = .{ .once = &.{ |
| 32005 | .{ ._, .vp_d, .sll, .dst0y, .src0y, .uia(32, .dst0, .sub_bit_size), ._ }, | 45036 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 32006 | .{ ._, .vp_d, .sra, .dst0y, .dst0y, .uia(32, .dst0, .sub_bit_size), ._ }, | 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 | .required_features = .{ .avx2, null, null, null }, | 45043 | .required_features = .{ .avx2, null, null, null }, |
| 32010 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any }, | 45044 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 32011 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, | 45045 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, |
| 32012 | .patterns = &.{ | 45046 | .patterns = &.{ |
| 32013 | .{ .src = .{ .to_sse, .none } }, | 45047 | .{ .src = .{ .to_sse, .none, .none } }, |
| 32014 | }, | 45048 | }, |
| 32015 | .extra_temps = .{ | 45049 | .extra_temps = .{ |
| 32016 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 45050 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -32030,18 +45064,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32030,18 +45064,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32030 | } }, | 45064 | } }, |
| 32031 | }, .{ | 45065 | }, .{ |
| 32032 | .required_features = .{ .avx2, null, null, null }, | 45066 | .required_features = .{ .avx2, null, null, null }, |
| 32033 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any }, | 45067 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 32034 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }}, | 45068 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, |
| 32035 | .patterns = &.{ | 45069 | .patterns = &.{ |
| 32036 | .{ .src = .{ .to_mem, .none } }, | 45070 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32037 | }, | 45071 | }, |
| 32038 | .extra_temps = .{ | 45072 | .extra_temps = .{ |
| 32039 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32040 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, | 45074 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 32041 | .unused, | 45075 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 32042 | .unused, | 45076 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| 32043 | .unused, | 45077 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32044 | .unused, | 45078 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32045 | .unused, | 45079 | .unused, |
| 32046 | .unused, | 45080 | .unused, |
| 32047 | .unused, | 45081 | .unused, |
| ... | @@ -32049,25 +45083,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32049,25 +45083,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32049 | .dst_temps = .{.mem}, | 45083 | .dst_temps = .{.mem}, |
| 32050 | .clobbers = .{ .eflags = true }, | 45084 | .clobbers = .{ .eflags = true }, |
| 32051 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45090 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32053 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 45091 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| 32054 | .{ ._, .vp_d, .sll, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, | 45092 | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 32055 | .{ ._, .vp_d, .sra, .tmp1y, .tmp1y, .uia(16, .dst0, .sub_bit_size), ._ }, | 45093 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| 32056 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, | 45094 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 32057 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 45095 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 32058 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45096 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32059 | } }, | 45097 | } }, |
| 32060 | }, .{ | 45098 | }, .{ |
| 32061 | .required_features = .{ .avx2, null, null, null }, | 45099 | .required_features = .{ .avx2, null, null, null }, |
| 32062 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, .any }, | 45100 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 32063 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }}, | 45101 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, |
| 32064 | .patterns = &.{ | 45102 | .patterns = &.{ |
| 32065 | .{ .src = .{ .to_mem, .none } }, | 45103 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32066 | }, | 45104 | }, |
| 32067 | .extra_temps = .{ | 45105 | .extra_temps = .{ |
| 32068 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45106 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32069 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, | 45107 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 32070 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, | 45108 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 32071 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 45109 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32072 | .unused, | 45110 | .unused, |
| 32073 | .unused, | 45111 | .unused, |
| ... | @@ -32088,18 +45126,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32088,18 +45126,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32088 | } }, | 45126 | } }, |
| 32089 | }, .{ | 45127 | }, .{ |
| 32090 | .required_features = .{ .avx, null, null, null }, | 45128 | .required_features = .{ .avx, null, null, null }, |
| 32091 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, | 45129 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 32092 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 45130 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32093 | .patterns = &.{ | 45131 | .patterns = &.{ |
| 32094 | .{ .src = .{ .to_mem, .none } }, | 45132 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32095 | }, | 45133 | }, |
| 32096 | .extra_temps = .{ | 45134 | .extra_temps = .{ |
| 32097 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45135 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32098 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 45136 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 32099 | .unused, | 45137 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 32100 | .unused, | 45138 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 32101 | .unused, | 45139 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32102 | .unused, | 45140 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32103 | .unused, | 45141 | .unused, |
| 32104 | .unused, | 45142 | .unused, |
| 32105 | .unused, | 45143 | .unused, |
| ... | @@ -32107,25 +45145,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32107,25 +45145,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32107 | .dst_temps = .{.mem}, | 45145 | .dst_temps = .{.mem}, |
| 32108 | .clobbers = .{ .eflags = true }, | 45146 | .clobbers = .{ .eflags = true }, |
| 32109 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45152 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32111 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 45153 | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| 32112 | .{ ._, .vp_d, .sll, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, | 45154 | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 32113 | .{ ._, .vp_d, .sra, .tmp1x, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._ }, | 45155 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 32114 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 45156 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 32115 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 45157 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32116 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45158 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32117 | } }, | 45159 | } }, |
| 32118 | }, .{ | 45160 | }, .{ |
| 32119 | .required_features = .{ .avx, null, null, null }, | 45161 | .required_features = .{ .avx, null, null, null }, |
| 32120 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, | 45162 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 32121 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, | 45163 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32122 | .patterns = &.{ | 45164 | .patterns = &.{ |
| 32123 | .{ .src = .{ .to_mem, .none } }, | 45165 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32124 | }, | 45166 | }, |
| 32125 | .extra_temps = .{ | 45167 | .extra_temps = .{ |
| 32126 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45168 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32127 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 45169 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32128 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 45170 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32129 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 45171 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32130 | .unused, | 45172 | .unused, |
| 32131 | .unused, | 45173 | .unused, |
| ... | @@ -32146,18 +45188,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32146,18 +45188,18 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32146 | } }, | 45188 | } }, |
| 32147 | }, .{ | 45189 | }, .{ |
| 32148 | .required_features = .{ .sse2, null, null, null }, | 45190 | .required_features = .{ .sse2, null, null, null }, |
| 32149 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any }, | 45191 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 32150 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, | 45192 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32151 | .patterns = &.{ | 45193 | .patterns = &.{ |
| 32152 | .{ .src = .{ .to_mem, .none } }, | 45194 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32153 | }, | 45195 | }, |
| 32154 | .extra_temps = .{ | 45196 | .extra_temps = .{ |
| 32155 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45197 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32156 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, | 45198 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 32157 | .unused, | 45199 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 32158 | .unused, | 45200 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 32159 | .unused, | 45201 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32160 | .unused, | 45202 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, |
| 32161 | .unused, | 45203 | .unused, |
| 32162 | .unused, | 45204 | .unused, |
| 32163 | .unused, | 45205 | .unused, |
| ... | @@ -32165,25 +45207,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32165,25 +45207,30 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32165 | .dst_temps = .{.mem}, | 45207 | .dst_temps = .{.mem}, |
| 32166 | .clobbers = .{ .eflags = true }, | 45208 | .clobbers = .{ .eflags = true }, |
| 32167 | .each = .{ .once = &.{ | 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 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45214 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32169 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 45215 | .{ .@"0:", ._dqa, .mov, .tmp3x, .tmp1x, ._, ._ }, |
| 32170 | .{ ._, .p_d, .sll, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, | 45216 | .{ ._, .p_, .@"and", .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32171 | .{ ._, .p_d, .sra, .tmp1x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, | 45217 | .{ ._, .p_q, .add, .tmp3x, .tmp2x, ._, ._ }, |
| 32172 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, | 45218 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| | 45219 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 32173 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 45220 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 32174 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45221 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32175 | } }, | 45222 | } }, |
| 32176 | }, .{ | 45223 | }, .{ |
| 32177 | .required_features = .{ .sse2, null, null, null }, | 45224 | .required_features = .{ .sse2, null, null, null }, |
| 32178 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, | 45225 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 32179 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, | 45226 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32180 | .patterns = &.{ | 45227 | .patterns = &.{ |
| 32181 | .{ .src = .{ .to_mem, .none } }, | 45228 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32182 | }, | 45229 | }, |
| 32183 | .extra_temps = .{ | 45230 | .extra_temps = .{ |
| 32184 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45231 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32185 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 45232 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32186 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 45233 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32187 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 45234 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32188 | .unused, | 45235 | .unused, |
| 32189 | .unused, | 45236 | .unused, |
| ... | @@ -32205,15 +45252,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32205,15 +45252,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32205 | } }, | 45252 | } }, |
| 32206 | }, .{ | 45253 | }, .{ |
| 32207 | .required_features = .{ .sse, null, null, null }, | 45254 | .required_features = .{ .sse, null, null, null }, |
| 32208 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, .any }, | 45255 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 32209 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }}, | 45256 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32210 | .patterns = &.{ | 45257 | .patterns = &.{ |
| 32211 | .{ .src = .{ .to_mem, .none } }, | 45258 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32212 | }, | 45259 | }, |
| 32213 | .extra_temps = .{ | 45260 | .extra_temps = .{ |
| 32214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32215 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 45262 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32216 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 45263 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 32217 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 45264 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, |
| 32218 | .unused, | 45265 | .unused, |
| 32219 | .unused, | 45266 | .unused, |
| ... | @@ -32234,14 +45281,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32234,14 +45281,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32234 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45281 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32235 | } }, | 45282 | } }, |
| 32236 | }, .{ | 45283 | }, .{ |
| 32237 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any }, | 45284 | .required_features = .{ .@"64bit", null, null, null }, |
| 32238 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, | 45285 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| | 45286 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32239 | .patterns = &.{ | 45287 | .patterns = &.{ |
| 32240 | .{ .src = .{ .to_mem, .none } }, | 45288 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32241 | }, | 45289 | }, |
| 32242 | .extra_temps = .{ | 45290 | .extra_temps = .{ |
| 32243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45291 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32244 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45292 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32245 | .unused, | 45293 | .unused, |
| 32246 | .unused, | 45294 | .unused, |
| 32247 | .unused, | 45295 | .unused, |
| ... | @@ -32254,20 +45302,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32254,20 +45302,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32254 | .clobbers = .{ .eflags = true }, | 45302 | .clobbers = .{ .eflags = true }, |
| 32255 | .each = .{ .once = &.{ | 45303 | .each = .{ .once = &.{ |
| 32256 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45304 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32257 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 45305 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32258 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45306 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32259 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45307 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32260 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45308 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32261 | } }, | 45309 | } }, |
| 32262 | }, .{ | 45310 | }, .{ |
| 32263 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any }, | 45311 | .required_features = .{ .@"64bit", null, null, null }, |
| 32264 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 45314 | .patterns = &.{ |
| 32266 | .{ .src = .{ .to_mem, .none } }, | 45315 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32267 | }, | 45316 | }, |
| 32268 | .extra_temps = .{ | 45317 | .extra_temps = .{ |
| 32269 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32270 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 45319 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 32271 | .unused, | 45320 | .unused, |
| 32272 | .unused, | 45321 | .unused, |
| 32273 | .unused, | 45322 | .unused, |
| ... | @@ -32280,24 +45329,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32280,24 +45329,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32280 | .clobbers = .{ .eflags = true }, | 45329 | .clobbers = .{ .eflags = true }, |
| 32281 | .each = .{ .once = &.{ | 45330 | .each = .{ .once = &.{ |
| 32282 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45331 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32283 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 45332 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32284 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45333 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32285 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45334 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32286 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45335 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32287 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45336 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32288 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45337 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32289 | } }, | 45338 | } }, |
| 32290 | }, .{ | 45339 | }, .{ |
| 32291 | .required_features = .{ .bmi2, null, null, null }, | 45340 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 32292 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 45341 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 32293 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45342 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32294 | .patterns = &.{ | 45343 | .patterns = &.{ |
| 32295 | .{ .src = .{ .to_mem, .none } }, | 45344 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32296 | }, | 45345 | }, |
| 32297 | .extra_temps = .{ | 45346 | .extra_temps = .{ |
| 32298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45347 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32299 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 45348 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32300 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45349 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32301 | .unused, | 45350 | .unused, |
| 32302 | .unused, | 45351 | .unused, |
| 32303 | .unused, | 45352 | .unused, |
| ... | @@ -32310,20 +45359,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32310,20 +45359,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32310 | .each = .{ .once = &.{ | 45359 | .each = .{ .once = &.{ |
| 32311 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45360 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32312 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 45361 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32313 | .{ .@"0:", ._, .bzhi, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 45362 | .{ .@"0:", ._, .bzhi, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 32314 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45363 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 32315 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45364 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32316 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45365 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32317 | } }, | 45366 | } }, |
| 32318 | }, .{ | 45367 | }, .{ |
| 32319 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any }, | 45368 | .required_features = .{ .@"64bit", null, null, null }, |
| 32320 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 45371 | .patterns = &.{ |
| 32322 | .{ .src = .{ .to_mem, .none } }, | 45372 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32323 | }, | 45373 | }, |
| 32324 | .extra_temps = .{ | 45374 | .extra_temps = .{ |
| 32325 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45375 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32326 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45376 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32327 | .unused, | 45377 | .unused, |
| 32328 | .unused, | 45378 | .unused, |
| 32329 | .unused, | 45379 | .unused, |
| ... | @@ -32336,21 +45386,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32336,21 +45386,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32336 | .clobbers = .{ .eflags = true }, | 45386 | .clobbers = .{ .eflags = true }, |
| 32337 | .each = .{ .once = &.{ | 45387 | .each = .{ .once = &.{ |
| 32338 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45388 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32339 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 45389 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 32340 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 45390 | .{ ._, ._, .@"and", .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 32341 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45391 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32342 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45392 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32343 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45393 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32344 | } }, | 45394 | } }, |
| 32345 | }, .{ | 45395 | }, .{ |
| 32346 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 45396 | .required_features = .{ .@"64bit", null, null, null }, |
| 32347 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, | 45397 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 45398 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32348 | .patterns = &.{ | 45399 | .patterns = &.{ |
| 32349 | .{ .src = .{ .to_mem, .none } }, | 45400 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32350 | }, | 45401 | }, |
| 32351 | .extra_temps = .{ | 45402 | .extra_temps = .{ |
| 32352 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45403 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32353 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45404 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32354 | .unused, | 45405 | .unused, |
| 32355 | .unused, | 45406 | .unused, |
| 32356 | .unused, | 45407 | .unused, |
| ... | @@ -32363,20 +45414,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32363,20 +45414,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32363 | .clobbers = .{ .eflags = true }, | 45414 | .clobbers = .{ .eflags = true }, |
| 32364 | .each = .{ .once = &.{ | 45415 | .each = .{ .once = &.{ |
| 32365 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45416 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32366 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 45417 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32367 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45418 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32368 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45419 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32369 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45420 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32370 | } }, | 45421 | } }, |
| 32371 | }, .{ | 45422 | }, .{ |
| 32372 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, | 45423 | .required_features = .{ .@"64bit", null, null, null }, |
| 32373 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 45426 | .patterns = &.{ |
| 32375 | .{ .src = .{ .to_mem, .none } }, | 45427 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32376 | }, | 45428 | }, |
| 32377 | .extra_temps = .{ | 45429 | .extra_temps = .{ |
| 32378 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45430 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32379 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 45431 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 32380 | .unused, | 45432 | .unused, |
| 32381 | .unused, | 45433 | .unused, |
| 32382 | .unused, | 45434 | .unused, |
| ... | @@ -32389,24 +45441,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32389,24 +45441,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32389 | .clobbers = .{ .eflags = true }, | 45441 | .clobbers = .{ .eflags = true }, |
| 32390 | .each = .{ .once = &.{ | 45442 | .each = .{ .once = &.{ |
| 32391 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45443 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32392 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 45444 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32393 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45445 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32394 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45446 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32395 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45447 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32396 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45448 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32397 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45449 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32398 | } }, | 45450 | } }, |
| 32399 | }, .{ | 45451 | }, .{ |
| 32400 | .required_features = .{ .bmi2, null, null, null }, | 45452 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 32401 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 45453 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 32402 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45454 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32403 | .patterns = &.{ | 45455 | .patterns = &.{ |
| 32404 | .{ .src = .{ .to_mem, .none } }, | 45456 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32405 | }, | 45457 | }, |
| 32406 | .extra_temps = .{ | 45458 | .extra_temps = .{ |
| 32407 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45459 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32408 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 45460 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32409 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45461 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32410 | .unused, | 45462 | .unused, |
| 32411 | .unused, | 45463 | .unused, |
| 32412 | .unused, | 45464 | .unused, |
| ... | @@ -32419,20 +45471,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32419,20 +45471,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32419 | .each = .{ .once = &.{ | 45471 | .each = .{ .once = &.{ |
| 32420 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45472 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32421 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 45473 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32422 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 45474 | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 32423 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45475 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 32424 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45476 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32425 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45477 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32426 | } }, | 45478 | } }, |
| 32427 | }, .{ | 45479 | }, .{ |
| 32428 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 45480 | .required_features = .{ .@"64bit", null, null, null }, |
| 32429 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 45483 | .patterns = &.{ |
| 32431 | .{ .src = .{ .to_mem, .none } }, | 45484 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32432 | }, | 45485 | }, |
| 32433 | .extra_temps = .{ | 45486 | .extra_temps = .{ |
| 32434 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45487 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32435 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45488 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32436 | .unused, | 45489 | .unused, |
| 32437 | .unused, | 45490 | .unused, |
| 32438 | .unused, | 45491 | .unused, |
| ... | @@ -32445,21 +45498,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32445,21 +45498,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32445 | .clobbers = .{ .eflags = true }, | 45498 | .clobbers = .{ .eflags = true }, |
| 32446 | .each = .{ .once = &.{ | 45499 | .each = .{ .once = &.{ |
| 32447 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45500 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32448 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 45501 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, |
| 32449 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 45502 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32450 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45503 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32451 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45504 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32452 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45505 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32453 | } }, | 45506 | } }, |
| 32454 | }, .{ | 45507 | }, .{ |
| 32455 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, | 45508 | .required_features = .{ .@"64bit", null, null, null }, |
| 32456 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, | 45509 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 45510 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, |
| 32457 | .patterns = &.{ | 45511 | .patterns = &.{ |
| 32458 | .{ .src = .{ .to_mem, .none } }, | 45512 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32459 | }, | 45513 | }, |
| 32460 | .extra_temps = .{ | 45514 | .extra_temps = .{ |
| 32461 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45515 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32462 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45516 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32463 | .unused, | 45517 | .unused, |
| 32464 | .unused, | 45518 | .unused, |
| 32465 | .unused, | 45519 | .unused, |
| ... | @@ -32472,20 +45526,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32472,20 +45526,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32472 | .clobbers = .{ .eflags = true }, | 45526 | .clobbers = .{ .eflags = true }, |
| 32473 | .each = .{ .once = &.{ | 45527 | .each = .{ .once = &.{ |
| 32474 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45528 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32475 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 45529 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32476 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45530 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32477 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45531 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32478 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45532 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32479 | } }, | 45533 | } }, |
| 32480 | }, .{ | 45534 | }, .{ |
| 32481 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, | 45535 | .required_features = .{ .@"64bit", null, null, null }, |
| 32482 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 45538 | .patterns = &.{ |
| 32484 | .{ .src = .{ .to_mem, .none } }, | 45539 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32485 | }, | 45540 | }, |
| 32486 | .extra_temps = .{ | 45541 | .extra_temps = .{ |
| 32487 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45542 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32488 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 45543 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 32489 | .unused, | 45544 | .unused, |
| 32490 | .unused, | 45545 | .unused, |
| 32491 | .unused, | 45546 | .unused, |
| ... | @@ -32498,24 +45553,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32498,24 +45553,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32498 | .clobbers = .{ .eflags = true }, | 45553 | .clobbers = .{ .eflags = true }, |
| 32499 | .each = .{ .once = &.{ | 45554 | .each = .{ .once = &.{ |
| 32500 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45555 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32501 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 45556 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 32502 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45557 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32503 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45558 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32504 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45559 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 32505 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45560 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32506 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45561 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32507 | } }, | 45562 | } }, |
| 32508 | }, .{ | 45563 | }, .{ |
| 32509 | .required_features = .{ .bmi2, null, null, null }, | 45564 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 32510 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, | 45565 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| 32511 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45566 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32512 | .patterns = &.{ | 45567 | .patterns = &.{ |
| 32513 | .{ .src = .{ .to_mem, .none } }, | 45568 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32514 | }, | 45569 | }, |
| 32515 | .extra_temps = .{ | 45570 | .extra_temps = .{ |
| 32516 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45571 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32517 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 45572 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32518 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45573 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32519 | .unused, | 45574 | .unused, |
| 32520 | .unused, | 45575 | .unused, |
| 32521 | .unused, | 45576 | .unused, |
| ... | @@ -32528,25 +45583,83 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32528,25 +45583,83 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32528 | .each = .{ .once = &.{ | 45583 | .each = .{ .once = &.{ |
| 32529 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45584 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32530 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 45585 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32531 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 45586 | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._ }, |
| 32532 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45587 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 32533 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45588 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32534 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45589 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32535 | } }, | 45590 | } }, |
| 32536 | }, .{ | 45591 | }, .{ |
| 32537 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, | 45592 | .required_features = .{ .@"64bit", null, null, null }, |
| 32538 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 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 | .patterns = &.{ | 45623 | .patterns = &.{ |
| 32540 | .{ .src = .{ .to_mem, .none } }, | 45624 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32541 | }, | 45625 | }, |
| 32542 | .extra_temps = .{ | 45626 | .extra_temps = .{ |
| 32543 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45627 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32544 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45628 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 45629 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 45630 | .unused, |
| 32545 | .unused, | 45631 | .unused, |
| 32546 | .unused, | 45632 | .unused, |
| 32547 | .unused, | 45633 | .unused, |
| 32548 | .unused, | 45634 | .unused, |
| 32549 | .unused, | 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 | .unused, | 45663 | .unused, |
| 32551 | .unused, | 45664 | .unused, |
| 32552 | }, | 45665 | }, |
| ... | @@ -32554,23 +45667,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32554,23 +45667,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32554 | .clobbers = .{ .eflags = true }, | 45667 | .clobbers = .{ .eflags = true }, |
| 32555 | .each = .{ .once = &.{ | 45668 | .each = .{ .once = &.{ |
| 32556 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45669 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32557 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, | 45670 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32558 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 45671 | .{ .@"0:", ._, .mov, .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 32559 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45672 | .{ ._, ._l, .sa, .tmp2q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| 32560 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32562 | } }, | 45678 | } }, |
| 32563 | }, .{ | 45679 | }, .{ |
| 32564 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any }, | 45680 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 32565 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, | 45681 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| | 45682 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32566 | .patterns = &.{ | 45683 | .patterns = &.{ |
| 32567 | .{ .src = .{ .to_mem, .none } }, | 45684 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32568 | }, | 45685 | }, |
| 32569 | .extra_temps = .{ | 45686 | .extra_temps = .{ |
| 32570 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45687 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32571 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45688 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32572 | .unused, | 45689 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32573 | .unused, | 45690 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32574 | .unused, | 45691 | .unused, |
| 32575 | .unused, | 45692 | .unused, |
| 32576 | .unused, | 45693 | .unused, |
| ... | @@ -32581,21 +45698,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32581,21 +45698,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32581 | .clobbers = .{ .eflags = true }, | 45698 | .clobbers = .{ .eflags = true }, |
| 32582 | .each = .{ .once = &.{ | 45699 | .each = .{ .once = &.{ |
| 32583 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45700 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32584 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 45701 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32585 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45702 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, |
| 32586 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45707 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32588 | } }, | 45708 | } }, |
| 32589 | }, .{ | 45709 | }, .{ |
| 32590 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any }, | 45710 | .required_features = .{ .@"64bit", null, null, null }, |
| 32591 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 45711 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| | 45712 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 32592 | .patterns = &.{ | 45713 | .patterns = &.{ |
| 32593 | .{ .src = .{ .to_mem, .none } }, | 45714 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32594 | }, | 45715 | }, |
| 32595 | .extra_temps = .{ | 45716 | .extra_temps = .{ |
| 32596 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 45717 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 32597 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 45718 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32598 | .unused, | 45719 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 32599 | .unused, | 45720 | .unused, |
| 32600 | .unused, | 45721 | .unused, |
| 32601 | .unused, | 45722 | .unused, |
| ... | @@ -32607,25 +45728,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32607,25 +45728,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32607 | .clobbers = .{ .eflags = true }, | 45728 | .clobbers = .{ .eflags = true }, |
| 32608 | .each = .{ .once = &.{ | 45729 | .each = .{ .once = &.{ |
| 32609 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45730 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 32610 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 45731 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 32611 | .{ ._, ._l, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45732 | .{ .@"0:", ._, .mov, .tmp2q, .ua(.dst0, .add_umax), ._, ._ }, |
| 32612 | .{ ._, ._r, .sa, .tmp1d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45733 | .{ ._, ._, .@"and", .tmp2q, .memi(.src0q, .tmp1), ._, ._ }, |
| 32613 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45734 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 32614 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45735 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, |
| | 45736 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 32615 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 45737 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 32616 | } }, | 45738 | } }, |
| 32617 | }, .{ | 45739 | }, .{ |
| 32618 | .required_features = .{ .bmi2, null, null, null }, | 45740 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 32619 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, | 45741 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| 32620 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45742 | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 32621 | .patterns = &.{ | 45743 | .patterns = &.{ |
| 32622 | .{ .src = .{ .to_mem, .none } }, | 45744 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32623 | }, | 45745 | }, |
| 32624 | .extra_temps = .{ | 45746 | .extra_temps = .{ |
| 32625 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 32626 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | | |
| 32627 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 45751 | .unused, |
| 32630 | .unused, | 45752 | .unused, |
| 32631 | .unused, | 45753 | .unused, |
| ... | @@ -32635,24 +45757,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32635,24 +45757,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32635 | .dst_temps = .{.mem}, | 45757 | .dst_temps = .{.mem}, |
| 32636 | .clobbers = .{ .eflags = true }, | 45758 | .clobbers = .{ .eflags = true }, |
| 32637 | .each = .{ .once = &.{ | 45759 | .each = .{ .once = &.{ |
| 32638 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45760 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32639 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 45761 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32640 | .{ .@"0:", ._, .bzhi, .tmp2d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), .tmp1d, ._ }, | 45762 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32641 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45763 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 32642 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45764 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32643 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 45770 | .required_features = .{ .@"64bit", null, null, null }, |
| 32647 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45771 | .src_constraints = .{ .any_scalar_int, .any, .any }, |
| | 45772 | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, |
| 32648 | .patterns = &.{ | 45773 | .patterns = &.{ |
| 32649 | .{ .src = .{ .to_mem, .none } }, | 45774 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32650 | }, | 45775 | }, |
| 32651 | .extra_temps = .{ | 45776 | .extra_temps = .{ |
| 32652 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 32653 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45777 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32654 | .unused, | 45778 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32655 | .unused, | 45779 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 45780 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32656 | .unused, | 45781 | .unused, |
| 32657 | .unused, | 45782 | .unused, |
| 32658 | .unused, | 45783 | .unused, |
| ... | @@ -32662,24 +45787,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32662,24 +45787,27 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32662 | .dst_temps = .{.mem}, | 45787 | .dst_temps = .{.mem}, |
| 32663 | .clobbers = .{ .eflags = true }, | 45788 | .clobbers = .{ .eflags = true }, |
| 32664 | .each = .{ .once = &.{ | 45789 | .each = .{ .once = &.{ |
| 32665 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45790 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32666 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, | 45791 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32667 | .{ ._, ._, .@"and", .tmp1d, .sa(.dst0, .add_umax), ._, ._ }, | 45792 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32668 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, | 45793 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, |
| 32669 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45794 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32670 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 45800 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 32674 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .dword, .is = 32 } }}, | 45801 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| | 45802 | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32675 | .patterns = &.{ | 45803 | .patterns = &.{ |
| 32676 | .{ .src = .{ .to_mem, .none } }, | 45804 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32677 | }, | 45805 | }, |
| 32678 | .extra_temps = .{ | 45806 | .extra_temps = .{ |
| 32679 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 32680 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | | |
| 32681 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 45811 | .unused, |
| 32684 | .unused, | 45812 | .unused, |
| 32685 | .unused, | 45813 | .unused, |
| ... | @@ -32689,25 +45817,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32689,25 +45817,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32689 | .dst_temps = .{.mem}, | 45817 | .dst_temps = .{.mem}, |
| 32690 | .clobbers = .{ .eflags = true }, | 45818 | .clobbers = .{ .eflags = true }, |
| 32691 | .each = .{ .once = &.{ | 45819 | .each = .{ .once = &.{ |
| 32692 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45820 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32693 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 45821 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32694 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 45822 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32695 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45823 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 32696 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 45824 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32697 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45825 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 32698 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 45835 | .required_features = .{ .@"64bit", null, null, null }, |
| 32702 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, | 45836 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| | 45837 | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32703 | .patterns = &.{ | 45838 | .patterns = &.{ |
| 32704 | .{ .src = .{ .to_mem, .none } }, | 45839 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32705 | }, | 45840 | }, |
| 32706 | .extra_temps = .{ | 45841 | .extra_temps = .{ |
| 32707 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 32708 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45842 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32709 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, | 45843 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32710 | .unused, | 45844 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 45845 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32711 | .unused, | 45846 | .unused, |
| 32712 | .unused, | 45847 | .unused, |
| 32713 | .unused, | 45848 | .unused, |
| ... | @@ -32717,28 +45852,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32717,28 +45852,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32717 | .dst_temps = .{.mem}, | 45852 | .dst_temps = .{.mem}, |
| 32718 | .clobbers = .{ .eflags = true }, | 45853 | .clobbers = .{ .eflags = true }, |
| 32719 | .each = .{ .once = &.{ | 45854 | .each = .{ .once = &.{ |
| 32720 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45855 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32721 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 45856 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32722 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 45857 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32723 | .{ ._, ._l, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45858 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 32724 | .{ ._, ._r, .sa, .tmp2d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, | 45859 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32725 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45860 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 32726 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 45861 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 32727 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45862 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| 32728 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 45870 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 32732 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 45871 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 32733 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45872 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32734 | .patterns = &.{ | 45873 | .patterns = &.{ |
| 32735 | .{ .src = .{ .to_mem, .none } }, | 45874 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32736 | }, | 45875 | }, |
| 32737 | .extra_temps = .{ | 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 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 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 | .unused, | 45881 | .unused, |
| 32743 | .unused, | 45882 | .unused, |
| 32744 | .unused, | 45883 | .unused, |
| ... | @@ -32748,26 +45887,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32748,26 +45887,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32748 | .dst_temps = .{.mem}, | 45887 | .dst_temps = .{.mem}, |
| 32749 | .clobbers = .{ .eflags = true }, | 45888 | .clobbers = .{ .eflags = true }, |
| 32750 | .each = .{ .once = &.{ | 45889 | .each = .{ .once = &.{ |
| 32751 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45890 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32752 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 45891 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32753 | .{ ._, ._, .mov, .tmp2d, .sa(.dst0, .add_bit_size), ._, ._ }, | 45892 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32754 | .{ .@"0:", ._, .bzhi, .tmp3d, .memi(.src0d, .tmp1), .tmp2d, ._ }, | 45893 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 32755 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, | 45894 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32756 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 45895 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 32757 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45896 | .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 32758 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 45907 | .required_features = .{ .@"64bit", null, null, null }, |
| 32762 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 45908 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| | 45909 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, |
| 32763 | .patterns = &.{ | 45910 | .patterns = &.{ |
| 32764 | .{ .src = .{ .to_mem, .none } }, | 45911 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32765 | }, | 45912 | }, |
| 32766 | .extra_temps = .{ | 45913 | .extra_temps = .{ |
| 32767 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | | |
| 32768 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45914 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32769 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 45915 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32770 | .unused, | 45916 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 45917 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32771 | .unused, | 45918 | .unused, |
| 32772 | .unused, | 45919 | .unused, |
| 32773 | .unused, | 45920 | .unused, |
| ... | @@ -32777,199 +45924,304 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32777,199 +45924,304 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32777 | .dst_temps = .{.mem}, | 45924 | .dst_temps = .{.mem}, |
| 32778 | .clobbers = .{ .eflags = true }, | 45925 | .clobbers = .{ .eflags = true }, |
| 32779 | .each = .{ .once = &.{ | 45926 | .each = .{ .once = &.{ |
| 32780 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 45927 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32781 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 45928 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32782 | .{ .@"0:", ._, .mov, .tmp2d, .memi(.src0d, .tmp1), ._, ._ }, | 45929 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32783 | .{ ._, ._, .@"and", .tmp2d, .sa(.dst0, .add_umax), ._, ._ }, | 45930 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 32784 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, | 45931 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32785 | .{ ._, ._, .lea, .tmp1d, .leaa(.tmp1, .add_src0_elem_size), ._, ._ }, | 45932 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 32786 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, | 45933 | .{ ._, ._l, .sa, .tmp3q, .uia(64, .dst0, .sub_bit_size_rem_64), ._, ._ }, |
| 32787 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 45944 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 32791 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, | 45945 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 32792 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 45946 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 32793 | .patterns = &.{ | 45947 | .patterns = &.{ |
| 32794 | .{ .src = .{ .to_sse, .none } }, | 45948 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32795 | }, | 45949 | }, |
| 32796 | .extra_temps = .{ | 45950 | .extra_temps = .{ |
| 32797 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 45951 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32798 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 45952 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32799 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 45953 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32800 | .unused, | 45954 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32801 | .unused, | 45955 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32802 | .unused, | 45956 | .unused, |
| 32803 | .unused, | 45957 | .unused, |
| 32804 | .unused, | 45958 | .unused, |
| 32805 | .unused, | 45959 | .unused, |
| 32806 | }, | 45960 | }, |
| 32807 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 45961 | .dst_temps = .{.mem}, |
| | 45962 | .clobbers = .{ .eflags = true }, |
| 32808 | .each = .{ .once = &.{ | 45963 | .each = .{ .once = &.{ |
| 32809 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 45964 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32810 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, | 45965 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32811 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 45966 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32812 | .{ ._, .vp_q, .add, .dst0x, .dst0x, .lea(.tmp0x), ._ }, | 45967 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 32813 | .{ ._, .vp_, .xor, .dst0x, .dst0x, .lea(.tmp0x), ._ }, | 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 }, | 45978 | .required_features = .{ .@"64bit", null, null, null }, |
| 32817 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, | 45979 | .src_constraints = .{ .any_scalar_signed_int, .any, .any }, |
| 32818 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 45980 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 32819 | .patterns = &.{ | 45981 | .patterns = &.{ |
| 32820 | .{ .src = .{ .to_sse, .none } }, | 45982 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32821 | }, | 45983 | }, |
| 32822 | .extra_temps = .{ | 45984 | .extra_temps = .{ |
| 32823 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 45985 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32824 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 45986 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32825 | .unused, | 45987 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32826 | .unused, | 45988 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32827 | .unused, | 45989 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32828 | .unused, | 45990 | .unused, |
| 32829 | .unused, | 45991 | .unused, |
| 32830 | .unused, | 45992 | .unused, |
| 32831 | .unused, | 45993 | .unused, |
| 32832 | }, | 45994 | }, |
| 32833 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 45995 | .dst_temps = .{.mem}, |
| | 45996 | .clobbers = .{ .eflags = true }, |
| 32834 | .each = .{ .once = &.{ | 45997 | .each = .{ .once = &.{ |
| 32835 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 45998 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32836 | .{ ._, .vp_, .@"and", .dst0x, .src0x, .lea(.tmp0x), ._ }, | 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 }, | 46012 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 32840 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, | 46013 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32841 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 46014 | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32842 | .patterns = &.{ | 46015 | .patterns = &.{ |
| 32843 | .{ .src = .{ .to_mut_sse, .none } }, | 46016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32844 | }, | 46017 | }, |
| 32845 | .extra_temps = .{ | 46018 | .extra_temps = .{ |
| 32846 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 46019 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32847 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46020 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32848 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 46021 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32849 | .unused, | 46022 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32850 | .unused, | 46023 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32851 | .unused, | 46024 | .unused, |
| 32852 | .unused, | 46025 | .unused, |
| 32853 | .unused, | 46026 | .unused, |
| 32854 | .unused, | 46027 | .unused, |
| 32855 | }, | 46028 | }, |
| 32856 | .dst_temps = .{.{ .ref = .src0 }}, | 46029 | .dst_temps = .{.mem}, |
| | 46030 | .clobbers = .{ .eflags = true }, |
| 32857 | .each = .{ .once = &.{ | 46031 | .each = .{ .once = &.{ |
| 32858 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 46032 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32859 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 46033 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32860 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 46034 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32861 | .{ ._, .p_q, .add, .dst0x, .lea(.tmp0x), ._, ._ }, | 46035 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 32862 | .{ ._, .p_, .xor, .dst0x, .lea(.tmp0x), ._, ._ }, | 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 }, | 46044 | .required_features = .{ .@"64bit", null, null, null }, |
| 32866 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, | 46045 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32867 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 46046 | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32868 | .patterns = &.{ | 46047 | .patterns = &.{ |
| 32869 | .{ .src = .{ .to_mut_sse, .none } }, | 46048 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32870 | }, | 46049 | }, |
| 32871 | .extra_temps = .{ | 46050 | .extra_temps = .{ |
| 32872 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 46051 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32873 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 46052 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32874 | .unused, | 46053 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32875 | .unused, | 46054 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 32876 | .unused, | 46055 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32877 | .unused, | 46056 | .unused, |
| 32878 | .unused, | 46057 | .unused, |
| 32879 | .unused, | 46058 | .unused, |
| 32880 | .unused, | 46059 | .unused, |
| 32881 | }, | 46060 | }, |
| 32882 | .dst_temps = .{.{ .ref = .src0 }}, | 46061 | .dst_temps = .{.mem}, |
| | 46062 | .clobbers = .{ .eflags = true }, |
| 32883 | .each = .{ .once = &.{ | 46063 | .each = .{ .once = &.{ |
| 32884 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 46064 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32885 | .{ ._, .p_, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 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 }, | 46076 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| 32889 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, | 46077 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32890 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 46078 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32891 | .patterns = &.{ | 46079 | .patterns = &.{ |
| 32892 | .{ .src = .{ .to_mut_sse, .none } }, | 46080 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32893 | }, | 46081 | }, |
| 32894 | .extra_temps = .{ | 46082 | .extra_temps = .{ |
| 32895 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 46083 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32896 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 46084 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32897 | .unused, | 46085 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32898 | .unused, | 46086 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32899 | .unused, | 46087 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32900 | .unused, | 46088 | .unused, |
| 32901 | .unused, | 46089 | .unused, |
| 32902 | .unused, | 46090 | .unused, |
| 32903 | .unused, | 46091 | .unused, |
| 32904 | }, | 46092 | }, |
| 32905 | .dst_temps = .{.{ .ref = .src0 }}, | 46093 | .dst_temps = .{.mem}, |
| | 46094 | .clobbers = .{ .eflags = true }, |
| 32906 | .each = .{ .once = &.{ | 46095 | .each = .{ .once = &.{ |
| 32907 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 46096 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32908 | .{ ._, ._ps, .@"and", .dst0x, .lea(.tmp0x), ._, ._ }, | 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 }, | 46111 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| 32912 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any }, | 46112 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32913 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }}, | 46113 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32914 | .patterns = &.{ | 46114 | .patterns = &.{ |
| 32915 | .{ .src = .{ .to_sse, .none } }, | 46115 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32916 | }, | 46116 | }, |
| 32917 | .extra_temps = .{ | 46117 | .extra_temps = .{ |
| 32918 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 46118 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32919 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46119 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32920 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 46120 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32921 | .unused, | 46121 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 32922 | .unused, | 46122 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32923 | .unused, | 46123 | .unused, |
| 32924 | .unused, | 46124 | .unused, |
| 32925 | .unused, | 46125 | .unused, |
| 32926 | .unused, | 46126 | .unused, |
| 32927 | }, | 46127 | }, |
| 32928 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 46128 | .dst_temps = .{.mem}, |
| | 46129 | .clobbers = .{ .eflags = true }, |
| 32929 | .each = .{ .once = &.{ | 46130 | .each = .{ .once = &.{ |
| 32930 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 46131 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32931 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, | 46132 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32932 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 46133 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32933 | .{ ._, .vp_q, .add, .dst0y, .dst0y, .lea(.tmp0y), ._ }, | 46134 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, |
| 32934 | .{ ._, .vp_, .xor, .dst0y, .dst0y, .lea(.tmp0y), ._ }, | 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 }, | 46146 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| 32938 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any }, | 46147 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32939 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, | 46148 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 32940 | .patterns = &.{ | 46149 | .patterns = &.{ |
| 32941 | .{ .src = .{ .to_sse, .none } }, | 46150 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32942 | }, | 46151 | }, |
| 32943 | .extra_temps = .{ | 46152 | .extra_temps = .{ |
| 32944 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 46153 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32945 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0 } } }, | 46154 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32946 | .unused, | 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 | .unused, | 46159 | .unused, |
| 32948 | .unused, | 46160 | .unused, |
| 32949 | .unused, | 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 | .unused, | 46192 | .unused, |
| 32951 | .unused, | 46193 | .unused, |
| 32952 | .unused, | 46194 | .unused, |
| 32953 | }, | 46195 | }, |
| 32954 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, | 46196 | .dst_temps = .{.mem}, |
| | 46197 | .clobbers = .{ .eflags = true }, |
| 32955 | .each = .{ .once = &.{ | 46198 | .each = .{ .once = &.{ |
| 32956 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 46199 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32957 | .{ ._, .vp_, .@"and", .dst0y, .src0y, .lea(.tmp0y), ._ }, | 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 }, | 46212 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 32961 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, .any }, | 46213 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32962 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }}, | 46214 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32963 | .patterns = &.{ | 46215 | .patterns = &.{ |
| 32964 | .{ .src = .{ .to_mem, .none } }, | 46216 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32965 | }, | 46217 | }, |
| 32966 | .extra_temps = .{ | 46218 | .extra_temps = .{ |
| 32967 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46219 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 32968 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 46220 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 32969 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 46221 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 32970 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, | 46222 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 32971 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46223 | .unused, |
| 32972 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 46224 | .unused, |
| 32973 | .unused, | 46225 | .unused, |
| 32974 | .unused, | 46226 | .unused, |
| 32975 | .unused, | 46227 | .unused, |
| ... | @@ -32977,30 +46229,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32977,30 +46229,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32977 | .dst_temps = .{.mem}, | 46229 | .dst_temps = .{.mem}, |
| 32978 | .clobbers = .{ .eflags = true }, | 46230 | .clobbers = .{ .eflags = true }, |
| 32979 | .each = .{ .once = &.{ | 46231 | .each = .{ .once = &.{ |
| 32980 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, | 46232 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 32981 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, | 46233 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 32982 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, | 46234 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 32983 | .{ ._, .v_dqa, .mov, .tmp2y, .lea(.tmp0y), ._, ._ }, | 46235 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 32984 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46236 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 32985 | .{ .@"0:", .vp_, .@"and", .tmp3y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, | 46237 | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, |
| 32986 | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .tmp2y, ._ }, | 46238 | .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ }, |
| 32987 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, | 46239 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, |
| 32988 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, | 46240 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, |
| 32989 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 46241 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 32990 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 46247 | .required_features = .{ .@"64bit", null, null, null }, |
| 32994 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, .any }, | 46248 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 32995 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }}, | 46249 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, |
| 32996 | .patterns = &.{ | 46250 | .patterns = &.{ |
| 32997 | .{ .src = .{ .to_mem, .none } }, | 46251 | .{ .src = .{ .to_mem, .none, .none } }, |
| 32998 | }, | 46252 | }, |
| 32999 | .extra_temps = .{ | 46253 | .extra_temps = .{ |
| 33000 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46254 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33001 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 46255 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33002 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, | 46256 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33003 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46257 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33004 | .unused, | 46258 | .unused, |
| 33005 | .unused, | 46259 | .unused, |
| 33006 | .unused, | 46260 | .unused, |
| ... | @@ -33010,28 +46264,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33010,28 +46264,34 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33010 | .dst_temps = .{.mem}, | 46264 | .dst_temps = .{.mem}, |
| 33011 | .clobbers = .{ .eflags = true }, | 46265 | .clobbers = .{ .eflags = true }, |
| 33012 | .each = .{ .once = &.{ | 46266 | .each = .{ .once = &.{ |
| 33013 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | 46267 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33014 | .{ ._, .v_dqa, .mov, .tmp1y, .lea(.tmp0y), ._, ._ }, | 46268 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33015 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46269 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33016 | .{ .@"0:", .vp_, .@"and", .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, | 46270 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33017 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, | 46271 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33018 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, | 46272 | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, |
| 33019 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 46282 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| 33023 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, | 46283 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 33024 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | 46284 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 33025 | .patterns = &.{ | 46285 | .patterns = &.{ |
| 33026 | .{ .src = .{ .to_mem, .none } }, | 46286 | .{ .src = .{ .to_mem, .none, .none } }, |
| 33027 | }, | 46287 | }, |
| 33028 | .extra_temps = .{ | 46288 | .extra_temps = .{ |
| 33029 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46289 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33030 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 46290 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33031 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 46291 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33032 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 46292 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 33033 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46293 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33034 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 46294 | .unused, |
| 33035 | .unused, | 46295 | .unused, |
| 33036 | .unused, | 46296 | .unused, |
| 33037 | .unused, | 46297 | .unused, |
| ... | @@ -33039,31 +46299,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33039,31 +46299,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33039 | .dst_temps = .{.mem}, | 46299 | .dst_temps = .{.mem}, |
| 33040 | .clobbers = .{ .eflags = true }, | 46300 | .clobbers = .{ .eflags = true }, |
| 33041 | .each = .{ .once = &.{ | 46301 | .each = .{ .once = &.{ |
| 33042 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, | 46302 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33043 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, | 46303 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33044 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp5), ._, ._ }, | 46304 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33045 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, | 46305 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 33046 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46306 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33047 | .{ .@"0:", .vp_, .@"and", .tmp3x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, | 46307 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33048 | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .tmp2x, ._ }, | 46308 | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, |
| 33049 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, | 46309 | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, |
| 33050 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, | 46310 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, |
| 33051 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 46311 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, |
| 33052 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 46312 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 46313 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, |
| 33053 | } }, | 46314 | } }, |
| 33054 | }, .{ | 46315 | }, .{ |
| 33055 | .required_features = .{ .avx, null, null, null }, | 46316 | .required_features = .{ .@"64bit", null, null, null }, |
| 33056 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, | 46317 | .src_constraints = .{ .any_scalar_unsigned_int, .any, .any }, |
| 33057 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 46318 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 33058 | .patterns = &.{ | 46319 | .patterns = &.{ |
| 33059 | .{ .src = .{ .to_mem, .none } }, | 46320 | .{ .src = .{ .to_mem, .none, .none } }, |
| 33060 | }, | 46321 | }, |
| 33061 | .extra_temps = .{ | 46322 | .extra_temps = .{ |
| 33062 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46323 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 33063 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 46324 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 33064 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 46325 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 33065 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46326 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 33066 | .unused, | 46327 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 33067 | .unused, | 46328 | .unused, |
| 33068 | .unused, | 46329 | .unused, |
| 33069 | .unused, | 46330 | .unused, |
| ... | @@ -33072,118 +46333,456 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33072,118 +46333,456 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33072 | .dst_temps = .{.mem}, | 46333 | .dst_temps = .{.mem}, |
| 33073 | .clobbers = .{ .eflags = true }, | 46334 | .clobbers = .{ .eflags = true }, |
| 33074 | .each = .{ .once = &.{ | 46335 | .each = .{ .once = &.{ |
| 33075 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | 46336 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, |
| 33076 | .{ ._, .v_dqa, .mov, .tmp1x, .lea(.tmp0x), ._, ._ }, | 46337 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 33077 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46338 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| 33078 | .{ .@"0:", .vp_, .@"and", .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, | 46339 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 33079 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, | 46340 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, |
| 33080 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 46341 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| 33081 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 }, | 46542 | .dst_constraints = .{.{ .int = .byte }}, |
| 33085 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, .any }, | | |
| 33086 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }}, | | |
| 33087 | .patterns = &.{ | 46543 | .patterns = &.{ |
| 33088 | .{ .src = .{ .to_mem, .none } }, | 46544 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 33089 | }, | 46545 | }, |
| 33090 | .extra_temps = .{ | 46546 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 33091 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46547 | .each = .{ .once = &.{ |
| 33092 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 46548 | .{ ._, ._, .movzx, .dst0d, .leai(.src0b, .src1), ._, ._ }, |
| 33093 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 46549 | } }, |
| 33094 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, | 46550 | }, .{ |
| 33095 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46551 | .dst_constraints = .{.{ .int = .word }}, |
| 33096 | .{ .kind = .{ .smin_mem = .{ .ref = .dst0 } } }, | 46552 | .patterns = &.{ |
| 33097 | .unused, | 46553 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 33098 | .unused, | | |
| 33099 | .unused, | | |
| 33100 | }, | 46554 | }, |
| 33101 | .dst_temps = .{.mem}, | 46555 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 33102 | .clobbers = .{ .eflags = true }, | | |
| 33103 | .each = .{ .once = &.{ | 46556 | .each = .{ .once = &.{ |
| 33104 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp4), ._, ._ }, | 46557 | .{ ._, ._, .movzx, .dst0d, .leaa(.src0w, .add_src0_elem_size_times_src1), ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33116 | } }, | 46558 | } }, |
| 33117 | }, .{ | 46559 | }, .{ |
| 33118 | .required_features = .{ .sse2, null, null, null }, | 46560 | .dst_constraints = .{.{ .int = .word }}, |
| 33119 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, .any }, | | |
| 33120 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }}, | | |
| 33121 | .patterns = &.{ | 46561 | .patterns = &.{ |
| 33122 | .{ .src = .{ .to_mem, .none } }, | 46562 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 33123 | }, | 46563 | }, |
| 33124 | .extra_temps = .{ | 46564 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 33125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46565 | .each = .{ .once = &.{ |
| 33126 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 46566 | .{ ._, ._, .movzx, .dst0d, .leasi(.src0w, .@"2", .src1), ._, ._ }, |
| 33127 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 46567 | } }, |
| 33128 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46568 | }, .{ |
| 33129 | .unused, | 46569 | .dst_constraints = .{.{ .int = .dword }}, |
| 33130 | .unused, | 46570 | .patterns = &.{ |
| 33131 | .unused, | 46571 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 33132 | .unused, | 46572 | }, |
| 33133 | .unused, | 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 | .patterns = &.{ | 46750 | .patterns = &.{ |
| 33152 | .{ .src = .{ .to_mem, .none } }, | 46751 | .{ .src = .{ .to_sse, .to_sse, .to_sse } }, |
| 33153 | }, | 46752 | }, |
| 33154 | .extra_temps = .{ | 46753 | .extra_temps = .{ |
| 33155 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46754 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 33156 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 46755 | .{ .type = .f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33157 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, | 46756 | .unused, |
| 33158 | .{ .kind = .{ .umax_mem = .{ .ref = .dst0, .to_signedness = .unsigned } } }, | 46757 | .unused, |
| 33159 | .unused, | 46758 | .unused, |
| 33160 | .unused, | 46759 | .unused, |
| 33161 | .unused, | 46760 | .unused, |
| 33162 | .unused, | 46761 | .unused, |
| 33163 | .unused, | 46762 | .unused, |
| 33164 | }, | 46763 | }, |
| 33165 | .dst_temps = .{.mem}, | 46764 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 33166 | .clobbers = .{ .eflags = true }, | | |
| 33167 | .each = .{ .once = &.{ | 46765 | .each = .{ .once = &.{ |
| 33168 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, | 46766 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 33169 | .{ ._, ._ps, .mova, .tmp1x, .lea(.tmp0x), ._, ._ }, | 46767 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 33170 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46768 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ }, |
| 33171 | .{ .@"0:", ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, | 46769 | .{ ._, .v_ss, .fmadd213, .dst0x, .tmp0x, .tmp1d, ._ }, |
| 33172 | .{ ._, ._ps, .@"and", .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 46770 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 33173 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, | | |
| 33174 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | | |
| 33175 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 33176 | } }, | 46771 | } }, |
| 33177 | }, .{ | 46772 | }, .{ |
| 33178 | .required_features = .{ .@"64bit", null, null, null }, | 46773 | .required_features = .{ .sse, null, null, null }, |
| 33179 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any }, | 46774 | .src_constraints = .{ |
| 33180 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, | 46775 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 46776 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 46777 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| | 46778 | }, |
| 33181 | .patterns = &.{ | 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 | .extra_temps = .{ | 46783 | .extra_temps = .{ |
| 33185 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46784 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33186 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 46785 | .unused, |
| 33187 | .unused, | 46786 | .unused, |
| 33188 | .unused, | 46787 | .unused, |
| 33189 | .unused, | 46788 | .unused, |
| ... | @@ -33192,25 +46791,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33192,25 +46791,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33192 | .unused, | 46791 | .unused, |
| 33193 | .unused, | 46792 | .unused, |
| 33194 | }, | 46793 | }, |
| 33195 | .dst_temps = .{.mem}, | 46794 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33196 | .clobbers = .{ .eflags = true }, | 46795 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33197 | .each = .{ .once = &.{ | 46796 | .each = .{ .once = &.{ |
| 33198 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46797 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33203 | } }, | 46798 | } }, |
| 33204 | }, .{ | 46799 | }, .{ |
| 33205 | .required_features = .{ .@"64bit", null, null, null }, | 46800 | .required_features = .{ .fma, .f16c, null, null }, |
| 33206 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any }, | 46801 | .src_constraints = .{ |
| 33207 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 46802 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 46803 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 46804 | .{ .scalar_float = .{ .of = .qword, .is = .word } }, |
| | 46805 | }, |
| 33208 | .patterns = &.{ | 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 | .extra_temps = .{ | 46816 | .extra_temps = .{ |
| 33212 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46817 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 33213 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 46818 | .{ .type = .vector_4_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33214 | .unused, | 46819 | .unused, |
| 33215 | .unused, | 46820 | .unused, |
| 33216 | .unused, | 46821 | .unused, |
| ... | @@ -33219,28 +46824,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33219,28 +46824,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33219 | .unused, | 46824 | .unused, |
| 33220 | .unused, | 46825 | .unused, |
| 33221 | }, | 46826 | }, |
| 33222 | .dst_temps = .{.mem}, | 46827 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 33223 | .clobbers = .{ .eflags = true }, | | |
| 33224 | .each = .{ .once = &.{ | 46828 | .each = .{ .once = &.{ |
| 33225 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46829 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 33226 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 46830 | .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, |
| 33227 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, | 46831 | .{ ._, .v_ps, .cvtph2, .tmp1x, .src2q, ._, ._ }, |
| 33228 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, | 46832 | .{ ._, .v_ps, .fmadd213, .dst0x, .tmp0x, .tmp1x, ._ }, |
| 33229 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 46833 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 33230 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | | |
| 33231 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 33232 | } }, | 46834 | } }, |
| 33233 | }, .{ | 46835 | }, .{ |
| 33234 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 46836 | .required_features = .{ .fma, .f16c, null, null }, |
| 33235 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 46837 | .src_constraints = .{ |
| 33236 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 46838 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 46839 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 46840 | .{ .scalar_float = .{ .of = .xword, .is = .word } }, |
| | 46841 | }, |
| 33237 | .patterns = &.{ | 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 | .extra_temps = .{ | 46852 | .extra_temps = .{ |
| 33241 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46853 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 33242 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 46854 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33243 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 46855 | .unused, |
| 33244 | .unused, | 46856 | .unused, |
| 33245 | .unused, | 46857 | .unused, |
| 33246 | .unused, | 46858 | .unused, |
| ... | @@ -33248,28 +46860,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33248,28 +46860,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33248 | .unused, | 46860 | .unused, |
| 33249 | .unused, | 46861 | .unused, |
| 33250 | }, | 46862 | }, |
| 33251 | .dst_temps = .{.mem}, | 46863 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 33252 | .clobbers = .{ .eflags = true }, | | |
| 33253 | .each = .{ .once = &.{ | 46864 | .each = .{ .once = &.{ |
| 33254 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46865 | .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, |
| 33255 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 46866 | .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, |
| 33256 | .{ .@"0:", ._, .bzhi, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), .tmp1q, ._ }, | 46867 | .{ ._, .v_ps, .cvtph2, .tmp1y, .src2x, ._, ._ }, |
| 33257 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, | 46868 | .{ ._, .v_ps, .fmadd213, .dst0y, .tmp0y, .tmp1y, ._ }, |
| 33258 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 46869 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 33259 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | | |
| 33260 | } }, | 46870 | } }, |
| 33261 | }, .{ | 46871 | }, .{ |
| 33262 | .required_features = .{ .@"64bit", null, null, null }, | 46872 | .required_features = .{ .fma, .f16c, null, null }, |
| 33263 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any }, | 46873 | .src_constraints = .{ |
| 33264 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 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 | .patterns = &.{ | 46878 | .patterns = &.{ |
| 33266 | .{ .src = .{ .to_mem, .none } }, | 46879 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33267 | }, | 46880 | }, |
| 33268 | .extra_temps = .{ | 46881 | .extra_temps = .{ |
| 33269 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46882 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33270 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 46883 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 33271 | .unused, | 46884 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33272 | .unused, | 46885 | .{ .type = .vector_8_f16, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33273 | .unused, | 46886 | .unused, |
| 33274 | .unused, | 46887 | .unused, |
| 33275 | .unused, | 46888 | .unused, |
| ... | @@ -33277,221 +46890,232 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33277,221 +46890,232 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33277 | .unused, | 46890 | .unused, |
| 33278 | }, | 46891 | }, |
| 33279 | .dst_temps = .{.mem}, | 46892 | .dst_temps = .{.mem}, |
| 33280 | .clobbers = .{ .eflags = true }, | | |
| 33281 | .each = .{ .once = &.{ | 46893 | .each = .{ .once = &.{ |
| 33282 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46894 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33283 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, | 46895 | .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33284 | .{ ._, ._, .@"and", .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 46896 | .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33285 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 46897 | .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33286 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 46898 | .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .tmp3y, ._ }, |
| | 46899 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| | 46900 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 33287 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 46901 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33288 | } }, | 46902 | } }, |
| 33289 | }, .{ | 46903 | }, .{ |
| 33290 | .required_features = .{ .@"64bit", null, null, null }, | 46904 | .required_features = .{ .avx, null, null, null }, |
| 33291 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any }, | 46905 | .src_constraints = .{ |
| 33292 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, | 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 | .patterns = &.{ | 46910 | .patterns = &.{ |
| 33294 | .{ .src = .{ .to_mem, .none } }, | 46911 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33295 | }, | 46912 | }, |
| | 46913 | .call_frame = .{ .alignment = .@"16" }, |
| 33296 | .extra_temps = .{ | 46914 | .extra_temps = .{ |
| 33297 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46915 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33298 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 46916 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 33299 | .unused, | 46917 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 33300 | .unused, | 46918 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 33301 | .unused, | 46919 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33302 | .unused, | 46920 | .unused, |
| 33303 | .unused, | 46921 | .unused, |
| 33304 | .unused, | 46922 | .unused, |
| 33305 | .unused, | 46923 | .unused, |
| 33306 | }, | 46924 | }, |
| 33307 | .dst_temps = .{.mem}, | 46925 | .dst_temps = .{.mem}, |
| 33308 | .clobbers = .{ .eflags = true }, | 46926 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33309 | .each = .{ .once = &.{ | 46927 | .each = .{ .once = &.{ |
| 33310 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46928 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33311 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 46929 | .{ .@"0:", .vp_, .xor, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| 33312 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 46930 | .{ ._, .vp_w, .insr, .tmp1x, .tmp3x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 33313 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 46936 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33315 | } }, | 46937 | } }, |
| 33316 | }, .{ | 46938 | }, .{ |
| 33317 | .required_features = .{ .@"64bit", null, null, null }, | 46939 | .required_features = .{ .sse4_1, null, null, null }, |
| 33318 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any }, | 46940 | .src_constraints = .{ |
| 33319 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 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 | .patterns = &.{ | 46945 | .patterns = &.{ |
| 33321 | .{ .src = .{ .to_mem, .none } }, | 46946 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33322 | }, | 46947 | }, |
| | 46948 | .call_frame = .{ .alignment = .@"16" }, |
| 33323 | .extra_temps = .{ | 46949 | .extra_temps = .{ |
| 33324 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46950 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33325 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 46951 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 33326 | .unused, | 46952 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 33327 | .unused, | 46953 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 33328 | .unused, | 46954 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33329 | .unused, | 46955 | .unused, |
| 33330 | .unused, | 46956 | .unused, |
| 33331 | .unused, | 46957 | .unused, |
| 33332 | .unused, | 46958 | .unused, |
| 33333 | }, | 46959 | }, |
| 33334 | .dst_temps = .{.mem}, | 46960 | .dst_temps = .{.mem}, |
| 33335 | .clobbers = .{ .eflags = true }, | 46961 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33336 | .each = .{ .once = &.{ | 46962 | .each = .{ .once = &.{ |
| 33337 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 46963 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33338 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 46964 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 33339 | .{ ._, ._l, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, | 46965 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 33340 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, | 46966 | .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 33341 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 46967 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 33342 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 46973 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33344 | } }, | 46974 | } }, |
| 33345 | }, .{ | 46975 | }, .{ |
| 33346 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 46976 | .required_features = .{ .sse2, null, null, null }, |
| 33347 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, | 46977 | .src_constraints = .{ |
| 33348 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 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 | .patterns = &.{ | 46982 | .patterns = &.{ |
| 33350 | .{ .src = .{ .to_mem, .none } }, | 46983 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33351 | }, | 46984 | }, |
| | 46985 | .call_frame = .{ .alignment = .@"16" }, |
| 33352 | .extra_temps = .{ | 46986 | .extra_temps = .{ |
| 33353 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 46987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33354 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 46988 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 33355 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 46989 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 33356 | .unused, | 46990 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 33357 | .unused, | 46991 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33358 | .unused, | 46992 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 33359 | .unused, | 46993 | .unused, |
| 33360 | .unused, | 46994 | .unused, |
| 33361 | .unused, | 46995 | .unused, |
| 33362 | }, | 46996 | }, |
| 33363 | .dst_temps = .{.mem}, | 46997 | .dst_temps = .{.mem}, |
| 33364 | .clobbers = .{ .eflags = true }, | 46998 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33365 | .each = .{ .once = &.{ | 46999 | .each = .{ .once = &.{ |
| 33366 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47000 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33367 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_bit_size), ._, ._ }, | 47001 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 33368 | .{ .@"0:", ._, .bzhi, .tmp2q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._ }, | 47002 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 33369 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, | 47003 | .{ ._, .p_, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 33370 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 47011 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33372 | } }, | 47012 | } }, |
| 33373 | }, .{ | 47013 | }, .{ |
| 33374 | .required_features = .{ .@"64bit", null, null, null }, | 47014 | .required_features = .{ .sse, null, null, null }, |
| 33375 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any }, | 47015 | .src_constraints = .{ |
| 33376 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 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 | .patterns = &.{ | 47020 | .patterns = &.{ |
| 33378 | .{ .src = .{ .to_mem, .none } }, | 47021 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33379 | }, | 47022 | }, |
| | 47023 | .call_frame = .{ .alignment = .@"16" }, |
| 33380 | .extra_temps = .{ | 47024 | .extra_temps = .{ |
| 33381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47025 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33382 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 47026 | .{ .type = .f16, .kind = .{ .reg = .ax } }, |
| 33383 | .unused, | 47027 | .{ .type = .f32, .kind = .mem }, |
| 33384 | .unused, | 47028 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 33385 | .unused, | 47029 | .{ .type = .f16, .kind = .{ .reg = .xmm1 } }, |
| 33386 | .unused, | 47030 | .{ .type = .f16, .kind = .{ .reg = .xmm2 } }, |
| 33387 | .unused, | 47031 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmah" } } }, |
| 33388 | .unused, | 47032 | .unused, |
| 33389 | .unused, | 47033 | .unused, |
| 33390 | }, | 47034 | }, |
| 33391 | .dst_temps = .{.mem}, | 47035 | .dst_temps = .{.mem}, |
| 33392 | .clobbers = .{ .eflags = true }, | 47036 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33393 | .each = .{ .once = &.{ | 47037 | .each = .{ .once = &.{ |
| 33394 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47038 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33395 | .{ .@"0:", ._, .mov, .tmp1q, .ua(.dst0, .add_umax), ._, ._ }, | 47039 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33396 | .{ ._, ._, .@"and", .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, | 47040 | .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ }, |
| 33397 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, | 47041 | .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ }, |
| 33398 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, | 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 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 47053 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33400 | } }, | 47054 | } }, |
| 33401 | }, .{ | 47055 | }, .{ |
| 33402 | .required_features = .{ .@"64bit", null, null, null }, | 47056 | .required_features = .{ .fma, null, null, null }, |
| 33403 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any }, | 47057 | .src_constraints = .{ |
| 33404 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, | 47058 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33405 | .patterns = &.{ | 47059 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33406 | .{ .src = .{ .to_mem, .none } }, | 47060 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33407 | }, | 47061 | }, |
| 33408 | .extra_temps = .{ | 47062 | .patterns = &.{ |
| 33409 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47063 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 33410 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 47064 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 33411 | .unused, | 47065 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 33412 | .unused, | 47066 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33413 | .unused, | | |
| 33414 | .unused, | | |
| 33415 | .unused, | | |
| 33416 | .unused, | | |
| 33417 | .unused, | | |
| 33418 | }, | 47067 | }, |
| 33419 | .dst_temps = .{.mem}, | 47068 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33420 | .clobbers = .{ .eflags = true }, | | |
| 33421 | .each = .{ .once = &.{ | 47069 | .each = .{ .once = &.{ |
| 33422 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47070 | .{ ._, .v_ss, .fmadd132, .dst0x, .src2x, .src1d, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33427 | } }, | 47071 | } }, |
| 33428 | }, .{ | 47072 | }, .{ |
| 33429 | .required_features = .{ .@"64bit", null, null, null }, | 47073 | .required_features = .{ .fma, null, null, null }, |
| 33430 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .yword } }, .any }, | 47074 | .src_constraints = .{ |
| 33431 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 47075 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33432 | .patterns = &.{ | 47076 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33433 | .{ .src = .{ .to_mem, .none } }, | 47077 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33434 | }, | 47078 | }, |
| 33435 | .extra_temps = .{ | 47079 | .patterns = &.{ |
| 33436 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47080 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 33437 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 47081 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 33438 | .unused, | 47082 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 33439 | .unused, | 47083 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33440 | .unused, | | |
| 33441 | .unused, | | |
| 33442 | .unused, | | |
| 33443 | .unused, | | |
| 33444 | .unused, | | |
| 33445 | }, | 47084 | }, |
| 33446 | .dst_temps = .{.mem}, | 47085 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33447 | .clobbers = .{ .eflags = true }, | | |
| 33448 | .each = .{ .once = &.{ | 47086 | .each = .{ .once = &.{ |
| 33449 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47087 | .{ ._, .v_ss, .fmadd213, .dst0x, .src1x, .src2d, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33456 | } }, | 47088 | } }, |
| 33457 | }, .{ | 47089 | }, .{ |
| 33458 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 47090 | .required_features = .{ .fma, null, null, null }, |
| 33459 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, | 47091 | .src_constraints = .{ |
| 33460 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 47092 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33461 | .patterns = &.{ | 47093 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33462 | .{ .src = .{ .to_mem, .none } }, | 47094 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 33463 | }, | 47095 | }, |
| 33464 | .extra_temps = .{ | 47096 | .patterns = &.{ |
| 33465 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47097 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 33466 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 47098 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 33467 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 47099 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 33468 | .unused, | | |
| 33469 | .unused, | | |
| 33470 | .unused, | | |
| 33471 | .unused, | | |
| 33472 | .unused, | | |
| 33473 | .unused, | | |
| 33474 | }, | 47100 | }, |
| 33475 | .dst_temps = .{.mem}, | 47101 | .dst_temps = .{.{ .ref = .src2 }}, |
| 33476 | .clobbers = .{ .eflags = true }, | | |
| 33477 | .each = .{ .once = &.{ | 47102 | .each = .{ .once = &.{ |
| 33478 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47103 | .{ ._, .v_ss, .fmadd231, .dst0x, .src0x, .src1d, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33484 | } }, | 47104 | } }, |
| 33485 | }, .{ | 47105 | }, .{ |
| 33486 | .required_features = .{ .@"64bit", null, null, null }, | 47106 | .required_features = .{ .sse, null, null, null }, |
| 33487 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .yword } }, .any }, | 47107 | .src_constraints = .{ |
| 33488 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 47108 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 47109 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 47110 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| | 47111 | }, |
| 33489 | .patterns = &.{ | 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 | .extra_temps = .{ | 47116 | .extra_temps = .{ |
| 33493 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47117 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } }, |
| 33494 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 47118 | .unused, |
| 33495 | .unused, | 47119 | .unused, |
| 33496 | .unused, | 47120 | .unused, |
| 33497 | .unused, | 47121 | .unused, |
| ... | @@ -33500,178 +47124,126 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33500,178 +47124,126 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33500 | .unused, | 47124 | .unused, |
| 33501 | .unused, | 47125 | .unused, |
| 33502 | }, | 47126 | }, |
| 33503 | .dst_temps = .{.mem}, | 47127 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33504 | .clobbers = .{ .eflags = true }, | 47128 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33505 | .each = .{ .once = &.{ | 47129 | .each = .{ .once = &.{ |
| 33506 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47130 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33512 | } }, | 47131 | } }, |
| 33513 | }, .{ | 47132 | }, .{ |
| 33514 | .required_features = .{ .@"64bit", null, null, null }, | 47133 | .required_features = .{ .fma, null, null, null }, |
| 33515 | .src_constraints = .{ .any_scalar_int, .any }, | 47134 | .src_constraints = .{ |
| 33516 | .dst_constraints = .{.{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 64 } }}, | 47135 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33517 | .patterns = &.{ | 47136 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33518 | .{ .src = .{ .to_mem, .none } }, | 47137 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33519 | }, | 47138 | }, |
| 33520 | .extra_temps = .{ | 47139 | .patterns = &.{ |
| 33521 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47140 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 33522 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47141 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 33523 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 47142 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 33524 | .unused, | 47143 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33525 | .unused, | | |
| 33526 | .unused, | | |
| 33527 | .unused, | | |
| 33528 | .unused, | | |
| 33529 | .unused, | | |
| 33530 | }, | 47144 | }, |
| 33531 | .dst_temps = .{.mem}, | 47145 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33532 | .clobbers = .{ .eflags = true }, | | |
| 33533 | .each = .{ .once = &.{ | 47146 | .each = .{ .once = &.{ |
| 33534 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47147 | .{ ._, .v_ps, .fmadd132, .dst0x, .src2x, .src1x, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33541 | } }, | 47148 | } }, |
| 33542 | }, .{ | 47149 | }, .{ |
| 33543 | .required_features = .{ .@"64bit", null, null, null }, | 47150 | .required_features = .{ .fma, null, null, null }, |
| 33544 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47151 | .src_constraints = .{ |
| 33545 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, | 47152 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33546 | .patterns = &.{ | 47153 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33547 | .{ .src = .{ .to_mem, .none } }, | 47154 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33548 | }, | 47155 | }, |
| 33549 | .extra_temps = .{ | 47156 | .patterns = &.{ |
| 33550 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47157 | .{ .src = .{ .to_mut_sse, .to_sse, .mem } }, |
| 33551 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47158 | .{ .src = .{ .to_sse, .to_mut_sse, .mem }, .commute = .{ 0, 1 } }, |
| 33552 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 47159 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 33553 | .unused, | 47160 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33554 | .unused, | | |
| 33555 | .unused, | | |
| 33556 | .unused, | | |
| 33557 | .unused, | | |
| 33558 | .unused, | | |
| 33559 | }, | 47161 | }, |
| 33560 | .dst_temps = .{.mem}, | 47162 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33561 | .clobbers = .{ .eflags = true }, | | |
| 33562 | .each = .{ .once = &.{ | 47163 | .each = .{ .once = &.{ |
| 33563 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47164 | .{ ._, .v_ps, .fmadd213, .dst0x, .src1x, .src2x, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33572 | } }, | 47165 | } }, |
| 33573 | }, .{ | 47166 | }, .{ |
| 33574 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 47167 | .required_features = .{ .fma, null, null, null }, |
| 33575 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47168 | .src_constraints = .{ |
| 33576 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 47169 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33577 | .patterns = &.{ | 47170 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33578 | .{ .src = .{ .to_mem, .none } }, | 47171 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 33579 | }, | 47172 | }, |
| 33580 | .extra_temps = .{ | 47173 | .patterns = &.{ |
| 33581 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47174 | .{ .src = .{ .to_sse, .mem, .to_mut_sse } }, |
| 33582 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47175 | .{ .src = .{ .mem, .to_sse, .to_mut_sse }, .commute = .{ 0, 1 } }, |
| 33583 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 47176 | .{ .src = .{ .to_sse, .to_sse, .to_mut_sse } }, |
| 33584 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | | |
| 33585 | .unused, | | |
| 33586 | .unused, | | |
| 33587 | .unused, | | |
| 33588 | .unused, | | |
| 33589 | .unused, | | |
| 33590 | }, | 47177 | }, |
| 33591 | .dst_temps = .{.mem}, | 47178 | .dst_temps = .{.{ .ref = .src2 }}, |
| 33592 | .clobbers = .{ .eflags = true }, | | |
| 33593 | .each = .{ .once = &.{ | 47179 | .each = .{ .once = &.{ |
| 33594 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47180 | .{ ._, .v_ps, .fmadd231, .dst0x, .src0x, .src1x, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33602 | } }, | 47181 | } }, |
| 33603 | }, .{ | 47182 | }, .{ |
| 33604 | .required_features = .{ .@"64bit", null, null, null }, | 47183 | .required_features = .{ .fma, null, null, null }, |
| 33605 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47184 | .src_constraints = .{ |
| 33606 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 47185 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33607 | .patterns = &.{ | 47186 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33608 | .{ .src = .{ .to_mem, .none } }, | 47187 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33609 | }, | 47188 | }, |
| 33610 | .extra_temps = .{ | 47189 | .patterns = &.{ |
| 33611 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 47190 | .{ .src = .{ .to_mut_sse, .mem, .to_sse } }, |
| 33612 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47191 | .{ .src = .{ .mem, .to_mut_sse, .to_sse }, .commute = .{ 0, 1 } }, |
| 33613 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 47192 | .{ .src = .{ .mut_sse, .sse, .sse } }, |
| 33614 | .unused, | 47193 | .{ .src = .{ .sse, .mut_sse, .sse }, .commute = .{ 0, 1 } }, |
| 33615 | .unused, | | |
| 33616 | .unused, | | |
| 33617 | .unused, | | |
| 33618 | .unused, | | |
| 33619 | .unused, | | |
| 33620 | }, | 47194 | }, |
| 33621 | .dst_temps = .{.mem}, | 47195 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33622 | .clobbers = .{ .eflags = true }, | | |
| 33623 | .each = .{ .once = &.{ | 47196 | .each = .{ .once = &.{ |
| 33624 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, | 47197 | .{ ._, .v_ps, .fmadd132, .dst0y, .src2y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33632 | } }, | 47198 | } }, |
| 33633 | }, .{ | 47199 | }, .{ |
| 33634 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47200 | .required_features = .{ .fma, null, null, null }, |
| 33635 | .src_constraints = .{ .any_scalar_int, .any }, | 47201 | .src_constraints = .{ |
| 33636 | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, | 47202 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 47203 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 47204 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| | 47205 | }, |
| 33637 | .patterns = &.{ | 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 = .{ | 47212 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33641 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47213 | .each = .{ .once = &.{ |
| 33642 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47214 | .{ ._, .v_ps, .fmadd213, .dst0y, .src1y, .src2y, ._ }, |
| 33643 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47215 | } }, |
| 33644 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47216 | }, .{ |
| 33645 | .unused, | 47217 | .required_features = .{ .fma, null, null, null }, |
| 33646 | .unused, | 47218 | .src_constraints = .{ |
| 33647 | .unused, | 47219 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33648 | .unused, | 47220 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33649 | .unused, | 47221 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 33650 | }, | 47222 | }, |
| 33651 | .dst_temps = .{.mem}, | 47223 | .patterns = &.{ |
| 33652 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 47229 | .each = .{ .once = &.{ |
| 33654 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47230 | .{ ._, .v_ps, .fmadd231, .dst0y, .src0y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33662 | } }, | 47231 | } }, |
| 33663 | }, .{ | 47232 | }, .{ |
| 33664 | .required_features = .{ .@"64bit", null, null, null }, | 47233 | .required_features = .{ .fma, null, null, null }, |
| 33665 | .src_constraints = .{ .any_scalar_int, .any }, | 47234 | .src_constraints = .{ |
| 33666 | .dst_constraints = .{.{ .scalar_exact_remainder_int = .{ .of = .xword, .is = .xword } }}, | 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 | .patterns = &.{ | 47239 | .patterns = &.{ |
| 33668 | .{ .src = .{ .to_mem, .none } }, | 47240 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33669 | }, | 47241 | }, |
| 33670 | .extra_temps = .{ | 47242 | .extra_temps = .{ |
| 33671 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33672 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47244 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 33673 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47245 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33674 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47246 | .unused, |
| 33675 | .unused, | 47247 | .unused, |
| 33676 | .unused, | 47248 | .unused, |
| 33677 | .unused, | 47249 | .unused, |
| ... | @@ -33679,955 +47251,607 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -33679,955 +47251,607 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 33679 | .unused, | 47251 | .unused, |
| 33680 | }, | 47252 | }, |
| 33681 | .dst_temps = .{.mem}, | 47253 | .dst_temps = .{.mem}, |
| 33682 | .clobbers = .{ .eflags = true }, | | |
| 33683 | .each = .{ .once = &.{ | 47254 | .each = .{ .once = &.{ |
| 33684 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47255 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33685 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47256 | .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33686 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47257 | .{ ._, .v_ps, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33687 | .{ .@"0:", ._, .mov, .tmp3d, .sa(.dst0, .add_elem_size_div_8), ._, ._ }, | 47258 | .{ ._, .v_ps, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ }, |
| 33688 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47259 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 33689 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, | 47260 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 33690 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, | 47261 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33691 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 33692 | } }, | 47262 | } }, |
| 33693 | }, .{ | 47263 | }, .{ |
| 33694 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47264 | .required_features = .{ .avx, null, null, null }, |
| 33695 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47265 | .src_constraints = .{ |
| 33696 | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47270 | .patterns = &.{ |
| 33698 | .{ .src = .{ .to_mem, .none } }, | 47271 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33699 | }, | 47272 | }, |
| | 47273 | .call_frame = .{ .alignment = .@"16" }, |
| 33700 | .extra_temps = .{ | 47274 | .extra_temps = .{ |
| 33701 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47275 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33702 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47276 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 33703 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47277 | .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, |
| 33704 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47278 | .{ .type = .f32, .kind = .{ .reg = .xmm2 } }, |
| 33705 | .unused, | 47279 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } }, |
| 33706 | .unused, | 47280 | .unused, |
| 33707 | .unused, | 47281 | .unused, |
| 33708 | .unused, | 47282 | .unused, |
| 33709 | .unused, | 47283 | .unused, |
| 33710 | }, | 47284 | }, |
| 33711 | .dst_temps = .{.mem}, | 47285 | .dst_temps = .{.mem}, |
| 33712 | .clobbers = .{ .eflags = true }, | 47286 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33713 | .each = .{ .once = &.{ | 47287 | .each = .{ .once = &.{ |
| 33714 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47288 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33715 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47289 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33716 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47290 | .{ ._, .v_ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33717 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, | 47291 | .{ ._, .v_ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33718 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47292 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 33719 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, | 47293 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 33720 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, | 47294 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 33721 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, | 47295 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33727 | } }, | 47296 | } }, |
| 33728 | }, .{ | 47297 | }, .{ |
| 33729 | .required_features = .{ .@"64bit", null, null, null }, | 47298 | .required_features = .{ .sse, null, null, null }, |
| 33730 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47299 | .src_constraints = .{ |
| 33731 | .dst_constraints = .{.{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47304 | .patterns = &.{ |
| 33733 | .{ .src = .{ .to_mem, .none } }, | 47305 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33734 | }, | 47306 | }, |
| | 47307 | .call_frame = .{ .alignment = .@"16" }, |
| 33735 | .extra_temps = .{ | 47308 | .extra_temps = .{ |
| 33736 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47309 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33737 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47310 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 33738 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47311 | .{ .type = .f32, .kind = .{ .reg = .xmm1 } }, |
| 33739 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47312 | .{ .type = .f32, .kind = .{ .reg = .xmm2 } }, |
| 33740 | .unused, | 47313 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaf" } } }, |
| 33741 | .unused, | 47314 | .unused, |
| 33742 | .unused, | 47315 | .unused, |
| 33743 | .unused, | 47316 | .unused, |
| 33744 | .unused, | 47317 | .unused, |
| 33745 | }, | 47318 | }, |
| 33746 | .dst_temps = .{.mem}, | 47319 | .dst_temps = .{.mem}, |
| 33747 | .clobbers = .{ .eflags = true }, | 47320 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33748 | .each = .{ .once = &.{ | 47321 | .each = .{ .once = &.{ |
| 33749 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47322 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33750 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47323 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33751 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47324 | .{ ._, ._ss, .mov, .tmp2x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33752 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, | 47325 | .{ ._, ._ss, .mov, .tmp3x, .memia(.src2d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33753 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47326 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 33754 | .{ ._, ._, .mov, .tmp3q, .lea(.tmp1q), ._, ._ }, | 47327 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 33755 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, | 47328 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 33756 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, | 47329 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33762 | } }, | 47330 | } }, |
| 33763 | }, .{ | 47331 | }, .{ |
| 33764 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47332 | .required_features = .{ .fma, null, null, null }, |
| 33765 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47333 | .src_constraints = .{ |
| 33766 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, | 47334 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 47335 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 47336 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| | 47337 | }, |
| 33767 | .patterns = &.{ | 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 = .{ | 47344 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33771 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47345 | .each = .{ .once = &.{ |
| 33772 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47346 | .{ ._, .v_sd, .fmadd132, .dst0x, .src2x, .src1q, ._ }, |
| 33773 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47347 | } }, |
| 33774 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47348 | }, .{ |
| 33775 | .unused, | 47349 | .required_features = .{ .fma, null, null, null }, |
| 33776 | .unused, | 47350 | .src_constraints = .{ |
| 33777 | .unused, | 47351 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 33778 | .unused, | 47352 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 33779 | .unused, | 47353 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 33780 | }, | 47354 | }, |
| 33781 | .dst_temps = .{.mem}, | 47355 | .patterns = &.{ |
| 33782 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 47362 | .each = .{ .once = &.{ |
| 33784 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47363 | .{ ._, .v_sd, .fmadd213, .dst0x, .src1x, .src2q, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33799 | } }, | 47364 | } }, |
| 33800 | }, .{ | 47365 | }, .{ |
| 33801 | .required_features = .{ .@"64bit", null, null, null }, | 47366 | .required_features = .{ .fma, null, null, null }, |
| 33802 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47367 | .src_constraints = .{ |
| 33803 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 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 | .extra_temps = .{ | 47392 | .extra_temps = .{ |
| 33808 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47393 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 33809 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47394 | .unused, |
| 33810 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47395 | .unused, |
| 33811 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47396 | .unused, |
| 33812 | .unused, | 47397 | .unused, |
| 33813 | .unused, | 47398 | .unused, |
| 33814 | .unused, | 47399 | .unused, |
| 33815 | .unused, | 47400 | .unused, |
| 33816 | .unused, | 47401 | .unused, |
| 33817 | }, | 47402 | }, |
| 33818 | .dst_temps = .{.mem}, | 47403 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33819 | .clobbers = .{ .eflags = true }, | 47404 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33820 | .each = .{ .once = &.{ | 47405 | .each = .{ .once = &.{ |
| 33821 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47406 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33836 | } }, | 47407 | } }, |
| 33837 | }, .{ | 47408 | }, .{ |
| 33838 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47409 | .required_features = .{ .fma, null, null, null }, |
| 33839 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47410 | .src_constraints = .{ |
| 33840 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, | 47411 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 47412 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 47413 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 47414 | }, |
| 33841 | .patterns = &.{ | 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 = .{ | 47421 | .dst_temps = .{.{ .ref = .src0 }}, |
| 33845 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47422 | .each = .{ .once = &.{ |
| 33846 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47423 | .{ ._, .v_pd, .fmadd132, .dst0x, .src2x, .src1x, ._ }, |
| 33847 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47424 | } }, |
| 33848 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47425 | }, .{ |
| 33849 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47426 | .required_features = .{ .fma, null, null, null }, |
| 33850 | .unused, | 47427 | .src_constraints = .{ |
| 33851 | .unused, | 47428 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 33852 | .unused, | 47429 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 33853 | .unused, | 47430 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 33854 | }, | 47431 | }, |
| 33855 | .dst_temps = .{.mem}, | 47432 | .patterns = &.{ |
| 33856 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 47439 | .each = .{ .once = &.{ |
| 33858 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47440 | .{ ._, .v_pd, .fmadd213, .dst0x, .src1x, .src2x, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33870 | } }, | 47441 | } }, |
| 33871 | }, .{ | 47442 | }, .{ |
| 33872 | .required_features = .{ .@"64bit", null, null, null }, | 47443 | .required_features = .{ .fma, null, null, null }, |
| 33873 | .src_constraints = .{ .any_scalar_signed_int, .any }, | 47444 | .src_constraints = .{ |
| 33874 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }}, | 47445 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 47446 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 47447 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| | 47448 | }, |
| 33875 | .patterns = &.{ | 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 = .{ | 47454 | .dst_temps = .{.{ .ref = .src2 }}, |
| 33879 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47455 | .each = .{ .once = &.{ |
| 33880 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47456 | .{ ._, .v_pd, .fmadd231, .dst0x, .src0x, .src1x, ._ }, |
| 33881 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47457 | } }, |
| 33882 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47458 | }, .{ |
| 33883 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47459 | .required_features = .{ .fma, null, null, null }, |
| 33884 | .unused, | 47460 | .src_constraints = .{ |
| 33885 | .unused, | 47461 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 33886 | .unused, | 47462 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 33887 | .unused, | 47463 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 33888 | }, | 47464 | }, |
| 33889 | .dst_temps = .{.mem}, | 47465 | .patterns = &.{ |
| 33890 | .clobbers = .{ .eflags = true }, | 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 | .each = .{ .once = &.{ | 47472 | .each = .{ .once = &.{ |
| 33892 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47473 | .{ ._, .v_pd, .fmadd132, .dst0y, .src2y, .src1y, ._ }, |
| 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", ._, ._, ._ }, | | |
| 33904 | } }, | 47474 | } }, |
| 33905 | }, .{ | 47475 | }, .{ |
| 33906 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47476 | .required_features = .{ .fma, null, null, null }, |
| 33907 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47477 | .src_constraints = .{ |
| 33908 | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47515 | .patterns = &.{ |
| 33910 | .{ .src = .{ .to_mem, .none } }, | 47516 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33911 | }, | 47517 | }, |
| 33912 | .extra_temps = .{ | 47518 | .extra_temps = .{ |
| 33913 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47519 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33914 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47520 | .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, |
| 33915 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47521 | .{ .type = .vector_4_f64, .kind = .{ .mut_rc = .{ .ref = .src2, .rc = .sse } } }, |
| 33916 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47522 | .unused, |
| 33917 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47523 | .unused, |
| 33918 | .unused, | 47524 | .unused, |
| 33919 | .unused, | 47525 | .unused, |
| 33920 | .unused, | 47526 | .unused, |
| 33921 | .unused, | 47527 | .unused, |
| 33922 | }, | 47528 | }, |
| 33923 | .dst_temps = .{.mem}, | 47529 | .dst_temps = .{.mem}, |
| 33924 | .clobbers = .{ .eflags = true }, | | |
| 33925 | .each = .{ .once = &.{ | 47530 | .each = .{ .once = &.{ |
| 33926 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47531 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33927 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47532 | .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33928 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47533 | .{ ._, .v_pd, .mova, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33929 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 47534 | .{ ._, .v_pd, .fmadd213, .tmp1y, .tmp2y, .memia(.src2y, .tmp0, .add_unaligned_size), ._ }, |
| 33930 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 47535 | .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 33931 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47536 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 33932 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 47537 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33933 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, | | |
| 33934 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | | |
| 33935 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, | | |
| 33936 | } }, | 47538 | } }, |
| 33937 | }, .{ | 47539 | }, .{ |
| 33938 | .required_features = .{ .@"64bit", null, null, null }, | 47540 | .required_features = .{ .avx, null, null, null }, |
| 33939 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47541 | .src_constraints = .{ |
| 33940 | .dst_constraints = .{.{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47546 | .patterns = &.{ |
| 33942 | .{ .src = .{ .to_mem, .none } }, | 47547 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33943 | }, | 47548 | }, |
| | 47549 | .call_frame = .{ .alignment = .@"16" }, |
| 33944 | .extra_temps = .{ | 47550 | .extra_temps = .{ |
| 33945 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47551 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33946 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47552 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 33947 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47553 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 33948 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47554 | .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, |
| 33949 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47555 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 33950 | .unused, | 47556 | .unused, |
| 33951 | .unused, | 47557 | .unused, |
| 33952 | .unused, | 47558 | .unused, |
| 33953 | .unused, | 47559 | .unused, |
| 33954 | }, | 47560 | }, |
| 33955 | .dst_temps = .{.mem}, | 47561 | .dst_temps = .{.mem}, |
| 33956 | .clobbers = .{ .eflags = true }, | 47562 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33957 | .each = .{ .once = &.{ | 47563 | .each = .{ .once = &.{ |
| 33958 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47564 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33959 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47565 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33960 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47566 | .{ ._, .v_sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33961 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 47567 | .{ ._, .v_sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33962 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 47568 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 33963 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47569 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 33964 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 47570 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33965 | .{ ._, ._, .add, .tmp1p, .sa2(.src0, .dst0, .add_delta_elem_size), ._, ._ }, | 47571 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 33966 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, | | |
| 33967 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 33968 | } }, | 47572 | } }, |
| 33969 | }, .{ | 47573 | }, .{ |
| 33970 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, | 47574 | .required_features = .{ .sse2, null, null, null }, |
| 33971 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47575 | .src_constraints = .{ |
| 33972 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47580 | .patterns = &.{ |
| 33974 | .{ .src = .{ .to_mem, .none } }, | 47581 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 33975 | }, | 47582 | }, |
| | 47583 | .call_frame = .{ .alignment = .@"16" }, |
| 33976 | .extra_temps = .{ | 47584 | .extra_temps = .{ |
| 33977 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47585 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 33978 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47586 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 33979 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47587 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 33980 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 47588 | .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, |
| 33981 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47589 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 33982 | .unused, | 47590 | .unused, |
| 33983 | .unused, | 47591 | .unused, |
| 33984 | .unused, | 47592 | .unused, |
| 33985 | .unused, | 47593 | .unused, |
| 33986 | }, | 47594 | }, |
| 33987 | .dst_temps = .{.mem}, | 47595 | .dst_temps = .{.mem}, |
| 33988 | .clobbers = .{ .eflags = true }, | 47596 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 33989 | .each = .{ .once = &.{ | 47597 | .each = .{ .once = &.{ |
| 33990 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47598 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 33991 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47599 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33992 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47600 | .{ ._, ._sd, .mov, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33993 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, | 47601 | .{ ._, ._sd, .mov, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 33994 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, | 47602 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 33995 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47603 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 33996 | .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ }, | 47604 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 33997 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ }, | 47605 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 34003 | } }, | 47606 | } }, |
| 34004 | }, .{ | 47607 | }, .{ |
| 34005 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 47608 | .required_features = .{ .sse, null, null, null }, |
| 34006 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47609 | .src_constraints = .{ |
| 34007 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47614 | .patterns = &.{ |
| 34009 | .{ .src = .{ .to_mem, .none } }, | 47615 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34010 | }, | 47616 | }, |
| | 47617 | .call_frame = .{ .alignment = .@"16" }, |
| 34011 | .extra_temps = .{ | 47618 | .extra_temps = .{ |
| 34012 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47619 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34013 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47620 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 34014 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47621 | .{ .type = .f64, .kind = .{ .reg = .xmm1 } }, |
| 34015 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 47622 | .{ .type = .f64, .kind = .{ .reg = .xmm2 } }, |
| 34016 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47623 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fma" } } }, |
| 34017 | .unused, | 47624 | .unused, |
| 34018 | .unused, | 47625 | .unused, |
| 34019 | .unused, | 47626 | .unused, |
| 34020 | .unused, | 47627 | .unused, |
| 34021 | }, | 47628 | }, |
| 34022 | .dst_temps = .{.mem}, | 47629 | .dst_temps = .{.mem}, |
| 34023 | .clobbers = .{ .eflags = true }, | 47630 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34024 | .each = .{ .once = &.{ | 47631 | .each = .{ .once = &.{ |
| 34025 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47632 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 34026 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47633 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 34027 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47634 | .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| 34028 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, | 47635 | .{ ._, ._ps, .xor, .tmp3x, .tmp3x, ._, ._ }, |
| 34029 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, | 47636 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34030 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47637 | .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34031 | .{ ._, ._, .bzhi, .tmp4q, .lea(.tmp1q), .tmp3q, ._ }, | 47638 | .{ ._, ._ps, .movl, .tmp3x, .memia(.src2q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34032 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp4q, ._, ._ }, | 47639 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 34033 | .{ ._, ._, .mov, .lead(.tmp2q, 8), .si(0), ._, ._ }, | 47640 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 34034 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, | 47641 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 34035 | .{ ._, ._, .lea, .tmp2p, .lead(.tmp2, 16), ._, ._ }, | 47642 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34036 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, | | |
| 34037 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 34038 | } }, | 47643 | } }, |
| 34039 | }, .{ | 47644 | }, .{ |
| 34040 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, | 47645 | .required_features = .{ .sse, .x87, null, null }, |
| 34041 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47646 | .src_constraints = .{ |
| 34042 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, | 47647 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 47648 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 47649 | .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, |
| | 47650 | }, |
| 34043 | .patterns = &.{ | 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 | .extra_temps = .{ | 47655 | .extra_temps = .{ |
| 34047 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47656 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 34048 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47657 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34049 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47658 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmax" } } }, |
| 34050 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 47659 | .unused, |
| 34051 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47660 | .unused, |
| 34052 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47661 | .unused, |
| 34053 | .unused, | 47662 | .unused, |
| 34054 | .unused, | 47663 | .unused, |
| 34055 | .unused, | 47664 | .unused, |
| 34056 | }, | 47665 | }, |
| 34057 | .dst_temps = .{.mem}, | 47666 | .dst_temps = .{.{ .reg = .st0 }}, |
| 34058 | .clobbers = .{ .eflags = true }, | 47667 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34059 | .each = .{ .once = &.{ | 47668 | .each = .{ .once = &.{ |
| 34060 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47669 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src0x), ._, ._ }, |
| 34061 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47670 | .{ ._, ._ps, .mova, .mem(.tmp1x), .tmp0x, ._, ._ }, |
| 34062 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47671 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src1x), ._, ._ }, |
| 34063 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, | 47672 | .{ ._, ._ps, .mova, .memd(.tmp1x, 16), .tmp0x, ._, ._ }, |
| 34064 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 47673 | .{ ._, ._ps, .mova, .tmp0x, .mem(.src2x), ._, ._ }, |
| 34065 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47674 | .{ ._, ._ps, .mova, .memd(.tmp1x, 16 * 2), .tmp0x, ._, ._ }, |
| 34066 | .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ }, | 47675 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 34067 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | | |
| 34068 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, | | |
| 34069 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | | |
| 34070 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, | | |
| 34071 | } }, | 47676 | } }, |
| 34072 | }, .{ | 47677 | }, .{ |
| 34073 | .required_features = .{ .@"64bit", .bmi2, null, null }, | 47678 | .required_features = .{ .sse, .x87, null, null }, |
| 34074 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47679 | .src_constraints = .{ |
| 34075 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, | 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 | .patterns = &.{ | 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 | .extra_temps = .{ | 47688 | .extra_temps = .{ |
| 34080 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47689 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34081 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47690 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 34082 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47691 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 34083 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, | 47692 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmax" } } }, |
| 34084 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47693 | .unused, |
| 34085 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47694 | .unused, |
| 34086 | .unused, | 47695 | .unused, |
| 34087 | .unused, | 47696 | .unused, |
| 34088 | .unused, | 47697 | .unused, |
| 34089 | }, | 47698 | }, |
| 34090 | .dst_temps = .{.mem}, | 47699 | .dst_temps = .{.mem}, |
| 34091 | .clobbers = .{ .eflags = true }, | 47700 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34092 | .each = .{ .once = &.{ | 47701 | .each = .{ .once = &.{ |
| 34093 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47702 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 34094 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47703 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34095 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47704 | .{ ._, ._ps, .mova, .mem(.tmp2x), .tmp1x, ._, ._ }, |
| 34096 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_bit_size_rem_64), ._, ._ }, | 47705 | .{ ._, ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34097 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 47706 | .{ ._, ._ps, .mova, .memd(.tmp2x, 16), .tmp1x, ._, ._ }, |
| 34098 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47707 | .{ ._, ._ps, .mova, .tmp1x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34099 | .{ ._, ._, .bzhi, .tmp5q, .lea(.tmp1q), .tmp3q, ._ }, | 47708 | .{ ._, ._ps, .mova, .memd(.tmp2x, 16 * 2), .tmp1x, ._, ._ }, |
| 34100 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | 47709 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 34101 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, | 47710 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 34102 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, | 47711 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 34103 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 47712 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 47713 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34104 | } }, | 47714 | } }, |
| 34105 | }, .{ | 47715 | }, .{ |
| 34106 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47716 | .required_features = .{ .sse, null, null, null }, |
| 34107 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47717 | .src_constraints = .{ |
| 34108 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 47718 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 47719 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 47720 | .{ .scalar_float = .{ .of = .xword, .is = .xword } }, |
| | 47721 | }, |
| 34109 | .patterns = &.{ | 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 | .extra_temps = .{ | 47726 | .extra_temps = .{ |
| 34113 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47727 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34114 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47728 | .unused, |
| 34115 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47729 | .unused, |
| 34116 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47730 | .unused, |
| 34117 | .unused, | 47731 | .unused, |
| 34118 | .unused, | 47732 | .unused, |
| 34119 | .unused, | 47733 | .unused, |
| 34120 | .unused, | 47734 | .unused, |
| 34121 | .unused, | 47735 | .unused, |
| 34122 | }, | 47736 | }, |
| 34123 | .dst_temps = .{.mem}, | 47737 | .dst_temps = .{.{ .ref = .src0 }}, |
| 34124 | .clobbers = .{ .eflags = true }, | 47738 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34125 | .each = .{ .once = &.{ | 47739 | .each = .{ .once = &.{ |
| 34126 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47740 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 34139 | } }, | 47741 | } }, |
| 34140 | }, .{ | 47742 | }, .{ |
| 34141 | .required_features = .{ .@"64bit", null, null, null }, | 47743 | .required_features = .{ .avx, null, null, null }, |
| 34142 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47744 | .src_constraints = .{ |
| 34143 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }}, | 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 | .patterns = &.{ | 47749 | .patterns = &.{ |
| 34145 | .{ .src = .{ .to_mem, .none } }, | 47750 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34146 | }, | 47751 | }, |
| | 47752 | .call_frame = .{ .alignment = .@"16" }, |
| 34147 | .extra_temps = .{ | 47753 | .extra_temps = .{ |
| 34148 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47754 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34149 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47755 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 34150 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47756 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 34151 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47757 | .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, |
| 34152 | .unused, | 47758 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34153 | .unused, | 47759 | .unused, |
| 34154 | .unused, | 47760 | .unused, |
| 34155 | .unused, | 47761 | .unused, |
| 34156 | .unused, | 47762 | .unused, |
| 34157 | }, | 47763 | }, |
| 34158 | .dst_temps = .{.mem}, | 47764 | .dst_temps = .{.mem}, |
| 34159 | .clobbers = .{ .eflags = true }, | 47765 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34160 | .each = .{ .once = &.{ | 47766 | .each = .{ .once = &.{ |
| 34161 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47767 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 34162 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47768 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34163 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47769 | .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34164 | .{ .@"0:", ._, .mov, .tmp3d, .sia(-2, .dst0, .add_elem_size_div_8), ._, ._ }, | 47770 | .{ ._, .v_dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34165 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47771 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 34166 | .{ ._, ._, .mov, .tmp3q, .ua(.dst0, .add_umax), ._, ._ }, | 47772 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 34167 | .{ ._, ._, .@"and", .tmp3q, .lea(.tmp1q), ._, ._ }, | 47773 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 34168 | .{ ._, ._, .mov, .lea(.tmp2q), .tmp3q, ._, ._ }, | 47774 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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", ._, ._, ._ }, | | |
| 34174 | } }, | 47775 | } }, |
| 34175 | }, .{ | 47776 | }, .{ |
| 34176 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, | 47777 | .required_features = .{ .sse2, null, null, null }, |
| 34177 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47778 | .src_constraints = .{ |
| 34178 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, | 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 | .patterns = &.{ | 47783 | .patterns = &.{ |
| 34180 | .{ .src = .{ .to_mem, .none } }, | 47784 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34181 | }, | 47785 | }, |
| | 47786 | .call_frame = .{ .alignment = .@"16" }, |
| 34182 | .extra_temps = .{ | 47787 | .extra_temps = .{ |
| 34183 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47788 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34184 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47789 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 34185 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47790 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 34186 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47791 | .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, |
| 34187 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47792 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34188 | .unused, | 47793 | .unused, |
| 34189 | .unused, | 47794 | .unused, |
| 34190 | .unused, | 47795 | .unused, |
| 34191 | .unused, | 47796 | .unused, |
| 34192 | }, | 47797 | }, |
| 34193 | .dst_temps = .{.mem}, | 47798 | .dst_temps = .{.mem}, |
| 34194 | .clobbers = .{ .eflags = true }, | 47799 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34195 | .each = .{ .once = &.{ | 47800 | .each = .{ .once = &.{ |
| 34196 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47801 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 34197 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47802 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34198 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47803 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34199 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 47804 | .{ ._, ._dqa, .mov, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34200 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 47805 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 34201 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47806 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 34202 | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, | 47807 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 34203 | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, | 47808 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34204 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | | |
| 34205 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, | | |
| 34206 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | | |
| 34207 | .{ ._, ._a, .j, .@"0b", ._, ._, ._ }, | | |
| 34208 | } }, | 47809 | } }, |
| 34209 | }, .{ | 47810 | }, .{ |
| 34210 | .required_features = .{ .@"64bit", null, null, null }, | 47811 | .required_features = .{ .sse, null, null, null }, |
| 34211 | .src_constraints = .{ .any_scalar_unsigned_int, .any }, | 47812 | .src_constraints = .{ |
| 34212 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }}, | 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 | .patterns = &.{ | 47817 | .patterns = &.{ |
| 34214 | .{ .src = .{ .to_mem, .none } }, | 47818 | .{ .src = .{ .to_mem, .to_mem, .to_mem } }, |
| 34215 | }, | 47819 | }, |
| | 47820 | .call_frame = .{ .alignment = .@"16" }, |
| 34216 | .extra_temps = .{ | 47821 | .extra_temps = .{ |
| 34217 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 47822 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 34218 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 47823 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 34219 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 47824 | .{ .type = .f128, .kind = .{ .reg = .xmm1 } }, |
| 34220 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 47825 | .{ .type = .f128, .kind = .{ .reg = .xmm2 } }, |
| 34221 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 47826 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaq" } } }, |
| 34222 | .unused, | 47827 | .unused, |
| 34223 | .unused, | 47828 | .unused, |
| 34224 | .unused, | 47829 | .unused, |
| 34225 | .unused, | 47830 | .unused, |
| 34226 | }, | 47831 | }, |
| 34227 | .dst_temps = .{.mem}, | 47832 | .dst_temps = .{.mem}, |
| 34228 | .clobbers = .{ .eflags = true }, | 47833 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 34229 | .each = .{ .once = &.{ | 47834 | .each = .{ .once = &.{ |
| 34230 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_len), ._, ._ }, | 47835 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 34231 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, | 47836 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34232 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, | 47837 | .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34233 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, | 47838 | .{ ._, ._ps, .mova, .tmp3x, .memia(.src2x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 34234 | .{ .@"0:", ._, .mov, .tmp4d, .sia(-1, .dst0, .add_elem_size_div_8), ._, ._ }, | 47839 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 34235 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, | 47840 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 34236 | .{ ._, ._, .mov, .tmp4q, .ua(.dst0, .add_umax), ._, ._ }, | 47841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 34237 | .{ ._, ._, .@"and", .tmp4q, .lea(.tmp1q), ._, ._ }, | 47842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 34238 | .{ ._, ._sq, .sto, ._, ._, ._, ._ }, | | |
| 34239 | .{ ._, ._, .add, .tmp1p, .sia2(8, .src0, .dst0, .add_delta_elem_size), ._, ._ }, | | |
| 34240 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, | | |
| 34241 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 34242 | } }, | 47843 | } }, |
| 34243 | } }) catch |err| switch (err) { | 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 | @tagName(air_tag), | 47846 | @tagName(air_tag), |
| 34246 | ty_op.ty.toType().fmt(pt), | 47847 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 34247 | cg.typeOf(ty_op.operand).fmt(pt), | | |
| 34248 | ops[0].tracking(cg), | 47848 | ops[0].tracking(cg), |
| | 47849 | ops[1].tracking(cg), |
| | 47850 | ops[2].tracking(cg), |
| 34249 | }), | 47851 | }), |
| 34250 | else => |e| return e, | 47852 | else => |e| return e, |
| 34251 | }; | 47853 | }; |
| 34252 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 47854 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs, pl_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); | | |
| 34631 | }, | 47855 | }, |
| 34632 | .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else { | 47856 | .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else { |
| 34633 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 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,7 +52789,7 @@ fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: bits.RoundM |
| 39565 | .param_types = &.{ty.toIntern()}, | 52789 | .param_types = &.{ty.toIntern()}, |
| 39566 | .callee = std.fmt.bufPrint(&callee_buf, "{s}{s}{s}", .{ | 52790 | .callee = std.fmt.bufPrint(&callee_buf, "{s}{s}{s}", .{ |
| 39567 | floatLibcAbiPrefix(ty), | 52791 | floatLibcAbiPrefix(ty), |
| 39568 | switch (mode.mode) { | 52792 | switch (mode.direction) { |
| 39569 | .down => "floor", | 52793 | .down => "floor", |
| 39570 | .up => "ceil", | 52794 | .up => "ceil", |
| 39571 | .zero => "trunc", | 52795 | .zero => "trunc", |
| ... | @@ -42209,7 +55433,7 @@ fn genBinOp( | ... | @@ -42209,7 +55433,7 @@ fn genBinOp( |
| 42209 | } }, &.{ lhs_ty, rhs_ty }, &.{ adjusted, .{ .air_ref = rhs_air } }, .{}); | 55433 | } }, &.{ lhs_ty, rhs_ty }, &.{ adjusted, .{ .air_ref = rhs_air } }, .{}); |
| 42210 | }, | 55434 | }, |
| 42211 | .div_trunc, .div_floor => try self.genRoundLibcall(lhs_ty, result, .{ | 55435 | .div_trunc, .div_floor => try self.genRoundLibcall(lhs_ty, result, .{ |
| 42212 | .mode = switch (air_tag) { | 55436 | .direction = switch (air_tag) { |
| 42213 | .div_trunc => .zero, | 55437 | .div_trunc => .zero, |
| 42214 | .div_floor => .down, | 55438 | .div_floor => .down, |
| 42215 | else => unreachable, | 55439 | else => unreachable, |
| ... | @@ -42667,7 +55891,7 @@ fn genBinOp( | ... | @@ -42667,7 +55891,7 @@ fn genBinOp( |
| 42667 | dst_reg, | 55891 | dst_reg, |
| 42668 | dst_reg, | 55892 | dst_reg, |
| 42669 | bits.RoundMode.imm(.{ | 55893 | bits.RoundMode.imm(.{ |
| 42670 | .mode = switch (air_tag) { | 55894 | .direction = switch (air_tag) { |
| 42671 | .div_trunc => .zero, | 55895 | .div_trunc => .zero, |
| 42672 | .div_floor => .down, | 55896 | .div_floor => .down, |
| 42673 | else => unreachable, | 55897 | else => unreachable, |
| ... | @@ -43469,7 +56693,7 @@ fn genBinOp( | ... | @@ -43469,7 +56693,7 @@ fn genBinOp( |
| 43469 | switch (air_tag) { | 56693 | switch (air_tag) { |
| 43470 | .add, .add_wrap, .sub, .sub_wrap, .mul, .mul_wrap, .div_float, .div_exact => {}, | 56694 | .add, .add_wrap, .sub, .sub_wrap, .mul, .mul_wrap, .div_float, .div_exact => {}, |
| 43471 | .div_trunc, .div_floor => try self.genRound(lhs_ty, dst_reg, .{ .register = dst_reg }, .{ | 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 | .div_trunc => .zero, | 56697 | .div_trunc => .zero, |
| 43474 | .div_floor => .down, | 56698 | .div_floor => .down, |
| 43475 | else => unreachable, | 56699 | else => unreachable, |
| ... | @@ -51237,10 +64461,17 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -51237,10 +64461,17 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 51237 | const acc_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); | 64461 | const acc_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 51238 | const acc_lock = self.register_manager.lockRegAssumeUnused(acc_reg); | 64462 | const acc_lock = self.register_manager.lockRegAssumeUnused(acc_reg); |
| 51239 | defer self.register_manager.unlockReg(acc_lock); | 64463 | defer self.register_manager.unlockReg(acc_lock); |
| 51240 | var limb_offset: i31 = 0; | 64464 | var limb_offset: i31 = @intCast((mask_len - 1) / 64 * 8); |
| 51241 | while (limb_offset < abi_size) : (limb_offset += 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 | try self.asmRegisterMemory( | 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 | .Or => .@"or", | 64475 | .Or => .@"or", |
| 51245 | .And => .@"and", | 64476 | .And => .@"and", |
| 51246 | else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), | 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,6 +64482,8 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 51251 | .disp = limb_offset, | 64482 | .disp = limb_offset, |
| 51252 | }), | 64483 | }), |
| 51253 | ); | 64484 | ); |
| | 64485 | if (limb_offset == 0) break; |
| | 64486 | first = false; |
| 51254 | } | 64487 | } |
| 51255 | switch (reduce.operation) { | 64488 | switch (reduce.operation) { |
| 51256 | .Or => { | 64489 | .Or => { |
| ... | @@ -53741,11 +66974,11 @@ const Temp = struct { | ... | @@ -53741,11 +66974,11 @@ const Temp = struct { |
| 53741 | }; | 66974 | }; |
| 53742 | if (commute) std.mem.swap(Temp, &ops[0], &ops[1]); | 66975 | if (commute) std.mem.swap(Temp, &ops[0], &ops[1]); |
| 53743 | try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ | 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 | .patterns = &.{ | 66978 | .patterns = &.{ |
| 53746 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, | 66979 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53747 | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, | 66980 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53748 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 66981 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53749 | }, | 66982 | }, |
| 53750 | .dst_temps = .{.{ .cc = .g }}, | 66983 | .dst_temps = .{.{ .cc = .g }}, |
| 53751 | .clobbers = .{ .eflags = true }, | 66984 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53753,12 +66986,12 @@ const Temp = struct { | ... | @@ -53753,12 +66986,12 @@ const Temp = struct { |
| 53753 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 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 | .patterns = &.{ | 66990 | .patterns = &.{ |
| 53758 | .{ .src = .{ .mem, .imm8 } }, | 66991 | .{ .src = .{ .mem, .imm8, .none } }, |
| 53759 | .{ .src = .{ .to_gpr, .imm8 } }, | 66992 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 53760 | .{ .src = .{ .to_gpr, .mem } }, | 66993 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53761 | .{ .src = .{ .to_gpr, .to_gpr } }, | 66994 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53762 | }, | 66995 | }, |
| 53763 | .dst_temps = .{.{ .cc = .l }}, | 66996 | .dst_temps = .{.{ .cc = .l }}, |
| 53764 | .clobbers = .{ .eflags = true }, | 66997 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53766,11 +66999,11 @@ const Temp = struct { | ... | @@ -53766,11 +66999,11 @@ const Temp = struct { |
| 53766 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 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 | .patterns = &.{ | 67003 | .patterns = &.{ |
| 53771 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, | 67004 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53772 | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, | 67005 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53773 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67006 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53774 | }, | 67007 | }, |
| 53775 | .dst_temps = .{.{ .cc = .a }}, | 67008 | .dst_temps = .{.{ .cc = .a }}, |
| 53776 | .clobbers = .{ .eflags = true }, | 67009 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53778,12 +67011,12 @@ const Temp = struct { | ... | @@ -53778,12 +67011,12 @@ const Temp = struct { |
| 53778 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 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 | .patterns = &.{ | 67015 | .patterns = &.{ |
| 53783 | .{ .src = .{ .mem, .imm8 } }, | 67016 | .{ .src = .{ .mem, .imm8, .none } }, |
| 53784 | .{ .src = .{ .to_gpr, .imm8 } }, | 67017 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 53785 | .{ .src = .{ .to_gpr, .mem } }, | 67018 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53786 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67019 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53787 | }, | 67020 | }, |
| 53788 | .dst_temps = .{.{ .cc = .b }}, | 67021 | .dst_temps = .{.{ .cc = .b }}, |
| 53789 | .clobbers = .{ .eflags = true }, | 67022 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53791,11 +67024,11 @@ const Temp = struct { | ... | @@ -53791,11 +67024,11 @@ const Temp = struct { |
| 53791 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 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 | .patterns = &.{ | 67028 | .patterns = &.{ |
| 53796 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, | 67029 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53797 | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, | 67030 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53798 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67031 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53799 | }, | 67032 | }, |
| 53800 | .dst_temps = .{.{ .cc = .g }}, | 67033 | .dst_temps = .{.{ .cc = .g }}, |
| 53801 | .clobbers = .{ .eflags = true }, | 67034 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53803,12 +67036,12 @@ const Temp = struct { | ... | @@ -53803,12 +67036,12 @@ const Temp = struct { |
| 53803 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 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 | .patterns = &.{ | 67040 | .patterns = &.{ |
| 53808 | .{ .src = .{ .mem, .imm16 } }, | 67041 | .{ .src = .{ .mem, .imm16, .none } }, |
| 53809 | .{ .src = .{ .to_gpr, .imm16 } }, | 67042 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| 53810 | .{ .src = .{ .to_gpr, .mem } }, | 67043 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53811 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67044 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53812 | }, | 67045 | }, |
| 53813 | .dst_temps = .{.{ .cc = .l }}, | 67046 | .dst_temps = .{.{ .cc = .l }}, |
| 53814 | .clobbers = .{ .eflags = true }, | 67047 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53816,11 +67049,11 @@ const Temp = struct { | ... | @@ -53816,11 +67049,11 @@ const Temp = struct { |
| 53816 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 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 | .patterns = &.{ | 67053 | .patterns = &.{ |
| 53821 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, | 67054 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53822 | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, | 67055 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53823 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67056 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53824 | }, | 67057 | }, |
| 53825 | .dst_temps = .{.{ .cc = .a }}, | 67058 | .dst_temps = .{.{ .cc = .a }}, |
| 53826 | .clobbers = .{ .eflags = true }, | 67059 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53828,12 +67061,12 @@ const Temp = struct { | ... | @@ -53828,12 +67061,12 @@ const Temp = struct { |
| 53828 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 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 | .patterns = &.{ | 67065 | .patterns = &.{ |
| 53833 | .{ .src = .{ .mem, .imm16 } }, | 67066 | .{ .src = .{ .mem, .imm16, .none } }, |
| 53834 | .{ .src = .{ .to_gpr, .imm16 } }, | 67067 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| 53835 | .{ .src = .{ .to_gpr, .mem } }, | 67068 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53836 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67069 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53837 | }, | 67070 | }, |
| 53838 | .dst_temps = .{.{ .cc = .b }}, | 67071 | .dst_temps = .{.{ .cc = .b }}, |
| 53839 | .clobbers = .{ .eflags = true }, | 67072 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53841,11 +67074,11 @@ const Temp = struct { | ... | @@ -53841,11 +67074,11 @@ const Temp = struct { |
| 53841 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 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 | .patterns = &.{ | 67078 | .patterns = &.{ |
| 53846 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, | 67079 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53847 | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, | 67080 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53848 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67081 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53849 | }, | 67082 | }, |
| 53850 | .dst_temps = .{.{ .cc = .g }}, | 67083 | .dst_temps = .{.{ .cc = .g }}, |
| 53851 | .clobbers = .{ .eflags = true }, | 67084 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53853,12 +67086,12 @@ const Temp = struct { | ... | @@ -53853,12 +67086,12 @@ const Temp = struct { |
| 53853 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 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 | .patterns = &.{ | 67090 | .patterns = &.{ |
| 53858 | .{ .src = .{ .mem, .imm32 } }, | 67091 | .{ .src = .{ .mem, .imm32, .none } }, |
| 53859 | .{ .src = .{ .to_gpr, .imm32 } }, | 67092 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| 53860 | .{ .src = .{ .to_gpr, .mem } }, | 67093 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53861 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67094 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53862 | }, | 67095 | }, |
| 53863 | .dst_temps = .{.{ .cc = .l }}, | 67096 | .dst_temps = .{.{ .cc = .l }}, |
| 53864 | .clobbers = .{ .eflags = true }, | 67097 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53866,11 +67099,11 @@ const Temp = struct { | ... | @@ -53866,11 +67099,11 @@ const Temp = struct { |
| 53866 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 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 | .patterns = &.{ | 67103 | .patterns = &.{ |
| 53871 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, | 67104 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53872 | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, | 67105 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53873 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67106 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53874 | }, | 67107 | }, |
| 53875 | .dst_temps = .{.{ .cc = .a }}, | 67108 | .dst_temps = .{.{ .cc = .a }}, |
| 53876 | .clobbers = .{ .eflags = true }, | 67109 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53878,12 +67111,12 @@ const Temp = struct { | ... | @@ -53878,12 +67111,12 @@ const Temp = struct { |
| 53878 | .{ ._, ._, .cmp, .src0d, .src1d, ._, ._ }, | 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 | .patterns = &.{ | 67115 | .patterns = &.{ |
| 53883 | .{ .src = .{ .mem, .imm32 } }, | 67116 | .{ .src = .{ .mem, .imm32, .none } }, |
| 53884 | .{ .src = .{ .to_gpr, .imm32 } }, | 67117 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| 53885 | .{ .src = .{ .to_gpr, .mem } }, | 67118 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53886 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67119 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53887 | }, | 67120 | }, |
| 53888 | .dst_temps = .{.{ .cc = .b }}, | 67121 | .dst_temps = .{.{ .cc = .b }}, |
| 53889 | .clobbers = .{ .eflags = true }, | 67122 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53892,11 +67125,11 @@ const Temp = struct { | ... | @@ -53892,11 +67125,11 @@ const Temp = struct { |
| 53892 | } }, | 67125 | } }, |
| 53893 | }, .{ | 67126 | }, .{ |
| 53894 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 67129 | .patterns = &.{ |
| 53897 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, | 67130 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53898 | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, | 67131 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53899 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67132 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53900 | }, | 67133 | }, |
| 53901 | .dst_temps = .{.{ .cc = .g }}, | 67134 | .dst_temps = .{.{ .cc = .g }}, |
| 53902 | .clobbers = .{ .eflags = true }, | 67135 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53905,12 +67138,12 @@ const Temp = struct { | ... | @@ -53905,12 +67138,12 @@ const Temp = struct { |
| 53905 | } }, | 67138 | } }, |
| 53906 | }, .{ | 67139 | }, .{ |
| 53907 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 67142 | .patterns = &.{ |
| 53910 | .{ .src = .{ .mem, .simm32 } }, | 67143 | .{ .src = .{ .mem, .simm32, .none } }, |
| 53911 | .{ .src = .{ .to_gpr, .simm32 } }, | 67144 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 53912 | .{ .src = .{ .to_gpr, .mem } }, | 67145 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53913 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67146 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53914 | }, | 67147 | }, |
| 53915 | .dst_temps = .{.{ .cc = .l }}, | 67148 | .dst_temps = .{.{ .cc = .l }}, |
| 53916 | .clobbers = .{ .eflags = true }, | 67149 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53919,11 +67152,11 @@ const Temp = struct { | ... | @@ -53919,11 +67152,11 @@ const Temp = struct { |
| 53919 | } }, | 67152 | } }, |
| 53920 | }, .{ | 67153 | }, .{ |
| 53921 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 67156 | .patterns = &.{ |
| 53924 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, | 67157 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 53925 | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, | 67158 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53926 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67159 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 53927 | }, | 67160 | }, |
| 53928 | .dst_temps = .{.{ .cc = .a }}, | 67161 | .dst_temps = .{.{ .cc = .a }}, |
| 53929 | .clobbers = .{ .eflags = true }, | 67162 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53932,12 +67165,12 @@ const Temp = struct { | ... | @@ -53932,12 +67165,12 @@ const Temp = struct { |
| 53932 | } }, | 67165 | } }, |
| 53933 | }, .{ | 67166 | }, .{ |
| 53934 | .required_features = .{ .@"64bit", null, null, null }, | 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 | .patterns = &.{ | 67169 | .patterns = &.{ |
| 53937 | .{ .src = .{ .mem, .simm32 } }, | 67170 | .{ .src = .{ .mem, .simm32, .none } }, |
| 53938 | .{ .src = .{ .to_gpr, .simm32 } }, | 67171 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 53939 | .{ .src = .{ .to_gpr, .mem } }, | 67172 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 53940 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67173 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 53941 | }, | 67174 | }, |
| 53942 | .dst_temps = .{.{ .cc = .b }}, | 67175 | .dst_temps = .{.{ .cc = .b }}, |
| 53943 | .clobbers = .{ .eflags = true }, | 67176 | .clobbers = .{ .eflags = true }, |
| ... | @@ -53949,9 +67182,10 @@ const Temp = struct { | ... | @@ -53949,9 +67182,10 @@ const Temp = struct { |
| 53949 | .src_constraints = .{ | 67182 | .src_constraints = .{ |
| 53950 | .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, | 67183 | .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, |
| 53951 | .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, | 67184 | .{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 67185 | .any, |
| 53952 | }, | 67186 | }, |
| 53953 | .patterns = &.{ | 67187 | .patterns = &.{ |
| 53954 | .{ .src = .{ .to_mem, .to_mem } }, | 67188 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 53955 | }, | 67189 | }, |
| 53956 | .extra_temps = .{ | 67190 | .extra_temps = .{ |
| 53957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67191 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -53981,9 +67215,10 @@ const Temp = struct { | ... | @@ -53981,9 +67215,10 @@ const Temp = struct { |
| 53981 | .src_constraints = .{ | 67215 | .src_constraints = .{ |
| 53982 | .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, | 67216 | .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 53983 | .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, | 67217 | .{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 67218 | .any, |
| 53984 | }, | 67219 | }, |
| 53985 | .patterns = &.{ | 67220 | .patterns = &.{ |
| 53986 | .{ .src = .{ .to_mem, .to_mem } }, | 67221 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 53987 | }, | 67222 | }, |
| 53988 | .extra_temps = .{ | 67223 | .extra_temps = .{ |
| 53989 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67224 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54010,9 +67245,10 @@ const Temp = struct { | ... | @@ -54010,9 +67245,10 @@ const Temp = struct { |
| 54010 | .src_constraints = .{ | 67245 | .src_constraints = .{ |
| 54011 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, | 67246 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 54012 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, | 67247 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 67248 | .any, |
| 54013 | }, | 67249 | }, |
| 54014 | .patterns = &.{ | 67250 | .patterns = &.{ |
| 54015 | .{ .src = .{ .to_mem, .to_mem } }, | 67251 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54016 | }, | 67252 | }, |
| 54017 | .extra_temps = .{ | 67253 | .extra_temps = .{ |
| 54018 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67254 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54041,9 +67277,10 @@ const Temp = struct { | ... | @@ -54041,9 +67277,10 @@ const Temp = struct { |
| 54041 | .src_constraints = .{ | 67277 | .src_constraints = .{ |
| 54042 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, | 67278 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 54043 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, | 67279 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 67280 | .any, |
| 54044 | }, | 67281 | }, |
| 54045 | .patterns = &.{ | 67282 | .patterns = &.{ |
| 54046 | .{ .src = .{ .to_mem, .to_mem } }, | 67283 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54047 | }, | 67284 | }, |
| 54048 | .extra_temps = .{ | 67285 | .extra_temps = .{ |
| 54049 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67286 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54071,15 +67308,15 @@ const Temp = struct { | ... | @@ -54071,15 +67308,15 @@ const Temp = struct { |
| 54071 | }, | 67308 | }, |
| 54072 | .eq, .neq => { | 67309 | .eq, .neq => { |
| 54073 | try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ | 67310 | try cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ |
| 54074 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte } }, | 67311 | .src_constraints = .{ .{ .int = .byte }, .{ .int = .byte }, .any }, |
| 54075 | .patterns = &.{ | 67312 | .patterns = &.{ |
| 54076 | .{ .src = .{ .mem, .imm8 } }, | 67313 | .{ .src = .{ .mem, .imm8, .none } }, |
| 54077 | .{ .src = .{ .imm8, .mem }, .commute = .{ 0, 1 } }, | 67314 | .{ .src = .{ .imm8, .mem, .none }, .commute = .{ 0, 1 } }, |
| 54078 | .{ .src = .{ .to_gpr, .imm8 } }, | 67315 | .{ .src = .{ .to_gpr, .imm8, .none } }, |
| 54079 | .{ .src = .{ .imm8, .to_gpr }, .commute = .{ 0, 1 } }, | 67316 | .{ .src = .{ .imm8, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54080 | .{ .src = .{ .to_gpr, .mem } }, | 67317 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 54081 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67318 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54082 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67319 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54083 | }, | 67320 | }, |
| 54084 | .dst_temps = .{.{ .cc = .e }}, | 67321 | .dst_temps = .{.{ .cc = .e }}, |
| 54085 | .clobbers = .{ .eflags = true }, | 67322 | .clobbers = .{ .eflags = true }, |
| ... | @@ -54087,15 +67324,15 @@ const Temp = struct { | ... | @@ -54087,15 +67324,15 @@ const Temp = struct { |
| 54087 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, | 67324 | .{ ._, ._, .cmp, .src0b, .src1b, ._, ._ }, |
| 54088 | } }, | 67325 | } }, |
| 54089 | }, .{ | 67326 | }, .{ |
| 54090 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word } }, | 67327 | .src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any }, |
| 54091 | .patterns = &.{ | 67328 | .patterns = &.{ |
| 54092 | .{ .src = .{ .mem, .imm16 } }, | 67329 | .{ .src = .{ .mem, .imm16, .none } }, |
| 54093 | .{ .src = .{ .imm16, .mem }, .commute = .{ 0, 1 } }, | 67330 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| 54094 | .{ .src = .{ .to_gpr, .imm16 } }, | 67331 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| 54095 | .{ .src = .{ .imm16, .to_gpr }, .commute = .{ 0, 1 } }, | 67332 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54096 | .{ .src = .{ .to_gpr, .mem } }, | 67333 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 54097 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67334 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54098 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67335 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54099 | }, | 67336 | }, |
| 54100 | .dst_temps = .{.{ .cc = .e }}, | 67337 | .dst_temps = .{.{ .cc = .e }}, |
| 54101 | .clobbers = .{ .eflags = true }, | 67338 | .clobbers = .{ .eflags = true }, |
| ... | @@ -54103,15 +67340,15 @@ const Temp = struct { | ... | @@ -54103,15 +67340,15 @@ const Temp = struct { |
| 54103 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, | 67340 | .{ ._, ._, .cmp, .src0w, .src1w, ._, ._ }, |
| 54104 | } }, | 67341 | } }, |
| 54105 | }, .{ | 67342 | }, .{ |
| 54106 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword } }, | 67343 | .src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any }, |
| 54107 | .patterns = &.{ | 67344 | .patterns = &.{ |
| 54108 | .{ .src = .{ .mem, .imm32 } }, | 67345 | .{ .src = .{ .mem, .imm32, .none } }, |
| 54109 | .{ .src = .{ .imm32, .mem }, .commute = .{ 0, 1 } }, | 67346 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 54110 | .{ .src = .{ .to_gpr, .imm32 } }, | 67347 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| 54111 | .{ .src = .{ .imm32, .to_gpr }, .commute = .{ 0, 1 } }, | 67348 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54112 | .{ .src = .{ .to_gpr, .mem } }, | 67349 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 54113 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67350 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54114 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67351 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54115 | }, | 67352 | }, |
| 54116 | .dst_temps = .{.{ .cc = .e }}, | 67353 | .dst_temps = .{.{ .cc = .e }}, |
| 54117 | .clobbers = .{ .eflags = true }, | 67354 | .clobbers = .{ .eflags = true }, |
| ... | @@ -54120,15 +67357,15 @@ const Temp = struct { | ... | @@ -54120,15 +67357,15 @@ const Temp = struct { |
| 54120 | } }, | 67357 | } }, |
| 54121 | }, .{ | 67358 | }, .{ |
| 54122 | .required_features = .{ .@"64bit", null, null, null }, | 67359 | .required_features = .{ .@"64bit", null, null, null }, |
| 54123 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 67360 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any }, |
| 54124 | .patterns = &.{ | 67361 | .patterns = &.{ |
| 54125 | .{ .src = .{ .mem, .simm32 } }, | 67362 | .{ .src = .{ .mem, .simm32, .none } }, |
| 54126 | .{ .src = .{ .simm32, .mem }, .commute = .{ 0, 1 } }, | 67363 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| 54127 | .{ .src = .{ .to_gpr, .simm32 } }, | 67364 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| 54128 | .{ .src = .{ .simm32, .to_gpr }, .commute = .{ 0, 1 } }, | 67365 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54129 | .{ .src = .{ .to_gpr, .mem } }, | 67366 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 54130 | .{ .src = .{ .mem, .to_gpr }, .commute = .{ 0, 1 } }, | 67367 | .{ .src = .{ .mem, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| 54131 | .{ .src = .{ .to_gpr, .to_gpr } }, | 67368 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 54132 | }, | 67369 | }, |
| 54133 | .dst_temps = .{.{ .cc = .e }}, | 67370 | .dst_temps = .{.{ .cc = .e }}, |
| 54134 | .clobbers = .{ .eflags = true }, | 67371 | .clobbers = .{ .eflags = true }, |
| ... | @@ -54137,11 +67374,11 @@ const Temp = struct { | ... | @@ -54137,11 +67374,11 @@ const Temp = struct { |
| 54137 | } }, | 67374 | } }, |
| 54138 | }, .{ | 67375 | }, .{ |
| 54139 | .required_features = .{ .sse, .mmx, null, null }, | 67376 | .required_features = .{ .sse, .mmx, null, null }, |
| 54140 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword } }, | 67377 | .src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any }, |
| 54141 | .patterns = &.{ | 67378 | .patterns = &.{ |
| 54142 | .{ .src = .{ .to_mut_mm, .mem } }, | 67379 | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 54143 | .{ .src = .{ .mem, .to_mut_mm }, .commute = .{ 0, 1 } }, | 67380 | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 54144 | .{ .src = .{ .to_mut_mm, .to_mm } }, | 67381 | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 54145 | }, | 67382 | }, |
| 54146 | .extra_temps = .{ | 67383 | .extra_temps = .{ |
| 54147 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 67384 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54165,11 +67402,11 @@ const Temp = struct { | ... | @@ -54165,11 +67402,11 @@ const Temp = struct { |
| 54165 | } }, | 67402 | } }, |
| 54166 | }, .{ | 67403 | }, .{ |
| 54167 | .required_features = .{ .avx, null, null, null }, | 67404 | .required_features = .{ .avx, null, null, null }, |
| 54168 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, | 67405 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54169 | .patterns = &.{ | 67406 | .patterns = &.{ |
| 54170 | .{ .src = .{ .to_xmm, .mem } }, | 67407 | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 54171 | .{ .src = .{ .mem, .to_xmm }, .commute = .{ 0, 1 } }, | 67408 | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 54172 | .{ .src = .{ .to_xmm, .to_xmm } }, | 67409 | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 54173 | }, | 67410 | }, |
| 54174 | .extra_temps = .{ | 67411 | .extra_temps = .{ |
| 54175 | .{ .kind = .{ .rc = .sse } }, | 67412 | .{ .kind = .{ .rc = .sse } }, |
| ... | @@ -54190,11 +67427,11 @@ const Temp = struct { | ... | @@ -54190,11 +67427,11 @@ const Temp = struct { |
| 54190 | } }, | 67427 | } }, |
| 54191 | }, .{ | 67428 | }, .{ |
| 54192 | .required_features = .{ .sse4_1, null, null, null }, | 67429 | .required_features = .{ .sse4_1, null, null, null }, |
| 54193 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, | 67430 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54194 | .patterns = &.{ | 67431 | .patterns = &.{ |
| 54195 | .{ .src = .{ .to_mut_xmm, .mem } }, | 67432 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 54196 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 67433 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 54197 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 67434 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 54198 | }, | 67435 | }, |
| 54199 | .dst_temps = .{.{ .cc = .z }}, | 67436 | .dst_temps = .{.{ .cc = .z }}, |
| 54200 | .clobbers = .{ .eflags = true }, | 67437 | .clobbers = .{ .eflags = true }, |
| ... | @@ -54204,11 +67441,11 @@ const Temp = struct { | ... | @@ -54204,11 +67441,11 @@ const Temp = struct { |
| 54204 | } }, | 67441 | } }, |
| 54205 | }, .{ | 67442 | }, .{ |
| 54206 | .required_features = .{ .sse2, .fast_imm16, null, null }, | 67443 | .required_features = .{ .sse2, .fast_imm16, null, null }, |
| 54207 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, | 67444 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54208 | .patterns = &.{ | 67445 | .patterns = &.{ |
| 54209 | .{ .src = .{ .to_mut_xmm, .mem } }, | 67446 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 54210 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 67447 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 54211 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 67448 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 54212 | }, | 67449 | }, |
| 54213 | .extra_temps = .{ | 67450 | .extra_temps = .{ |
| 54214 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 67451 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54232,11 +67469,11 @@ const Temp = struct { | ... | @@ -54232,11 +67469,11 @@ const Temp = struct { |
| 54232 | } }, | 67469 | } }, |
| 54233 | }, .{ | 67470 | }, .{ |
| 54234 | .required_features = .{ .sse2, null, null, null }, | 67471 | .required_features = .{ .sse2, null, null, null }, |
| 54235 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword } }, | 67472 | .src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any }, |
| 54236 | .patterns = &.{ | 67473 | .patterns = &.{ |
| 54237 | .{ .src = .{ .to_mut_xmm, .mem } }, | 67474 | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 54238 | .{ .src = .{ .mem, .to_mut_xmm }, .commute = .{ 0, 1 } }, | 67475 | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 54239 | .{ .src = .{ .to_mut_xmm, .to_xmm } }, | 67476 | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 54240 | }, | 67477 | }, |
| 54241 | .extra_temps = .{ | 67478 | .extra_temps = .{ |
| 54242 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 67479 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54260,11 +67497,11 @@ const Temp = struct { | ... | @@ -54260,11 +67497,11 @@ const Temp = struct { |
| 54260 | } }, | 67497 | } }, |
| 54261 | }, .{ | 67498 | }, .{ |
| 54262 | .required_features = .{ .avx2, null, null, null }, | 67499 | .required_features = .{ .avx2, null, null, null }, |
| 54263 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword } }, | 67500 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword }, .any }, |
| 54264 | .patterns = &.{ | 67501 | .patterns = &.{ |
| 54265 | .{ .src = .{ .to_ymm, .mem } }, | 67502 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 54266 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 67503 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 54267 | .{ .src = .{ .to_ymm, .to_ymm } }, | 67504 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 54268 | }, | 67505 | }, |
| 54269 | .extra_temps = .{ | 67506 | .extra_temps = .{ |
| 54270 | .{ .kind = .{ .rc = .sse } }, | 67507 | .{ .kind = .{ .rc = .sse } }, |
| ... | @@ -54285,11 +67522,11 @@ const Temp = struct { | ... | @@ -54285,11 +67522,11 @@ const Temp = struct { |
| 54285 | } }, | 67522 | } }, |
| 54286 | }, .{ | 67523 | }, .{ |
| 54287 | .required_features = .{ .avx, null, null, null }, | 67524 | .required_features = .{ .avx, null, null, null }, |
| 54288 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword } }, | 67525 | .src_constraints = .{ .{ .int = .yword }, .{ .int = .yword }, .any }, |
| 54289 | .patterns = &.{ | 67526 | .patterns = &.{ |
| 54290 | .{ .src = .{ .to_ymm, .mem } }, | 67527 | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 54291 | .{ .src = .{ .mem, .to_ymm }, .commute = .{ 0, 1 } }, | 67528 | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 54292 | .{ .src = .{ .to_ymm, .to_ymm } }, | 67529 | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 54293 | }, | 67530 | }, |
| 54294 | .extra_temps = .{ | 67531 | .extra_temps = .{ |
| 54295 | .{ .kind = .{ .rc = .sse } }, | 67532 | .{ .kind = .{ .rc = .sse } }, |
| ... | @@ -54313,9 +67550,10 @@ const Temp = struct { | ... | @@ -54313,9 +67550,10 @@ const Temp = struct { |
| 54313 | .src_constraints = .{ | 67550 | .src_constraints = .{ |
| 54314 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, | 67551 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| 54315 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, | 67552 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| | 67553 | .any, |
| 54316 | }, | 67554 | }, |
| 54317 | .patterns = &.{ | 67555 | .patterns = &.{ |
| 54318 | .{ .src = .{ .to_mem, .to_mem } }, | 67556 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54319 | }, | 67557 | }, |
| 54320 | .extra_temps = .{ | 67558 | .extra_temps = .{ |
| 54321 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54347,9 +67585,10 @@ const Temp = struct { | ... | @@ -54347,9 +67585,10 @@ const Temp = struct { |
| 54347 | .src_constraints = .{ | 67585 | .src_constraints = .{ |
| 54348 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, | 67586 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| 54349 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, | 67587 | .{ .remainder_int = .{ .of = .yword, .is = .xword } }, |
| | 67588 | .any, |
| 54350 | }, | 67589 | }, |
| 54351 | .patterns = &.{ | 67590 | .patterns = &.{ |
| 54352 | .{ .src = .{ .to_mem, .to_mem } }, | 67591 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54353 | }, | 67592 | }, |
| 54354 | .extra_temps = .{ | 67593 | .extra_temps = .{ |
| 54355 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67594 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54381,9 +67620,10 @@ const Temp = struct { | ... | @@ -54381,9 +67620,10 @@ const Temp = struct { |
| 54381 | .src_constraints = .{ | 67620 | .src_constraints = .{ |
| 54382 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, | 67621 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| 54383 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, | 67622 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| | 67623 | .any, |
| 54384 | }, | 67624 | }, |
| 54385 | .patterns = &.{ | 67625 | .patterns = &.{ |
| 54386 | .{ .src = .{ .to_mem, .to_mem } }, | 67626 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54387 | }, | 67627 | }, |
| 54388 | .extra_temps = .{ | 67628 | .extra_temps = .{ |
| 54389 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67629 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54412,9 +67652,10 @@ const Temp = struct { | ... | @@ -54412,9 +67652,10 @@ const Temp = struct { |
| 54412 | .src_constraints = .{ | 67652 | .src_constraints = .{ |
| 54413 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, | 67653 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| 54414 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, | 67654 | .{ .remainder_int = .{ .of = .yword, .is = .yword } }, |
| | 67655 | .any, |
| 54415 | }, | 67656 | }, |
| 54416 | .patterns = &.{ | 67657 | .patterns = &.{ |
| 54417 | .{ .src = .{ .to_mem, .to_mem } }, | 67658 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54418 | }, | 67659 | }, |
| 54419 | .extra_temps = .{ | 67660 | .extra_temps = .{ |
| 54420 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67661 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54443,9 +67684,10 @@ const Temp = struct { | ... | @@ -54443,9 +67684,10 @@ const Temp = struct { |
| 54443 | .src_constraints = .{ | 67684 | .src_constraints = .{ |
| 54444 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67685 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54445 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67686 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| | 67687 | .any, |
| 54446 | }, | 67688 | }, |
| 54447 | .patterns = &.{ | 67689 | .patterns = &.{ |
| 54448 | .{ .src = .{ .to_mem, .to_mem } }, | 67690 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54449 | }, | 67691 | }, |
| 54450 | .extra_temps = .{ | 67692 | .extra_temps = .{ |
| 54451 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67693 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54474,9 +67716,10 @@ const Temp = struct { | ... | @@ -54474,9 +67716,10 @@ const Temp = struct { |
| 54474 | .src_constraints = .{ | 67716 | .src_constraints = .{ |
| 54475 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67717 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54476 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67718 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| | 67719 | .any, |
| 54477 | }, | 67720 | }, |
| 54478 | .patterns = &.{ | 67721 | .patterns = &.{ |
| 54479 | .{ .src = .{ .to_mem, .to_mem } }, | 67722 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54480 | }, | 67723 | }, |
| 54481 | .extra_temps = .{ | 67724 | .extra_temps = .{ |
| 54482 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67725 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54505,9 +67748,10 @@ const Temp = struct { | ... | @@ -54505,9 +67748,10 @@ const Temp = struct { |
| 54505 | .src_constraints = .{ | 67748 | .src_constraints = .{ |
| 54506 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67749 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54507 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67750 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| | 67751 | .any, |
| 54508 | }, | 67752 | }, |
| 54509 | .patterns = &.{ | 67753 | .patterns = &.{ |
| 54510 | .{ .src = .{ .to_mem, .to_mem } }, | 67754 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54511 | }, | 67755 | }, |
| 54512 | .extra_temps = .{ | 67756 | .extra_temps = .{ |
| 54513 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67757 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54537,9 +67781,10 @@ const Temp = struct { | ... | @@ -54537,9 +67781,10 @@ const Temp = struct { |
| 54537 | .src_constraints = .{ | 67781 | .src_constraints = .{ |
| 54538 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67782 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| 54539 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, | 67783 | .{ .remainder_int = .{ .of = .xword, .is = .xword } }, |
| | 67784 | .any, |
| 54540 | }, | 67785 | }, |
| 54541 | .patterns = &.{ | 67786 | .patterns = &.{ |
| 54542 | .{ .src = .{ .to_mem, .to_mem } }, | 67787 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54543 | }, | 67788 | }, |
| 54544 | .extra_temps = .{ | 67789 | .extra_temps = .{ |
| 54545 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67790 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54569,9 +67814,10 @@ const Temp = struct { | ... | @@ -54569,9 +67814,10 @@ const Temp = struct { |
| 54569 | .src_constraints = .{ | 67814 | .src_constraints = .{ |
| 54570 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, | 67815 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| 54571 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, | 67816 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| | 67817 | .any, |
| 54572 | }, | 67818 | }, |
| 54573 | .patterns = &.{ | 67819 | .patterns = &.{ |
| 54574 | .{ .src = .{ .to_mem, .to_mem } }, | 67820 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54575 | }, | 67821 | }, |
| 54576 | .extra_temps = .{ | 67822 | .extra_temps = .{ |
| 54577 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67823 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54601,9 +67847,10 @@ const Temp = struct { | ... | @@ -54601,9 +67847,10 @@ const Temp = struct { |
| 54601 | .src_constraints = .{ | 67847 | .src_constraints = .{ |
| 54602 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, | 67848 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| 54603 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, | 67849 | .{ .remainder_int = .{ .of = .qword, .is = .qword } }, |
| | 67850 | .any, |
| 54604 | }, | 67851 | }, |
| 54605 | .patterns = &.{ | 67852 | .patterns = &.{ |
| 54606 | .{ .src = .{ .to_mem, .to_mem } }, | 67853 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54607 | }, | 67854 | }, |
| 54608 | .extra_temps = .{ | 67855 | .extra_temps = .{ |
| 54609 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67856 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -54630,9 +67877,10 @@ const Temp = struct { | ... | @@ -54630,9 +67877,10 @@ const Temp = struct { |
| 54630 | .src_constraints = .{ | 67877 | .src_constraints = .{ |
| 54631 | .{ .remainder_int = .{ .of = .dword, .is = .dword } }, | 67878 | .{ .remainder_int = .{ .of = .dword, .is = .dword } }, |
| 54632 | .{ .remainder_int = .{ .of = .dword, .is = .dword } }, | 67879 | .{ .remainder_int = .{ .of = .dword, .is = .dword } }, |
| | 67880 | .any, |
| 54633 | }, | 67881 | }, |
| 54634 | .patterns = &.{ | 67882 | .patterns = &.{ |
| 54635 | .{ .src = .{ .to_mem, .to_mem } }, | 67883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 54636 | }, | 67884 | }, |
| 54637 | .extra_temps = .{ | 67885 | .extra_temps = .{ |
| 54638 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 67886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| ... | @@ -55344,7 +68592,7 @@ const Select = struct { | ... | @@ -55344,7 +68592,7 @@ const Select = struct { |
| 55344 | }; | 68592 | }; |
| 55345 | | 68593 | |
| 55346 | const Pattern = struct { | 68594 | const Pattern = struct { |
| 55347 | src: [2]Src, | 68595 | src: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Src, |
| 55348 | commute: struct { u8, u8 } = .{ 0, 0 }, | 68596 | commute: struct { u8, u8 } = .{ 0, 0 }, |
| 55349 | | 68597 | |
| 55350 | const Src = union(enum) { | 68598 | const Src = union(enum) { |
| ... | @@ -55781,6 +69029,7 @@ const Select = struct { | ... | @@ -55781,6 +69029,7 @@ const Select = struct { |
| 55781 | dst0, | 69029 | dst0, |
| 55782 | src0, | 69030 | src0, |
| 55783 | src1, | 69031 | src1, |
| | 69032 | src2, |
| 55784 | none, | 69033 | none, |
| 55785 | | 69034 | |
| 55786 | const Sized = packed struct(u8) { | 69035 | const Sized = packed struct(u8) { |
| ... | @@ -55920,6 +69169,17 @@ const Select = struct { | ... | @@ -55920,6 +69169,17 @@ const Select = struct { |
| 55920 | const src1t: Sized = .{ .ref = .src1, .size = .tbyte }; | 69169 | const src1t: Sized = .{ .ref = .src1, .size = .tbyte }; |
| 55921 | const src1x: Sized = .{ .ref = .src1, .size = .xword }; | 69170 | const src1x: Sized = .{ .ref = .src1, .size = .xword }; |
| 55922 | const src1y: Sized = .{ .ref = .src1, .size = .yword }; | 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 | fn typeOf(ref: Ref, s: *const Select) Type { | 69185 | fn typeOf(ref: Ref, s: *const Select) Type { |
| ... | @@ -56064,6 +69324,16 @@ const Select = struct { | ... | @@ -56064,6 +69324,16 @@ const Select = struct { |
| 56064 | const src1x: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src1x }; | 69324 | const src1x: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src1x }; |
| 56065 | const src1y: Select.Operand = .{ .flags = .{ .tag = .ref }, .base = .src1y }; | 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 | fn si(imm: i32) Select.Operand { | 69337 | fn si(imm: i32) Select.Operand { |
| 56068 | return .{ .flags = .{ .tag = .simm }, .imm = imm }; | 69338 | return .{ .flags = .{ .tag = .simm }, .imm = imm }; |
| 56069 | } | 69339 | } |
Jacob Young <jacobly@ziglang.org> 2025-02-04 06:33:36-05:00
src