| ... | @@ -98180,6 +98180,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -98180,6 +98180,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 98180 | .{ ._, ._, .mov, .dst0d, .memsi(.src0d, .@"4", .src1), ._, ._ }, | 98180 | .{ ._, ._, .mov, .dst0d, .memsi(.src0d, .@"4", .src1), ._, ._ }, |
| 98181 | } }, | 98181 | } }, |
| 98182 | }, .{ | 98182 | }, .{ |
| | 98183 | .required_features = .{ .@"64bit", null, null, null }, |
| 98183 | .dst_constraints = .{ .{ .int = .qword }, .any }, | 98184 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| 98184 | .patterns = &.{ | 98185 | .patterns = &.{ |
| 98185 | .{ .src = .{ .to_mem, .simm32, .none } }, | 98186 | .{ .src = .{ .to_mem, .simm32, .none } }, |
| ... | @@ -120534,7 +120535,416 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -120534,7 +120535,416 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 120534 | try ert.die(cg); | 120535 | try ert.die(cg); |
| 120535 | try res.finish(inst, &.{}, &.{}, cg); | 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 | .c_va_arg => try cg.airVaArg(inst), | 120948 | .c_va_arg => try cg.airVaArg(inst), |
| 120539 | .c_va_copy => try cg.airVaCopy(inst), | 120949 | .c_va_copy => try cg.airVaCopy(inst), |
| 120540 | .c_va_end => try cg.airVaEnd(inst), | 120950 | .c_va_end => try cg.airVaEnd(inst), |
| ... | @@ -144898,7 +145308,10 @@ const Select = struct { | ... | @@ -144898,7 +145308,10 @@ const Select = struct { |
| 144898 | any_scalar_unsigned_int, | 145308 | any_scalar_unsigned_int, |
| 144899 | any_float, | 145309 | any_float, |
| 144900 | po2_any, | 145310 | po2_any, |
| | 145311 | bool, |
| 144901 | bool_vec: Memory.Size, | 145312 | bool_vec: Memory.Size, |
| | 145313 | ptr_bool_vec: Memory.Size, |
| | 145314 | ptr_any_bool_vec, |
| 144902 | signed_int_vec: Memory.Size, | 145315 | signed_int_vec: Memory.Size, |
| 144903 | signed_int_or_full_vec: Memory.Size, | 145316 | signed_int_or_full_vec: Memory.Size, |
| 144904 | unsigned_int_vec: Memory.Size, | 145317 | unsigned_int_vec: Memory.Size, |
| ... | @@ -144974,8 +145387,17 @@ const Select = struct { | ... | @@ -144974,8 +145387,17 @@ const Select = struct { |
| 144974 | .any_scalar_unsigned_int => if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned else false, | 145387 | .any_scalar_unsigned_int => if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .unsigned else false, |
| 144975 | .any_float => ty.isRuntimeFloat(), | 145388 | .any_float => ty.isRuntimeFloat(), |
| 144976 | .po2_any => std.math.isPowerOfTwo(ty.abiSize(zcu)), | 145389 | .po2_any => std.math.isPowerOfTwo(ty.abiSize(zcu)), |
| | 145390 | .bool => ty.toIntern() == .bool_type, |
| 144977 | .bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and | 145391 | .bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| 144978 | size.bitSize(cg.target) >= ty.vectorLen(zcu), | 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 | .signed_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and | 145401 | .signed_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and |
| 144980 | if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .signed else false, | 145402 | if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .signed else false, |
| 144981 | .signed_int_or_full_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and | 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