| ... | ... | @@ -6903,12 +6903,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6903 | 6903 | else => unreachable, |
| 6904 | 6904 | .div_float, .div_float_optimized => .div_float, |
| 6905 | 6905 | .div_exact, .div_exact_optimized => .div_exact, |
| 6906 | | }) else fallback: { |
| 6906 | }) else { |
| 6907 | 6907 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 6908 | | if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, .div_exact); |
| 6908 | const ty = cg.typeOf(bin_op.lhs); |
| 6909 | 6909 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 6910 | 6910 | var res: [1]Temp = undefined; |
| 6911 | | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 6911 | (if (cg.floatBits(ty.scalarType(zcu))) |_| cg.select(&res, &.{ty}, &ops, comptime &.{ .{ |
| 6912 | 6912 | .required_features = .{ .f16c, null, null, null }, |
| 6913 | 6913 | .src_constraints = .{ |
| 6914 | 6914 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| ... | ... | @@ -7772,10 +7772,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7772 | 7772 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7773 | 7773 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 7774 | 7774 | } }, |
| 7775 | | } }) catch |err| switch (err) { |
| 7775 | } }) else err: { |
| 7776 | assert(air_tag == .div_exact); |
| 7777 | res[0] = ops[0].divTruncInts(&ops[1], cg) catch |err| break :err err; |
| 7778 | }) catch |err| switch (err) { |
| 7776 | 7779 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 7777 | 7780 | @tagName(air_tag), |
| 7778 | | cg.typeOf(bin_op.lhs).fmt(pt), |
| 7781 | ty.fmt(pt), |
| 7779 | 7782 | ops[0].tracking(cg), |
| 7780 | 7783 | ops[1].tracking(cg), |
| 7781 | 7784 | }), |
| ... | ... | @@ -7785,743 +7788,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7785 | 7788 | }, |
| 7786 | 7789 | .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else { |
| 7787 | 7790 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 7791 | const ty = cg.typeOf(bin_op.lhs); |
| 7788 | 7792 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 7789 | 7793 | var res: [1]Temp = undefined; |
| 7790 | | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 7791 | | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 7792 | | .patterns = &.{ |
| 7793 | | .{ .src = .{ .mem, .mem, .none } }, |
| 7794 | | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 7795 | | .{ .src = .{ .mem, .to_gpr, .none } }, |
| 7796 | | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 7797 | | }, |
| 7798 | | .dst_temps = .{ .{ .reg = .al }, .unused }, |
| 7799 | | .clobbers = .{ .eflags = true }, |
| 7800 | | .each = .{ .once = &.{ |
| 7801 | | .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ }, |
| 7802 | | .{ ._, .i_, .div, .src1b, ._, ._, ._ }, |
| 7803 | | } }, |
| 7804 | | }, .{ |
| 7805 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 7806 | | .patterns = &.{ |
| 7807 | | .{ .src = .{ .mem, .mem, .none } }, |
| 7808 | | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 7809 | | .{ .src = .{ .mem, .to_gpr, .none } }, |
| 7810 | | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 7811 | | }, |
| 7812 | | .dst_temps = .{ .{ .reg = .al }, .unused }, |
| 7813 | | .clobbers = .{ .eflags = true }, |
| 7814 | | .each = .{ .once = &.{ |
| 7815 | | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 7816 | | .{ ._, ._, .div, .src1b, ._, ._, ._ }, |
| 7817 | | } }, |
| 7818 | | }, .{ |
| 7819 | | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 7820 | | .patterns = &.{ |
| 7821 | | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| 7822 | | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| 7823 | | }, |
| 7824 | | .extra_temps = .{ |
| 7825 | | .{ .type = .i16, .kind = .{ .reg = .dx } }, |
| 7826 | | .unused, |
| 7827 | | .unused, |
| 7828 | | .unused, |
| 7829 | | .unused, |
| 7830 | | .unused, |
| 7831 | | .unused, |
| 7832 | | .unused, |
| 7833 | | .unused, |
| 7834 | | }, |
| 7835 | | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7836 | | .clobbers = .{ .eflags = true }, |
| 7837 | | .each = .{ .once = &.{ |
| 7838 | | .{ ._, ._, .cwd, ._, ._, ._, ._ }, |
| 7839 | | .{ ._, .i_, .div, .src1w, ._, ._, ._ }, |
| 7840 | | } }, |
| 7841 | | }, .{ |
| 7842 | | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 7843 | | .patterns = &.{ |
| 7844 | | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| 7845 | | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| 7846 | | }, |
| 7847 | | .extra_temps = .{ |
| 7848 | | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| 7849 | | .unused, |
| 7850 | | .unused, |
| 7851 | | .unused, |
| 7852 | | .unused, |
| 7853 | | .unused, |
| 7854 | | .unused, |
| 7855 | | .unused, |
| 7856 | | .unused, |
| 7857 | | }, |
| 7858 | | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7859 | | .clobbers = .{ .eflags = true }, |
| 7860 | | .each = .{ .once = &.{ |
| 7861 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 7862 | | .{ ._, ._, .div, .src1w, ._, ._, ._ }, |
| 7863 | | } }, |
| 7864 | | }, .{ |
| 7865 | | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 7866 | | .patterns = &.{ |
| 7867 | | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| 7868 | | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| 7869 | | }, |
| 7870 | | .extra_temps = .{ |
| 7871 | | .{ .type = .i32, .kind = .{ .reg = .edx } }, |
| 7872 | | .unused, |
| 7873 | | .unused, |
| 7874 | | .unused, |
| 7875 | | .unused, |
| 7876 | | .unused, |
| 7877 | | .unused, |
| 7878 | | .unused, |
| 7879 | | .unused, |
| 7880 | | }, |
| 7881 | | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7882 | | .clobbers = .{ .eflags = true }, |
| 7883 | | .each = .{ .once = &.{ |
| 7884 | | .{ ._, ._, .cdq, ._, ._, ._, ._ }, |
| 7885 | | .{ ._, .i_, .div, .src1d, ._, ._, ._ }, |
| 7886 | | } }, |
| 7887 | | }, .{ |
| 7888 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 7889 | | .patterns = &.{ |
| 7890 | | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| 7891 | | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| 7892 | | }, |
| 7893 | | .extra_temps = .{ |
| 7894 | | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 7895 | | .unused, |
| 7896 | | .unused, |
| 7897 | | .unused, |
| 7898 | | .unused, |
| 7899 | | .unused, |
| 7900 | | .unused, |
| 7901 | | .unused, |
| 7902 | | .unused, |
| 7903 | | }, |
| 7904 | | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7905 | | .clobbers = .{ .eflags = true }, |
| 7906 | | .each = .{ .once = &.{ |
| 7907 | | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 7908 | | .{ ._, ._, .div, .src1d, ._, ._, ._ }, |
| 7909 | | } }, |
| 7910 | | }, .{ |
| 7911 | | .required_features = .{ .@"64bit", null, null, null }, |
| 7912 | | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 7913 | | .patterns = &.{ |
| 7914 | | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| 7915 | | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| 7916 | | }, |
| 7917 | | .extra_temps = .{ |
| 7918 | | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 7919 | | .unused, |
| 7920 | | .unused, |
| 7921 | | .unused, |
| 7922 | | .unused, |
| 7923 | | .unused, |
| 7924 | | .unused, |
| 7925 | | .unused, |
| 7926 | | .unused, |
| 7927 | | }, |
| 7928 | | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7929 | | .clobbers = .{ .eflags = true }, |
| 7930 | | .each = .{ .once = &.{ |
| 7931 | | .{ ._, ._, .cqo, ._, ._, ._, ._ }, |
| 7932 | | .{ ._, .i_, .div, .src1q, ._, ._, ._ }, |
| 7933 | | } }, |
| 7934 | | }, .{ |
| 7935 | | .required_features = .{ .@"64bit", null, null, null }, |
| 7936 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 7937 | | .patterns = &.{ |
| 7938 | | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| 7939 | | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| 7940 | | }, |
| 7941 | | .extra_temps = .{ |
| 7942 | | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 7943 | | .unused, |
| 7944 | | .unused, |
| 7945 | | .unused, |
| 7946 | | .unused, |
| 7947 | | .unused, |
| 7948 | | .unused, |
| 7949 | | .unused, |
| 7950 | | .unused, |
| 7951 | | }, |
| 7952 | | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7953 | | .clobbers = .{ .eflags = true }, |
| 7954 | | .each = .{ .once = &.{ |
| 7955 | | .{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ }, |
| 7956 | | .{ ._, ._, .div, .src1q, ._, ._, ._ }, |
| 7957 | | } }, |
| 7958 | | }, .{ |
| 7959 | | .required_features = .{ .@"64bit", null, null, null }, |
| 7960 | | .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, |
| 7961 | | .patterns = &.{ |
| 7962 | | .{ .src = .{ |
| 7963 | | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } }, |
| 7964 | | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } }, |
| 7965 | | .none, |
| 7966 | | } }, |
| 7967 | | }, |
| 7968 | | .call_frame = .{ .alignment = .@"16" }, |
| 7969 | | .extra_temps = .{ |
| 7970 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } }, |
| 7971 | | .unused, |
| 7972 | | .unused, |
| 7973 | | .unused, |
| 7974 | | .unused, |
| 7975 | | .unused, |
| 7976 | | .unused, |
| 7977 | | .unused, |
| 7978 | | .unused, |
| 7979 | | }, |
| 7980 | | .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused }, |
| 7981 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 7982 | | .each = .{ .once = &.{ |
| 7983 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 7984 | | } }, |
| 7985 | | }, .{ |
| 7986 | | .required_features = .{ .@"64bit", null, null, null }, |
| 7987 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, |
| 7988 | | .patterns = &.{ |
| 7989 | | .{ .src = .{ |
| 7990 | | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } }, |
| 7991 | | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } }, |
| 7992 | | .none, |
| 7993 | | } }, |
| 7994 | | }, |
| 7995 | | .call_frame = .{ .alignment = .@"16" }, |
| 7996 | | .extra_temps = .{ |
| 7997 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } }, |
| 7998 | | .unused, |
| 7999 | | .unused, |
| 8000 | | .unused, |
| 8001 | | .unused, |
| 8002 | | .unused, |
| 8003 | | .unused, |
| 8004 | | .unused, |
| 8005 | | .unused, |
| 8006 | | }, |
| 8007 | | .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused }, |
| 8008 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8009 | | .each = .{ .once = &.{ |
| 8010 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 8011 | | } }, |
| 8012 | | }, .{ |
| 8013 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8014 | | .src_constraints = .{ |
| 8015 | | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8016 | | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8017 | | .any, |
| 8018 | | }, |
| 8019 | | .patterns = &.{ |
| 8020 | | .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } }, |
| 8021 | | }, |
| 8022 | | .call_frame = .{ .alignment = .@"16" }, |
| 8023 | | .extra_temps = .{ |
| 8024 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8025 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 8026 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 8027 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 8028 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } }, |
| 8029 | | .unused, |
| 8030 | | .unused, |
| 8031 | | .unused, |
| 8032 | | .unused, |
| 8033 | | }, |
| 8034 | | .dst_temps = .{ .mem, .unused }, |
| 8035 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8036 | | .each = .{ .once = &.{ |
| 8037 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 8038 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 8039 | | .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ }, |
| 8040 | | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ }, |
| 8041 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8042 | | } }, |
| 8043 | | }, .{ |
| 8044 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8045 | | .src_constraints = .{ |
| 8046 | | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8047 | | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8048 | | .any, |
| 8049 | | }, |
| 8050 | | .patterns = &.{ |
| 8051 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8052 | | }, |
| 8053 | | .call_frame = .{ .alignment = .@"16" }, |
| 8054 | | .extra_temps = .{ |
| 8055 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8056 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 8057 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 8058 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 8059 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } }, |
| 8060 | | .unused, |
| 8061 | | .unused, |
| 8062 | | .unused, |
| 8063 | | .unused, |
| 8064 | | }, |
| 8065 | | .dst_temps = .{ .mem, .unused }, |
| 8066 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8067 | | .each = .{ .once = &.{ |
| 8068 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 8069 | | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 8070 | | .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ }, |
| 8071 | | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ }, |
| 8072 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 8073 | | } }, |
| 8074 | | }, .{ |
| 8075 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 8076 | | .src_constraints = .{ |
| 8077 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 8078 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 8079 | | .any, |
| 8080 | | }, |
| 8081 | | .patterns = &.{ |
| 8082 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8083 | | }, |
| 8084 | | .extra_temps = .{ |
| 8085 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8086 | | .{ .type = .i8, .kind = .{ .reg = .al } }, |
| 8087 | | .unused, |
| 8088 | | .unused, |
| 8089 | | .unused, |
| 8090 | | .unused, |
| 8091 | | .unused, |
| 8092 | | .unused, |
| 8093 | | .unused, |
| 8094 | | }, |
| 8095 | | .dst_temps = .{ .mem, .unused }, |
| 8096 | | .clobbers = .{ .eflags = true }, |
| 8097 | | .each = .{ .once = &.{ |
| 8098 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8099 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8100 | | .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8101 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 8102 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 8103 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8104 | | } }, |
| 8105 | | }, .{ |
| 8106 | | .src_constraints = .{ |
| 8107 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 8108 | | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 8109 | | .any, |
| 8110 | | }, |
| 8111 | | .patterns = &.{ |
| 8112 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8113 | | }, |
| 8114 | | .extra_temps = .{ |
| 8115 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8116 | | .{ .type = .i8, .kind = .{ .reg = .al } }, |
| 8117 | | .unused, |
| 8118 | | .unused, |
| 8119 | | .unused, |
| 8120 | | .unused, |
| 8121 | | .unused, |
| 8122 | | .unused, |
| 8123 | | .unused, |
| 8124 | | }, |
| 8125 | | .dst_temps = .{ .mem, .unused }, |
| 8126 | | .clobbers = .{ .eflags = true }, |
| 8127 | | .each = .{ .once = &.{ |
| 8128 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8129 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8130 | | .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8131 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 8132 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 8133 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 8134 | | } }, |
| 8135 | | }, .{ |
| 8136 | | .required_features = .{ .slow_incdec, null, null, null }, |
| 8137 | | .src_constraints = .{ |
| 8138 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 8139 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 8140 | | .any, |
| 8141 | | }, |
| 8142 | | .patterns = &.{ |
| 8143 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8144 | | }, |
| 8145 | | .extra_temps = .{ |
| 8146 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8147 | | .{ .type = .u8, .kind = .{ .reg = .al } }, |
| 8148 | | .unused, |
| 8149 | | .unused, |
| 8150 | | .unused, |
| 8151 | | .unused, |
| 8152 | | .unused, |
| 8153 | | .unused, |
| 8154 | | .unused, |
| 8155 | | }, |
| 8156 | | .dst_temps = .{ .mem, .unused }, |
| 8157 | | .clobbers = .{ .eflags = true }, |
| 8158 | | .each = .{ .once = &.{ |
| 8159 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8160 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8161 | | .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8162 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 8163 | | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 8164 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8165 | | } }, |
| 8166 | | }, .{ |
| 8167 | | .src_constraints = .{ |
| 8168 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 8169 | | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 8170 | | .any, |
| 8171 | | }, |
| 8172 | | .patterns = &.{ |
| 8173 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8174 | | }, |
| 8175 | | .extra_temps = .{ |
| 8176 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8177 | | .{ .type = .u8, .kind = .{ .reg = .al } }, |
| 8178 | | .unused, |
| 8179 | | .unused, |
| 8180 | | .unused, |
| 8181 | | .unused, |
| 8182 | | .unused, |
| 8183 | | .unused, |
| 8184 | | .unused, |
| 8185 | | }, |
| 8186 | | .dst_temps = .{ .mem, .unused }, |
| 8187 | | .clobbers = .{ .eflags = true }, |
| 8188 | | .each = .{ .once = &.{ |
| 8189 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8190 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8191 | | .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8192 | | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 8193 | | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 8194 | | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 8195 | | } }, |
| 8196 | | }, .{ |
| 8197 | | .src_constraints = .{ |
| 8198 | | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 8199 | | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 8200 | | .any, |
| 8201 | | }, |
| 8202 | | .patterns = &.{ |
| 8203 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8204 | | }, |
| 8205 | | .extra_temps = .{ |
| 8206 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8207 | | .{ .type = .i16, .kind = .{ .reg = .ax } }, |
| 8208 | | .{ .type = .i16, .kind = .{ .reg = .dx } }, |
| 8209 | | .unused, |
| 8210 | | .unused, |
| 8211 | | .unused, |
| 8212 | | .unused, |
| 8213 | | .unused, |
| 8214 | | .unused, |
| 8215 | | }, |
| 8216 | | .dst_temps = .{ .mem, .unused }, |
| 8217 | | .clobbers = .{ .eflags = true }, |
| 8218 | | .each = .{ .once = &.{ |
| 8219 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8220 | | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8221 | | .{ ._, ._, .cwd, ._, ._, ._, ._ }, |
| 8222 | | .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8223 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 8224 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 8225 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8226 | | } }, |
| 8227 | | }, .{ |
| 8228 | | .src_constraints = .{ |
| 8229 | | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 8230 | | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 8231 | | .any, |
| 8232 | | }, |
| 8233 | | .patterns = &.{ |
| 8234 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8235 | | }, |
| 8236 | | .extra_temps = .{ |
| 8237 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8238 | | .{ .type = .u16, .kind = .{ .reg = .ax } }, |
| 8239 | | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| 8240 | | .unused, |
| 8241 | | .unused, |
| 8242 | | .unused, |
| 8243 | | .unused, |
| 8244 | | .unused, |
| 8245 | | .unused, |
| 8246 | | }, |
| 8247 | | .dst_temps = .{ .mem, .unused }, |
| 8248 | | .clobbers = .{ .eflags = true }, |
| 8249 | | .each = .{ .once = &.{ |
| 8250 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8251 | | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8252 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 8253 | | .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8254 | | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 8255 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 8256 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8257 | | } }, |
| 8258 | | }, .{ |
| 8259 | | .src_constraints = .{ |
| 8260 | | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8261 | | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8262 | | .any, |
| 8263 | | }, |
| 8264 | | .patterns = &.{ |
| 8265 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8266 | | }, |
| 8267 | | .extra_temps = .{ |
| 8268 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8269 | | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 8270 | | .{ .type = .i32, .kind = .{ .reg = .edx } }, |
| 8271 | | .unused, |
| 8272 | | .unused, |
| 8273 | | .unused, |
| 8274 | | .unused, |
| 8275 | | .unused, |
| 8276 | | .unused, |
| 8277 | | }, |
| 8278 | | .dst_temps = .{ .mem, .unused }, |
| 8279 | | .clobbers = .{ .eflags = true }, |
| 8280 | | .each = .{ .once = &.{ |
| 8281 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8282 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8283 | | .{ ._, ._, .cdq, ._, ._, ._, ._ }, |
| 8284 | | .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8285 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 8286 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 8287 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8288 | | } }, |
| 8289 | | }, .{ |
| 8290 | | .src_constraints = .{ |
| 8291 | | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8292 | | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8293 | | .any, |
| 8294 | | }, |
| 8295 | | .patterns = &.{ |
| 8296 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8297 | | }, |
| 8298 | | .extra_temps = .{ |
| 8299 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8300 | | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 8301 | | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 8302 | | .unused, |
| 8303 | | .unused, |
| 8304 | | .unused, |
| 8305 | | .unused, |
| 8306 | | .unused, |
| 8307 | | .unused, |
| 8308 | | }, |
| 8309 | | .dst_temps = .{ .mem, .unused }, |
| 8310 | | .clobbers = .{ .eflags = true }, |
| 8311 | | .each = .{ .once = &.{ |
| 8312 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8313 | | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8314 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 8315 | | .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8316 | | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 8317 | | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 8318 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8319 | | } }, |
| 8320 | | }, .{ |
| 8321 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8322 | | .src_constraints = .{ |
| 8323 | | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 8324 | | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 8325 | | .any, |
| 8326 | | }, |
| 8327 | | .patterns = &.{ |
| 8328 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8329 | | }, |
| 8330 | | .extra_temps = .{ |
| 8331 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8332 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 8333 | | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 8334 | | .unused, |
| 8335 | | .unused, |
| 8336 | | .unused, |
| 8337 | | .unused, |
| 8338 | | .unused, |
| 8339 | | .unused, |
| 8340 | | }, |
| 8341 | | .dst_temps = .{ .mem, .unused }, |
| 8342 | | .clobbers = .{ .eflags = true }, |
| 8343 | | .each = .{ .once = &.{ |
| 8344 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8345 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8346 | | .{ ._, ._, .cqo, ._, ._, ._, ._ }, |
| 8347 | | .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8348 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 8349 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 8350 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8351 | | } }, |
| 8352 | | }, .{ |
| 8353 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8354 | | .src_constraints = .{ |
| 8355 | | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 8356 | | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 8357 | | .any, |
| 8358 | | }, |
| 8359 | | .patterns = &.{ |
| 8360 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8361 | | }, |
| 8362 | | .extra_temps = .{ |
| 8363 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8364 | | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 8365 | | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 8366 | | .unused, |
| 8367 | | .unused, |
| 8368 | | .unused, |
| 8369 | | .unused, |
| 8370 | | .unused, |
| 8371 | | .unused, |
| 8372 | | }, |
| 8373 | | .dst_temps = .{ .mem, .unused }, |
| 8374 | | .clobbers = .{ .eflags = true }, |
| 8375 | | .each = .{ .once = &.{ |
| 8376 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8377 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8378 | | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 8379 | | .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 8380 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 8381 | | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 8382 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8383 | | } }, |
| 8384 | | }, .{ |
| 8385 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8386 | | .src_constraints = .{ |
| 8387 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, |
| 8388 | | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, |
| 8389 | | .any, |
| 8390 | | }, |
| 8391 | | .patterns = &.{ |
| 8392 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8393 | | }, |
| 8394 | | .call_frame = .{ .alignment = .@"16" }, |
| 8395 | | .extra_temps = .{ |
| 8396 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8397 | | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8398 | | .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 8399 | | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 8400 | | .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 8401 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } }, |
| 8402 | | .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8403 | | .unused, |
| 8404 | | .unused, |
| 8405 | | }, |
| 8406 | | .dst_temps = .{ .mem, .unused }, |
| 8407 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8408 | | .each = .{ .once = &.{ |
| 8409 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8410 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8411 | | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 8412 | | .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8413 | | .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 8414 | | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 8415 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ }, |
| 8416 | | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ }, |
| 8417 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8418 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8419 | | } }, |
| 8420 | | }, .{ |
| 8421 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8422 | | .src_constraints = .{ |
| 8423 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 8424 | | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 8425 | | .any, |
| 8426 | | }, |
| 8427 | | .patterns = &.{ |
| 8428 | | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 8429 | | }, |
| 8430 | | .call_frame = .{ .alignment = .@"16" }, |
| 8431 | | .extra_temps = .{ |
| 8432 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8433 | | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8434 | | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 8435 | | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 8436 | | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 8437 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } }, |
| 8438 | | .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8439 | | .unused, |
| 8440 | | .unused, |
| 8441 | | }, |
| 8442 | | .dst_temps = .{ .mem, .unused }, |
| 8443 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8444 | | .each = .{ .once = &.{ |
| 8445 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8446 | | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8447 | | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 8448 | | .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8449 | | .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 8450 | | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 8451 | | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ }, |
| 8452 | | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ }, |
| 8453 | | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 8454 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8455 | | } }, |
| 8456 | | }, .{ |
| 8457 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8458 | | .src_constraints = .{ |
| 8459 | | .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8460 | | .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 8461 | | .any, |
| 8462 | | }, |
| 8463 | | .patterns = &.{ |
| 8464 | | .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } }, |
| 8465 | | }, |
| 8466 | | .call_frame = .{ .alignment = .@"16" }, |
| 8467 | | .extra_temps = .{ |
| 8468 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8469 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8470 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 8471 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 8472 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 8473 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } }, |
| 8474 | | .unused, |
| 8475 | | .unused, |
| 8476 | | .unused, |
| 8477 | | }, |
| 8478 | | .dst_temps = .{ .mem, .unused }, |
| 8479 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8480 | | .each = .{ .once = &.{ |
| 8481 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8482 | | .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8483 | | .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8484 | | .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8485 | | .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 8486 | | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 8487 | | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| 8488 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8489 | | } }, |
| 8490 | | }, .{ |
| 8491 | | .required_features = .{ .@"64bit", null, null, null }, |
| 8492 | | .src_constraints = .{ |
| 8493 | | .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8494 | | .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 8495 | | .any, |
| 8496 | | }, |
| 8497 | | .patterns = &.{ |
| 8498 | | .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } }, |
| 8499 | | }, |
| 8500 | | .call_frame = .{ .alignment = .@"16" }, |
| 8501 | | .extra_temps = .{ |
| 8502 | | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 8503 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 8504 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 8505 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 8506 | | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 8507 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } }, |
| 8508 | | .unused, |
| 8509 | | .unused, |
| 8510 | | .unused, |
| 8511 | | }, |
| 8512 | | .dst_temps = .{ .mem, .unused }, |
| 8513 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 8514 | | .each = .{ .once = &.{ |
| 8515 | | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 8516 | | .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8517 | | .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8518 | | .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, |
| 8519 | | .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 8520 | | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 8521 | | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| 8522 | | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 8523 | | } }, |
| 8524 | | }, .{ |
| 7794 | (if (cg.floatBits(ty.scalarType(zcu))) |_| cg.select(&res, &.{ty}, &ops, comptime &.{ .{ |
| 8525 | 7795 | .required_features = .{ .f16c, null, null, null }, |
| 8526 | 7796 | .src_constraints = .{ |
| 8527 | 7797 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| ... | ... | @@ -9502,10 +8772,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9502 | 8772 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9503 | 8773 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 9504 | 8774 | } }, |
| 9505 | | } }) catch |err| switch (err) { |
| 8775 | } }) else err: { |
| 8776 | res[0] = ops[0].divTruncInts(&ops[1], cg) catch |err| break :err err; |
| 8777 | }) catch |err| switch (err) { |
| 9506 | 8778 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 9507 | 8779 | @tagName(air_tag), |
| 9508 | | cg.typeOf(bin_op.lhs).fmt(pt), |
| 8780 | ty.fmt(pt), |
| 9509 | 8781 | ops[0].tracking(cg), |
| 9510 | 8782 | ops[1].tracking(cg), |
| 9511 | 8783 | }), |
| ... | ... | @@ -92399,6 +91671,748 @@ const Temp = struct { |
| 92399 | 91671 | return res[0]; |
| 92400 | 91672 | } |
| 92401 | 91673 | |
| 91674 | fn divTruncInts(lhs: *Temp, rhs: *Temp, cg: *CodeGen) Select.Error!Temp { |
| 91675 | var ops: [2]Temp = .{ lhs.*, rhs.* }; |
| 91676 | var res: [1]Temp = undefined; |
| 91677 | try cg.select(&res, &.{lhs.typeOf(cg)}, &ops, comptime &.{ .{ |
| 91678 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 91679 | .patterns = &.{ |
| 91680 | .{ .src = .{ .mem, .mem, .none } }, |
| 91681 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 91682 | .{ .src = .{ .mem, .to_gpr, .none } }, |
| 91683 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 91684 | }, |
| 91685 | .dst_temps = .{ .{ .reg = .al }, .unused }, |
| 91686 | .clobbers = .{ .eflags = true }, |
| 91687 | .each = .{ .once = &.{ |
| 91688 | .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ }, |
| 91689 | .{ ._, .i_, .div, .src1b, ._, ._, ._ }, |
| 91690 | } }, |
| 91691 | }, .{ |
| 91692 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 91693 | .patterns = &.{ |
| 91694 | .{ .src = .{ .mem, .mem, .none } }, |
| 91695 | .{ .src = .{ .to_gpr, .mem, .none } }, |
| 91696 | .{ .src = .{ .mem, .to_gpr, .none } }, |
| 91697 | .{ .src = .{ .to_gpr, .to_gpr, .none } }, |
| 91698 | }, |
| 91699 | .dst_temps = .{ .{ .reg = .al }, .unused }, |
| 91700 | .clobbers = .{ .eflags = true }, |
| 91701 | .each = .{ .once = &.{ |
| 91702 | .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ }, |
| 91703 | .{ ._, ._, .div, .src1b, ._, ._, ._ }, |
| 91704 | } }, |
| 91705 | }, .{ |
| 91706 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 91707 | .patterns = &.{ |
| 91708 | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| 91709 | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| 91710 | }, |
| 91711 | .extra_temps = .{ |
| 91712 | .{ .type = .i16, .kind = .{ .reg = .dx } }, |
| 91713 | .unused, |
| 91714 | .unused, |
| 91715 | .unused, |
| 91716 | .unused, |
| 91717 | .unused, |
| 91718 | .unused, |
| 91719 | .unused, |
| 91720 | .unused, |
| 91721 | }, |
| 91722 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 91723 | .clobbers = .{ .eflags = true }, |
| 91724 | .each = .{ .once = &.{ |
| 91725 | .{ ._, ._, .cwd, ._, ._, ._, ._ }, |
| 91726 | .{ ._, .i_, .div, .src1w, ._, ._, ._ }, |
| 91727 | } }, |
| 91728 | }, .{ |
| 91729 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 91730 | .patterns = &.{ |
| 91731 | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| 91732 | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| 91733 | }, |
| 91734 | .extra_temps = .{ |
| 91735 | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| 91736 | .unused, |
| 91737 | .unused, |
| 91738 | .unused, |
| 91739 | .unused, |
| 91740 | .unused, |
| 91741 | .unused, |
| 91742 | .unused, |
| 91743 | .unused, |
| 91744 | }, |
| 91745 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 91746 | .clobbers = .{ .eflags = true }, |
| 91747 | .each = .{ .once = &.{ |
| 91748 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 91749 | .{ ._, ._, .div, .src1w, ._, ._, ._ }, |
| 91750 | } }, |
| 91751 | }, .{ |
| 91752 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 91753 | .patterns = &.{ |
| 91754 | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| 91755 | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| 91756 | }, |
| 91757 | .extra_temps = .{ |
| 91758 | .{ .type = .i32, .kind = .{ .reg = .edx } }, |
| 91759 | .unused, |
| 91760 | .unused, |
| 91761 | .unused, |
| 91762 | .unused, |
| 91763 | .unused, |
| 91764 | .unused, |
| 91765 | .unused, |
| 91766 | .unused, |
| 91767 | }, |
| 91768 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 91769 | .clobbers = .{ .eflags = true }, |
| 91770 | .each = .{ .once = &.{ |
| 91771 | .{ ._, ._, .cdq, ._, ._, ._, ._ }, |
| 91772 | .{ ._, .i_, .div, .src1d, ._, ._, ._ }, |
| 91773 | } }, |
| 91774 | }, .{ |
| 91775 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 91776 | .patterns = &.{ |
| 91777 | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| 91778 | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| 91779 | }, |
| 91780 | .extra_temps = .{ |
| 91781 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 91782 | .unused, |
| 91783 | .unused, |
| 91784 | .unused, |
| 91785 | .unused, |
| 91786 | .unused, |
| 91787 | .unused, |
| 91788 | .unused, |
| 91789 | .unused, |
| 91790 | }, |
| 91791 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 91792 | .clobbers = .{ .eflags = true }, |
| 91793 | .each = .{ .once = &.{ |
| 91794 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 91795 | .{ ._, ._, .div, .src1d, ._, ._, ._ }, |
| 91796 | } }, |
| 91797 | }, .{ |
| 91798 | .required_features = .{ .@"64bit", null, null, null }, |
| 91799 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 91800 | .patterns = &.{ |
| 91801 | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| 91802 | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| 91803 | }, |
| 91804 | .extra_temps = .{ |
| 91805 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 91806 | .unused, |
| 91807 | .unused, |
| 91808 | .unused, |
| 91809 | .unused, |
| 91810 | .unused, |
| 91811 | .unused, |
| 91812 | .unused, |
| 91813 | .unused, |
| 91814 | }, |
| 91815 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 91816 | .clobbers = .{ .eflags = true }, |
| 91817 | .each = .{ .once = &.{ |
| 91818 | .{ ._, ._, .cqo, ._, ._, ._, ._ }, |
| 91819 | .{ ._, .i_, .div, .src1q, ._, ._, ._ }, |
| 91820 | } }, |
| 91821 | }, .{ |
| 91822 | .required_features = .{ .@"64bit", null, null, null }, |
| 91823 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 91824 | .patterns = &.{ |
| 91825 | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| 91826 | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| 91827 | }, |
| 91828 | .extra_temps = .{ |
| 91829 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 91830 | .unused, |
| 91831 | .unused, |
| 91832 | .unused, |
| 91833 | .unused, |
| 91834 | .unused, |
| 91835 | .unused, |
| 91836 | .unused, |
| 91837 | .unused, |
| 91838 | }, |
| 91839 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 91840 | .clobbers = .{ .eflags = true }, |
| 91841 | .each = .{ .once = &.{ |
| 91842 | .{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ }, |
| 91843 | .{ ._, ._, .div, .src1q, ._, ._, ._ }, |
| 91844 | } }, |
| 91845 | }, .{ |
| 91846 | .required_features = .{ .@"64bit", null, null, null }, |
| 91847 | .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any }, |
| 91848 | .patterns = &.{ |
| 91849 | .{ .src = .{ |
| 91850 | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } }, |
| 91851 | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } }, |
| 91852 | .none, |
| 91853 | } }, |
| 91854 | }, |
| 91855 | .call_frame = .{ .alignment = .@"16" }, |
| 91856 | .extra_temps = .{ |
| 91857 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } }, |
| 91858 | .unused, |
| 91859 | .unused, |
| 91860 | .unused, |
| 91861 | .unused, |
| 91862 | .unused, |
| 91863 | .unused, |
| 91864 | .unused, |
| 91865 | .unused, |
| 91866 | }, |
| 91867 | .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused }, |
| 91868 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 91869 | .each = .{ .once = &.{ |
| 91870 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 91871 | } }, |
| 91872 | }, .{ |
| 91873 | .required_features = .{ .@"64bit", null, null, null }, |
| 91874 | .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any }, |
| 91875 | .patterns = &.{ |
| 91876 | .{ .src = .{ |
| 91877 | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } }, |
| 91878 | .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } }, |
| 91879 | .none, |
| 91880 | } }, |
| 91881 | }, |
| 91882 | .call_frame = .{ .alignment = .@"16" }, |
| 91883 | .extra_temps = .{ |
| 91884 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } }, |
| 91885 | .unused, |
| 91886 | .unused, |
| 91887 | .unused, |
| 91888 | .unused, |
| 91889 | .unused, |
| 91890 | .unused, |
| 91891 | .unused, |
| 91892 | .unused, |
| 91893 | }, |
| 91894 | .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused }, |
| 91895 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 91896 | .each = .{ .once = &.{ |
| 91897 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 91898 | } }, |
| 91899 | }, .{ |
| 91900 | .required_features = .{ .@"64bit", null, null, null }, |
| 91901 | .src_constraints = .{ |
| 91902 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 91903 | .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 91904 | .any, |
| 91905 | }, |
| 91906 | .patterns = &.{ |
| 91907 | .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } }, |
| 91908 | }, |
| 91909 | .call_frame = .{ .alignment = .@"16" }, |
| 91910 | .extra_temps = .{ |
| 91911 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 91912 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 91913 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 91914 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 91915 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } }, |
| 91916 | .unused, |
| 91917 | .unused, |
| 91918 | .unused, |
| 91919 | .unused, |
| 91920 | }, |
| 91921 | .dst_temps = .{ .mem, .unused }, |
| 91922 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 91923 | .each = .{ .once = &.{ |
| 91924 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 91925 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 91926 | .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ }, |
| 91927 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ }, |
| 91928 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 91929 | } }, |
| 91930 | }, .{ |
| 91931 | .required_features = .{ .@"64bit", null, null, null }, |
| 91932 | .src_constraints = .{ |
| 91933 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 91934 | .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 91935 | .any, |
| 91936 | }, |
| 91937 | .patterns = &.{ |
| 91938 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 91939 | }, |
| 91940 | .call_frame = .{ .alignment = .@"16" }, |
| 91941 | .extra_temps = .{ |
| 91942 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 91943 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 91944 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 91945 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 91946 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } }, |
| 91947 | .unused, |
| 91948 | .unused, |
| 91949 | .unused, |
| 91950 | .unused, |
| 91951 | }, |
| 91952 | .dst_temps = .{ .mem, .unused }, |
| 91953 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 91954 | .each = .{ .once = &.{ |
| 91955 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 91956 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| 91957 | .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ }, |
| 91958 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ }, |
| 91959 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 91960 | } }, |
| 91961 | }, .{ |
| 91962 | .required_features = .{ .slow_incdec, null, null, null }, |
| 91963 | .src_constraints = .{ |
| 91964 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 91965 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 91966 | .any, |
| 91967 | }, |
| 91968 | .patterns = &.{ |
| 91969 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 91970 | }, |
| 91971 | .extra_temps = .{ |
| 91972 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 91973 | .{ .type = .i8, .kind = .{ .reg = .al } }, |
| 91974 | .unused, |
| 91975 | .unused, |
| 91976 | .unused, |
| 91977 | .unused, |
| 91978 | .unused, |
| 91979 | .unused, |
| 91980 | .unused, |
| 91981 | }, |
| 91982 | .dst_temps = .{ .mem, .unused }, |
| 91983 | .clobbers = .{ .eflags = true }, |
| 91984 | .each = .{ .once = &.{ |
| 91985 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 91986 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 91987 | .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 91988 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 91989 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 91990 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 91991 | } }, |
| 91992 | }, .{ |
| 91993 | .src_constraints = .{ |
| 91994 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 91995 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| 91996 | .any, |
| 91997 | }, |
| 91998 | .patterns = &.{ |
| 91999 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92000 | }, |
| 92001 | .extra_temps = .{ |
| 92002 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92003 | .{ .type = .i8, .kind = .{ .reg = .al } }, |
| 92004 | .unused, |
| 92005 | .unused, |
| 92006 | .unused, |
| 92007 | .unused, |
| 92008 | .unused, |
| 92009 | .unused, |
| 92010 | .unused, |
| 92011 | }, |
| 92012 | .dst_temps = .{ .mem, .unused }, |
| 92013 | .clobbers = .{ .eflags = true }, |
| 92014 | .each = .{ .once = &.{ |
| 92015 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92016 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92017 | .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92018 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 92019 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 92020 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 92021 | } }, |
| 92022 | }, .{ |
| 92023 | .required_features = .{ .slow_incdec, null, null, null }, |
| 92024 | .src_constraints = .{ |
| 92025 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 92026 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 92027 | .any, |
| 92028 | }, |
| 92029 | .patterns = &.{ |
| 92030 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92031 | }, |
| 92032 | .extra_temps = .{ |
| 92033 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92034 | .{ .type = .u8, .kind = .{ .reg = .al } }, |
| 92035 | .unused, |
| 92036 | .unused, |
| 92037 | .unused, |
| 92038 | .unused, |
| 92039 | .unused, |
| 92040 | .unused, |
| 92041 | .unused, |
| 92042 | }, |
| 92043 | .dst_temps = .{ .mem, .unused }, |
| 92044 | .clobbers = .{ .eflags = true }, |
| 92045 | .each = .{ .once = &.{ |
| 92046 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92047 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92048 | .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92049 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 92050 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 92051 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92052 | } }, |
| 92053 | }, .{ |
| 92054 | .src_constraints = .{ |
| 92055 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 92056 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| 92057 | .any, |
| 92058 | }, |
| 92059 | .patterns = &.{ |
| 92060 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92061 | }, |
| 92062 | .extra_temps = .{ |
| 92063 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92064 | .{ .type = .u8, .kind = .{ .reg = .al } }, |
| 92065 | .unused, |
| 92066 | .unused, |
| 92067 | .unused, |
| 92068 | .unused, |
| 92069 | .unused, |
| 92070 | .unused, |
| 92071 | .unused, |
| 92072 | }, |
| 92073 | .dst_temps = .{ .mem, .unused }, |
| 92074 | .clobbers = .{ .eflags = true }, |
| 92075 | .each = .{ .once = &.{ |
| 92076 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92077 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92078 | .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92079 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 92080 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 92081 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 92082 | } }, |
| 92083 | }, .{ |
| 92084 | .src_constraints = .{ |
| 92085 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 92086 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| 92087 | .any, |
| 92088 | }, |
| 92089 | .patterns = &.{ |
| 92090 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92091 | }, |
| 92092 | .extra_temps = .{ |
| 92093 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92094 | .{ .type = .i16, .kind = .{ .reg = .ax } }, |
| 92095 | .{ .type = .i16, .kind = .{ .reg = .dx } }, |
| 92096 | .unused, |
| 92097 | .unused, |
| 92098 | .unused, |
| 92099 | .unused, |
| 92100 | .unused, |
| 92101 | .unused, |
| 92102 | }, |
| 92103 | .dst_temps = .{ .mem, .unused }, |
| 92104 | .clobbers = .{ .eflags = true }, |
| 92105 | .each = .{ .once = &.{ |
| 92106 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92107 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92108 | .{ ._, ._, .cwd, ._, ._, ._, ._ }, |
| 92109 | .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92110 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 92111 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 92112 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92113 | } }, |
| 92114 | }, .{ |
| 92115 | .src_constraints = .{ |
| 92116 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 92117 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| 92118 | .any, |
| 92119 | }, |
| 92120 | .patterns = &.{ |
| 92121 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92122 | }, |
| 92123 | .extra_temps = .{ |
| 92124 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92125 | .{ .type = .u16, .kind = .{ .reg = .ax } }, |
| 92126 | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| 92127 | .unused, |
| 92128 | .unused, |
| 92129 | .unused, |
| 92130 | .unused, |
| 92131 | .unused, |
| 92132 | .unused, |
| 92133 | }, |
| 92134 | .dst_temps = .{ .mem, .unused }, |
| 92135 | .clobbers = .{ .eflags = true }, |
| 92136 | .each = .{ .once = &.{ |
| 92137 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92138 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92139 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 92140 | .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92141 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 92142 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 92143 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92144 | } }, |
| 92145 | }, .{ |
| 92146 | .src_constraints = .{ |
| 92147 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 92148 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| 92149 | .any, |
| 92150 | }, |
| 92151 | .patterns = &.{ |
| 92152 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92153 | }, |
| 92154 | .extra_temps = .{ |
| 92155 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92156 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 92157 | .{ .type = .i32, .kind = .{ .reg = .edx } }, |
| 92158 | .unused, |
| 92159 | .unused, |
| 92160 | .unused, |
| 92161 | .unused, |
| 92162 | .unused, |
| 92163 | .unused, |
| 92164 | }, |
| 92165 | .dst_temps = .{ .mem, .unused }, |
| 92166 | .clobbers = .{ .eflags = true }, |
| 92167 | .each = .{ .once = &.{ |
| 92168 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92169 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92170 | .{ ._, ._, .cdq, ._, ._, ._, ._ }, |
| 92171 | .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92172 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 92173 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 92174 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92175 | } }, |
| 92176 | }, .{ |
| 92177 | .src_constraints = .{ |
| 92178 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 92179 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 92180 | .any, |
| 92181 | }, |
| 92182 | .patterns = &.{ |
| 92183 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92184 | }, |
| 92185 | .extra_temps = .{ |
| 92186 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92187 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 92188 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| 92189 | .unused, |
| 92190 | .unused, |
| 92191 | .unused, |
| 92192 | .unused, |
| 92193 | .unused, |
| 92194 | .unused, |
| 92195 | }, |
| 92196 | .dst_temps = .{ .mem, .unused }, |
| 92197 | .clobbers = .{ .eflags = true }, |
| 92198 | .each = .{ .once = &.{ |
| 92199 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92200 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92201 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 92202 | .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92203 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 92204 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 92205 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92206 | } }, |
| 92207 | }, .{ |
| 92208 | .required_features = .{ .@"64bit", null, null, null }, |
| 92209 | .src_constraints = .{ |
| 92210 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 92211 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| 92212 | .any, |
| 92213 | }, |
| 92214 | .patterns = &.{ |
| 92215 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92216 | }, |
| 92217 | .extra_temps = .{ |
| 92218 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92219 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 92220 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 92221 | .unused, |
| 92222 | .unused, |
| 92223 | .unused, |
| 92224 | .unused, |
| 92225 | .unused, |
| 92226 | .unused, |
| 92227 | }, |
| 92228 | .dst_temps = .{ .mem, .unused }, |
| 92229 | .clobbers = .{ .eflags = true }, |
| 92230 | .each = .{ .once = &.{ |
| 92231 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92232 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92233 | .{ ._, ._, .cqo, ._, ._, ._, ._ }, |
| 92234 | .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92235 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 92236 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 92237 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92238 | } }, |
| 92239 | }, .{ |
| 92240 | .required_features = .{ .@"64bit", null, null, null }, |
| 92241 | .src_constraints = .{ |
| 92242 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 92243 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| 92244 | .any, |
| 92245 | }, |
| 92246 | .patterns = &.{ |
| 92247 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92248 | }, |
| 92249 | .extra_temps = .{ |
| 92250 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92251 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 92252 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 92253 | .unused, |
| 92254 | .unused, |
| 92255 | .unused, |
| 92256 | .unused, |
| 92257 | .unused, |
| 92258 | .unused, |
| 92259 | }, |
| 92260 | .dst_temps = .{ .mem, .unused }, |
| 92261 | .clobbers = .{ .eflags = true }, |
| 92262 | .each = .{ .once = &.{ |
| 92263 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92264 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92265 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 92266 | .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 92267 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 92268 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 92269 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92270 | } }, |
| 92271 | }, .{ |
| 92272 | .required_features = .{ .@"64bit", null, null, null }, |
| 92273 | .src_constraints = .{ |
| 92274 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, |
| 92275 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, |
| 92276 | .any, |
| 92277 | }, |
| 92278 | .patterns = &.{ |
| 92279 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92280 | }, |
| 92281 | .call_frame = .{ .alignment = .@"16" }, |
| 92282 | .extra_temps = .{ |
| 92283 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92284 | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 92285 | .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 92286 | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 92287 | .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 92288 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } }, |
| 92289 | .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 92290 | .unused, |
| 92291 | .unused, |
| 92292 | }, |
| 92293 | .dst_temps = .{ .mem, .unused }, |
| 92294 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 92295 | .each = .{ .once = &.{ |
| 92296 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92297 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92298 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 92299 | .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92300 | .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 92301 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 92302 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ }, |
| 92303 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ }, |
| 92304 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 92305 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92306 | } }, |
| 92307 | }, .{ |
| 92308 | .required_features = .{ .@"64bit", null, null, null }, |
| 92309 | .src_constraints = .{ |
| 92310 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 92311 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 92312 | .any, |
| 92313 | }, |
| 92314 | .patterns = &.{ |
| 92315 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 92316 | }, |
| 92317 | .call_frame = .{ .alignment = .@"16" }, |
| 92318 | .extra_temps = .{ |
| 92319 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92320 | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 92321 | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 92322 | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 92323 | .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 92324 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } }, |
| 92325 | .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 92326 | .unused, |
| 92327 | .unused, |
| 92328 | }, |
| 92329 | .dst_temps = .{ .mem, .unused }, |
| 92330 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 92331 | .each = .{ .once = &.{ |
| 92332 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92333 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92334 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 92335 | .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92336 | .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 92337 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 92338 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ }, |
| 92339 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ }, |
| 92340 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 92341 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92342 | } }, |
| 92343 | }, .{ |
| 92344 | .required_features = .{ .@"64bit", null, null, null }, |
| 92345 | .src_constraints = .{ |
| 92346 | .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 92347 | .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, |
| 92348 | .any, |
| 92349 | }, |
| 92350 | .patterns = &.{ |
| 92351 | .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } }, |
| 92352 | }, |
| 92353 | .call_frame = .{ .alignment = .@"16" }, |
| 92354 | .extra_temps = .{ |
| 92355 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92356 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 92357 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 92358 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 92359 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 92360 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } }, |
| 92361 | .unused, |
| 92362 | .unused, |
| 92363 | .unused, |
| 92364 | }, |
| 92365 | .dst_temps = .{ .mem, .unused }, |
| 92366 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 92367 | .each = .{ .once = &.{ |
| 92368 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92369 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92370 | .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92371 | .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92372 | .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 92373 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 92374 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| 92375 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92376 | } }, |
| 92377 | }, .{ |
| 92378 | .required_features = .{ .@"64bit", null, null, null }, |
| 92379 | .src_constraints = .{ |
| 92380 | .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 92381 | .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| 92382 | .any, |
| 92383 | }, |
| 92384 | .patterns = &.{ |
| 92385 | .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } }, |
| 92386 | }, |
| 92387 | .call_frame = .{ .alignment = .@"16" }, |
| 92388 | .extra_temps = .{ |
| 92389 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 92390 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } }, |
| 92391 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } }, |
| 92392 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } }, |
| 92393 | .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } }, |
| 92394 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } }, |
| 92395 | .unused, |
| 92396 | .unused, |
| 92397 | .unused, |
| 92398 | }, |
| 92399 | .dst_temps = .{ .mem, .unused }, |
| 92400 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 92401 | .each = .{ .once = &.{ |
| 92402 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 92403 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92404 | .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92405 | .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ }, |
| 92406 | .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 92407 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 92408 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| 92409 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 92410 | } }, |
| 92411 | } }); |
| 92412 | lhs.*, rhs.* = ops; |
| 92413 | return res[0]; |
| 92414 | } |
| 92415 | |
| 92402 | 92416 | fn finish( |
| 92403 | 92417 | temp: Temp, |
| 92404 | 92418 | inst: Air.Inst.Index, |
Jacob Young <jacobly@ziglang.org> 2025-02-14 19:53:27-05:00
src