| ... | ... | @@ -98180,6 +98180,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 98180 | 98180 | .{ ._, ._, .mov, .dst0d, .memsi(.src0d, .@"4", .src1), ._, ._ }, |
| 98181 | 98181 | } }, |
| 98182 | 98182 | }, .{ |
| 98183 | .required_features = .{ .@"64bit", null, null, null }, |
| 98183 | 98184 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| 98184 | 98185 | .patterns = &.{ |
| 98185 | 98186 | .{ .src = .{ .to_mem, .simm32, .none } }, |
| ... | ... | @@ -120534,7 +120535,416 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 120534 | 120535 | try ert.die(cg); |
| 120535 | 120536 | try res.finish(inst, &.{}, &.{}, cg); |
| 120536 | 120537 | }, |
| 120537 | | .vector_store_elem => return cg.fail("TODO implement vector_store_elem", .{}), |
| 120538 | .vector_store_elem => { |
| 120539 | const extra = air_datas[@intFromEnum(inst)].vector_store_elem; |
| 120540 | const bin_op = cg.air.extraData(Air.Bin, extra.payload).data; |
| 120541 | var ops = try cg.tempsFromOperands(inst, .{ extra.vector_ptr, bin_op.lhs, bin_op.rhs }); |
| 120542 | cg.select(&.{}, &.{}, &ops, comptime &.{ .{ |
| 120543 | .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool }, |
| 120544 | .patterns = &.{ |
| 120545 | .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 0 } } }, |
| 120546 | }, |
| 120547 | .extra_temps = .{ |
| 120548 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 120549 | .unused, |
| 120550 | .unused, |
| 120551 | .unused, |
| 120552 | .unused, |
| 120553 | .unused, |
| 120554 | .unused, |
| 120555 | .unused, |
| 120556 | .unused, |
| 120557 | .unused, |
| 120558 | .unused, |
| 120559 | }, |
| 120560 | .clobbers = .{ .eflags = true }, |
| 120561 | .each = .{ .once = &.{ |
| 120562 | .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, |
| 120563 | .{ ._, ._r, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120564 | .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, |
| 120565 | } }, |
| 120566 | }, .{ |
| 120567 | .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool }, |
| 120568 | .patterns = &.{ |
| 120569 | .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 1 } } }, |
| 120570 | }, |
| 120571 | .extra_temps = .{ |
| 120572 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 120573 | .unused, |
| 120574 | .unused, |
| 120575 | .unused, |
| 120576 | .unused, |
| 120577 | .unused, |
| 120578 | .unused, |
| 120579 | .unused, |
| 120580 | .unused, |
| 120581 | .unused, |
| 120582 | .unused, |
| 120583 | }, |
| 120584 | .clobbers = .{ .eflags = true }, |
| 120585 | .each = .{ .once = &.{ |
| 120586 | .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, |
| 120587 | .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120588 | .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, |
| 120589 | } }, |
| 120590 | }, .{ |
| 120591 | .required_features = .{ .cmov, null, null, null }, |
| 120592 | .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool }, |
| 120593 | .patterns = &.{ |
| 120594 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120595 | }, |
| 120596 | .extra_temps = .{ |
| 120597 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 120598 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 120599 | .unused, |
| 120600 | .unused, |
| 120601 | .unused, |
| 120602 | .unused, |
| 120603 | .unused, |
| 120604 | .unused, |
| 120605 | .unused, |
| 120606 | .unused, |
| 120607 | .unused, |
| 120608 | }, |
| 120609 | .clobbers = .{ .eflags = true }, |
| 120610 | .each = .{ .once = &.{ |
| 120611 | .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, |
| 120612 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 120613 | .{ ._, ._r, .bt, .tmp1d, .src1d, ._, ._ }, |
| 120614 | .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120615 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120616 | .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ }, |
| 120617 | .{ ._, ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, |
| 120618 | } }, |
| 120619 | }, .{ |
| 120620 | .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool }, |
| 120621 | .patterns = &.{ |
| 120622 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120623 | }, |
| 120624 | .extra_temps = .{ |
| 120625 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 120626 | .unused, |
| 120627 | .unused, |
| 120628 | .unused, |
| 120629 | .unused, |
| 120630 | .unused, |
| 120631 | .unused, |
| 120632 | .unused, |
| 120633 | .unused, |
| 120634 | .unused, |
| 120635 | .unused, |
| 120636 | }, |
| 120637 | .clobbers = .{ .eflags = true }, |
| 120638 | .each = .{ .once = &.{ |
| 120639 | .{ ._, ._, .movzx, .tmp0d, .lea(.src0b), ._, ._ }, |
| 120640 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120641 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| 120642 | .{ ._, ._r, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120643 | .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, |
| 120644 | .{ .@"0:", ._s, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120645 | .{ .@"1:", ._, .mov, .lea(.src0b), .tmp0b, ._, ._ }, |
| 120646 | } }, |
| 120647 | }, .{ |
| 120648 | .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool }, |
| 120649 | .patterns = &.{ |
| 120650 | .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 0 } } }, |
| 120651 | }, |
| 120652 | .clobbers = .{ .eflags = true }, |
| 120653 | .each = .{ .once = &.{ |
| 120654 | .{ ._, ._r, .bt, .lea(.src0w), .src1w, ._, ._ }, |
| 120655 | } }, |
| 120656 | }, .{ |
| 120657 | .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool }, |
| 120658 | .patterns = &.{ |
| 120659 | .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 1 } } }, |
| 120660 | }, |
| 120661 | .clobbers = .{ .eflags = true }, |
| 120662 | .each = .{ .once = &.{ |
| 120663 | .{ ._, ._s, .bt, .lea(.src0d), .src1d, ._, ._ }, |
| 120664 | } }, |
| 120665 | }, .{ |
| 120666 | .required_features = .{ .cmov, null, null, null }, |
| 120667 | .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool }, |
| 120668 | .patterns = &.{ |
| 120669 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120670 | }, |
| 120671 | .extra_temps = .{ |
| 120672 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 120673 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 120674 | .unused, |
| 120675 | .unused, |
| 120676 | .unused, |
| 120677 | .unused, |
| 120678 | .unused, |
| 120679 | .unused, |
| 120680 | .unused, |
| 120681 | .unused, |
| 120682 | .unused, |
| 120683 | }, |
| 120684 | .clobbers = .{ .eflags = true }, |
| 120685 | .each = .{ .once = &.{ |
| 120686 | .{ ._, ._, .movzx, .tmp0d, .lea(.src0w), ._, ._ }, |
| 120687 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 120688 | .{ ._, ._r, .bt, .tmp1d, .src1d, ._, ._ }, |
| 120689 | .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120690 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120691 | .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ }, |
| 120692 | .{ ._, ._, .mov, .lea(.src0w), .tmp0w, ._, ._ }, |
| 120693 | } }, |
| 120694 | }, .{ |
| 120695 | .src_constraints = .{ .{ .ptr_bool_vec = .word }, .any, .bool }, |
| 120696 | .patterns = &.{ |
| 120697 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120698 | }, |
| 120699 | .clobbers = .{ .eflags = true }, |
| 120700 | .each = .{ .once = &.{ |
| 120701 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120702 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 120703 | .{ ._, ._r, .bt, .lea(.src0w), .src1w, ._, ._ }, |
| 120704 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 120705 | .{ .@"1:", ._s, .bt, .lea(.src0w), .src1w, ._, ._ }, |
| 120706 | } }, |
| 120707 | }, .{ |
| 120708 | .src_constraints = .{ .ptr_any_bool_vec, .any, .bool }, |
| 120709 | .patterns = &.{ |
| 120710 | .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 0 } } }, |
| 120711 | }, |
| 120712 | .clobbers = .{ .eflags = true }, |
| 120713 | .each = .{ .once = &.{ |
| 120714 | .{ ._, ._r, .bt, .lea(.src0d), .src1d, ._, ._ }, |
| 120715 | } }, |
| 120716 | }, .{ |
| 120717 | .src_constraints = .{ .ptr_any_bool_vec, .any, .bool }, |
| 120718 | .patterns = &.{ |
| 120719 | .{ .src = .{ .to_gpr, .to_gpr, .{ .imm = 1 } } }, |
| 120720 | }, |
| 120721 | .clobbers = .{ .eflags = true }, |
| 120722 | .each = .{ .once = &.{ |
| 120723 | .{ ._, ._s, .bt, .lea(.src0d), .src1d, ._, ._ }, |
| 120724 | } }, |
| 120725 | }, .{ |
| 120726 | .required_features = .{ .cmov, null, null, null }, |
| 120727 | .src_constraints = .{ .{ .ptr_bool_vec = .dword }, .any, .bool }, |
| 120728 | .patterns = &.{ |
| 120729 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120730 | }, |
| 120731 | .extra_temps = .{ |
| 120732 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 120733 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 120734 | .unused, |
| 120735 | .unused, |
| 120736 | .unused, |
| 120737 | .unused, |
| 120738 | .unused, |
| 120739 | .unused, |
| 120740 | .unused, |
| 120741 | .unused, |
| 120742 | .unused, |
| 120743 | }, |
| 120744 | .clobbers = .{ .eflags = true }, |
| 120745 | .each = .{ .once = &.{ |
| 120746 | .{ ._, ._, .mov, .tmp0d, .lea(.src0d), ._, ._ }, |
| 120747 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 120748 | .{ ._, ._r, .bt, .tmp1d, .src1d, ._, ._ }, |
| 120749 | .{ ._, ._s, .bt, .tmp0d, .src1d, ._, ._ }, |
| 120750 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120751 | .{ ._, ._z, .cmov, .tmp0d, .tmp1d, ._, ._ }, |
| 120752 | .{ ._, ._, .mov, .lea(.src0d), .tmp0d, ._, ._ }, |
| 120753 | } }, |
| 120754 | }, .{ |
| 120755 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 120756 | .src_constraints = .{ .{ .ptr_bool_vec = .qword }, .any, .bool }, |
| 120757 | .patterns = &.{ |
| 120758 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120759 | }, |
| 120760 | .extra_temps = .{ |
| 120761 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 120762 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 120763 | .unused, |
| 120764 | .unused, |
| 120765 | .unused, |
| 120766 | .unused, |
| 120767 | .unused, |
| 120768 | .unused, |
| 120769 | .unused, |
| 120770 | .unused, |
| 120771 | .unused, |
| 120772 | }, |
| 120773 | .clobbers = .{ .eflags = true }, |
| 120774 | .each = .{ .once = &.{ |
| 120775 | .{ ._, ._, .mov, .tmp0q, .lea(.src0q), ._, ._ }, |
| 120776 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| 120777 | .{ ._, ._r, .bt, .tmp1q, .src1q, ._, ._ }, |
| 120778 | .{ ._, ._s, .bt, .tmp0q, .src1q, ._, ._ }, |
| 120779 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120780 | .{ ._, ._z, .cmov, .tmp0q, .tmp1q, ._, ._ }, |
| 120781 | .{ ._, ._, .mov, .lea(.src0q), .tmp0q, ._, ._ }, |
| 120782 | } }, |
| 120783 | }, .{ |
| 120784 | .required_features = .{ .cmov, null, null, null }, |
| 120785 | .src_constraints = .{ .ptr_any_bool_vec, .any, .bool }, |
| 120786 | .patterns = &.{ |
| 120787 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120788 | }, |
| 120789 | .extra_temps = .{ |
| 120790 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 120791 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 120792 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 120793 | .unused, |
| 120794 | .unused, |
| 120795 | .unused, |
| 120796 | .unused, |
| 120797 | .unused, |
| 120798 | .unused, |
| 120799 | .unused, |
| 120800 | .unused, |
| 120801 | }, |
| 120802 | .clobbers = .{ .eflags = true }, |
| 120803 | .each = .{ .once = &.{ |
| 120804 | .{ ._, ._, .mov, .tmp0d, .src1d, ._, ._ }, |
| 120805 | .{ ._, ._r, .sh, .tmp0d, .ui(5), ._, ._ }, |
| 120806 | .{ ._, ._, .mov, .tmp1d, .leasi(.src0d, .@"4", .tmp0), ._, ._ }, |
| 120807 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 120808 | .{ ._, ._r, .bt, .tmp2d, .src1d, ._, ._ }, |
| 120809 | .{ ._, ._s, .bt, .tmp1d, .src1d, ._, ._ }, |
| 120810 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120811 | .{ ._, ._z, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| 120812 | .{ ._, ._, .mov, .leasi(.src0d, .@"4", .tmp0), .tmp1d, ._, ._ }, |
| 120813 | } }, |
| 120814 | }, .{ |
| 120815 | .src_constraints = .{ .ptr_any_bool_vec, .any, .bool }, |
| 120816 | .patterns = &.{ |
| 120817 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120818 | }, |
| 120819 | .clobbers = .{ .eflags = true }, |
| 120820 | .each = .{ .once = &.{ |
| 120821 | .{ ._, ._, .@"test", .src2b, .si(1), ._, ._ }, |
| 120822 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 120823 | .{ ._, ._r, .bt, .lea(.src0d), .src1d, ._, ._ }, |
| 120824 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 120825 | .{ .@"1:", ._s, .bt, .lea(.src0d), .src1d, ._, ._ }, |
| 120826 | } }, |
| 120827 | }, .{ |
| 120828 | .src_constraints = .{ .any, .any, .{ .int = .byte } }, |
| 120829 | .patterns = &.{ |
| 120830 | .{ .src = .{ .to_gpr, .simm32, .imm8 } }, |
| 120831 | .{ .src = .{ .to_gpr, .simm32, .to_gpr } }, |
| 120832 | }, |
| 120833 | .each = .{ .once = &.{ |
| 120834 | .{ ._, ._, .mov, .leaa(.src0b, .add_src0_elem_size_mul_src1), .src2b, ._, ._ }, |
| 120835 | } }, |
| 120836 | }, .{ |
| 120837 | .src_constraints = .{ .any, .any, .{ .int = .byte } }, |
| 120838 | .patterns = &.{ |
| 120839 | .{ .src = .{ .to_gpr, .to_gpr, .imm8 } }, |
| 120840 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120841 | }, |
| 120842 | .each = .{ .once = &.{ |
| 120843 | .{ ._, ._, .mov, .leai(.src0b, .src1), .src2b, ._, ._ }, |
| 120844 | } }, |
| 120845 | }, .{ |
| 120846 | .src_constraints = .{ .any, .any, .{ .int = .word } }, |
| 120847 | .patterns = &.{ |
| 120848 | .{ .src = .{ .to_gpr, .simm32, .imm16 } }, |
| 120849 | .{ .src = .{ .to_gpr, .simm32, .to_gpr } }, |
| 120850 | }, |
| 120851 | .each = .{ .once = &.{ |
| 120852 | .{ ._, ._, .mov, .leaa(.src0w, .add_src0_elem_size_mul_src1), .src2w, ._, ._ }, |
| 120853 | } }, |
| 120854 | }, .{ |
| 120855 | .src_constraints = .{ .any, .any, .{ .int = .word } }, |
| 120856 | .patterns = &.{ |
| 120857 | .{ .src = .{ .to_gpr, .to_gpr, .imm16 } }, |
| 120858 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120859 | }, |
| 120860 | .each = .{ .once = &.{ |
| 120861 | .{ ._, ._, .mov, .leasi(.src0w, .@"2", .src1), .src2w, ._, ._ }, |
| 120862 | } }, |
| 120863 | }, .{ |
| 120864 | .src_constraints = .{ .any, .any, .{ .int = .dword } }, |
| 120865 | .patterns = &.{ |
| 120866 | .{ .src = .{ .to_gpr, .simm32, .imm32 } }, |
| 120867 | .{ .src = .{ .to_gpr, .simm32, .to_gpr } }, |
| 120868 | }, |
| 120869 | .each = .{ .once = &.{ |
| 120870 | .{ ._, ._, .mov, .leaa(.src0d, .add_src0_elem_size_mul_src1), .src2d, ._, ._ }, |
| 120871 | } }, |
| 120872 | }, .{ |
| 120873 | .src_constraints = .{ .any, .any, .{ .int = .dword } }, |
| 120874 | .patterns = &.{ |
| 120875 | .{ .src = .{ .to_gpr, .to_gpr, .imm32 } }, |
| 120876 | .{ .src = .{ .to_gpr, .to_gpr, .to_gpr } }, |
| 120877 | }, |
| 120878 | .each = .{ .once = &.{ |
| 120879 | .{ ._, ._, .mov, .leasi(.src0d, .@"4", .src1), .src2d, ._, ._ }, |
| 120880 | } }, |
| 120881 | }, .{ |
| 120882 | .required_features = .{ .@"64bit", null, null, null }, |
| 120883 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| 120884 | .patterns = &.{ |
| 120885 | .{ .src = .{ .to_mem, .simm32, .simm32 } }, |
| 120886 | .{ .src = .{ .to_mem, .simm32, .to_gpr } }, |
| 120887 | }, |
| 120888 | .each = .{ .once = &.{ |
| 120889 | .{ ._, ._, .mov, .leaa(.src0q, .add_src0_elem_size_mul_src1), .src2q, ._, ._ }, |
| 120890 | } }, |
| 120891 | }, .{ |
| 120892 | .required_features = .{ .@"64bit", null, null, null }, |
| 120893 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| 120894 | .patterns = &.{ |
| 120895 | .{ .src = .{ .to_mem, .to_gpr, .simm32 } }, |
| 120896 | .{ .src = .{ .to_mem, .to_gpr, .to_gpr } }, |
| 120897 | }, |
| 120898 | .each = .{ .once = &.{ |
| 120899 | .{ ._, ._, .mov, .leasi(.src0q, .@"8", .src1), .src2q, ._, ._ }, |
| 120900 | } }, |
| 120901 | } }) catch |err| switch (err) { |
| 120902 | error.SelectFailed => { |
| 120903 | const elem_size = cg.typeOf(extra.vector_ptr).childType(zcu).childType(zcu).abiSize(zcu); |
| 120904 | while (try ops[0].toBase(false, cg) or |
| 120905 | try ops[1].toRegClass(true, .general_purpose, cg)) |
| 120906 | {} |
| 120907 | const base_reg = ops[0].tracking(cg).short.register.to64(); |
| 120908 | const rhs_reg = ops[1].tracking(cg).short.register.to64(); |
| 120909 | if (!std.math.isPowerOfTwo(elem_size)) { |
| 120910 | try cg.spillEflagsIfOccupied(); |
| 120911 | try cg.asmRegisterRegisterImmediate( |
| 120912 | .{ .i_, .mul }, |
| 120913 | rhs_reg, |
| 120914 | rhs_reg, |
| 120915 | .u(elem_size), |
| 120916 | ); |
| 120917 | try cg.asmRegisterMemory( |
| 120918 | .{ ._, .lea }, |
| 120919 | base_reg, |
| 120920 | try ops[0].tracking(cg).short.mem(cg, .{ .index = rhs_reg }), |
| 120921 | ); |
| 120922 | } else if (elem_size > 8) { |
| 120923 | try cg.spillEflagsIfOccupied(); |
| 120924 | try cg.asmRegisterImmediate( |
| 120925 | .{ ._l, .sh }, |
| 120926 | rhs_reg, |
| 120927 | .u(std.math.log2_int(u64, elem_size)), |
| 120928 | ); |
| 120929 | try cg.asmRegisterMemory( |
| 120930 | .{ ._, .lea }, |
| 120931 | base_reg, |
| 120932 | try ops[0].tracking(cg).short.mem(cg, .{ .index = rhs_reg }), |
| 120933 | ); |
| 120934 | } else try cg.asmRegisterMemory( |
| 120935 | .{ ._, .lea }, |
| 120936 | base_reg, |
| 120937 | try ops[0].tracking(cg).short.mem(cg, .{ |
| 120938 | .index = rhs_reg, |
| 120939 | .scale = .fromFactor(@intCast(elem_size)), |
| 120940 | }), |
| 120941 | ); |
| 120942 | try ops[0].store(&ops[1], .{}, cg); |
| 120943 | }, |
| 120944 | else => |e| return e, |
| 120945 | }; |
| 120946 | for (ops) |op| try op.die(cg); |
| 120947 | }, |
| 120538 | 120948 | .c_va_arg => try cg.airVaArg(inst), |
| 120539 | 120949 | .c_va_copy => try cg.airVaCopy(inst), |
| 120540 | 120950 | .c_va_end => try cg.airVaEnd(inst), |
| ... | ... | @@ -144898,7 +145308,10 @@ const Select = struct { |
| 144898 | 145308 | any_scalar_unsigned_int, |
| 144899 | 145309 | any_float, |
| 144900 | 145310 | po2_any, |
| 145311 | bool, |
| 144901 | 145312 | bool_vec: Memory.Size, |
| 145313 | ptr_bool_vec: Memory.Size, |
| 145314 | ptr_any_bool_vec, |
| 144902 | 145315 | signed_int_vec: Memory.Size, |
| 144903 | 145316 | signed_int_or_full_vec: Memory.Size, |
| 144904 | 145317 | unsigned_int_vec: Memory.Size, |
| ... | ... | @@ -144974,8 +145387,17 @@ const Select = struct { |
| 144974 | 145387 | .any_scalar_unsigned_int => if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned else false, |
| 144975 | 145388 | .any_float => ty.isRuntimeFloat(), |
| 144976 | 145389 | .po2_any => std.math.isPowerOfTwo(ty.abiSize(zcu)), |
| 145390 | .bool => ty.toIntern() == .bool_type, |
| 144977 | 145391 | .bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| 144978 | 145392 | size.bitSize(cg.target) >= ty.vectorLen(zcu), |
| 145393 | .ptr_any_bool_vec => switch (zcu.intern_pool.indexToKey(ty.childType(zcu).toIntern())) { |
| 145394 | .vector_type => |vector_type| vector_type.child == .bool_type, |
| 145395 | else => false, |
| 145396 | }, |
| 145397 | .ptr_bool_vec => |size| switch (zcu.intern_pool.indexToKey(ty.childType(zcu).toIntern())) { |
| 145398 | .vector_type => |vector_type| vector_type.child == .bool_type and size.bitSize(cg.target) >= vector_type.len, |
| 145399 | else => false, |
| 145400 | }, |
| 144979 | 145401 | .signed_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and |
| 144980 | 145402 | if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .signed else false, |
| 144981 | 145403 | .signed_int_or_full_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and |
Jacob Young <jacobly@ziglang.org> 2025-05-17 20:30:02-04:00
src