| ... | @@ -6903,12 +6903,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6903,12 +6903,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6903 | else => unreachable, | 6903 | else => unreachable, |
| 6904 | .div_float, .div_float_optimized => .div_float, | 6904 | .div_float, .div_float_optimized => .div_float, |
| 6905 | .div_exact, .div_exact_optimized => .div_exact, | 6905 | .div_exact, .div_exact_optimized => .div_exact, |
| 6906 | }) else fallback: { | 6906 | }) else { |
| 6907 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 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 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 6909 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 6910 | var res: [1]Temp = undefined; | 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 | .required_features = .{ .f16c, null, null, null }, | 6912 | .required_features = .{ .f16c, null, null, null }, |
| 6913 | .src_constraints = .{ | 6913 | .src_constraints = .{ |
| 6914 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 6914 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| ... | @@ -7772,10 +7772,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7772,10 +7772,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7772 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 7772 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 7773 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 7779 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 7777 | @tagName(air_tag), | 7780 | @tagName(air_tag), |
| 7778 | cg.typeOf(bin_op.lhs).fmt(pt), | 7781 | ty.fmt(pt), |
| 7779 | ops[0].tracking(cg), | 7782 | ops[0].tracking(cg), |
| 7780 | ops[1].tracking(cg), | 7783 | ops[1].tracking(cg), |
| 7781 | }), | 7784 | }), |
| ... | @@ -7785,743 +7788,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7785,743 +7788,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7785 | }, | 7788 | }, |
| 7786 | .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else { | 7789 | .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else { |
| 7787 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 7790 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| | 7791 | const ty = cg.typeOf(bin_op.lhs); |
| 7788 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 7792 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 7789 | var res: [1]Temp = undefined; | 7793 | var res: [1]Temp = undefined; |
| 7790 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 7794 | (if (cg.floatBits(ty.scalarType(zcu))) |_| cg.select(&res, &.{ty}, &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 | }, .{ | | |
| 8525 | .required_features = .{ .f16c, null, null, null }, | 7795 | .required_features = .{ .f16c, null, null, null }, |
| 8526 | .src_constraints = .{ | 7796 | .src_constraints = .{ |
| 8527 | .{ .scalar_float = .{ .of = .word, .is = .word } }, | 7797 | .{ .scalar_float = .{ .of = .word, .is = .word } }, |
| ... | @@ -9502,10 +8772,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -9502,10 +8772,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 9502 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, | 8772 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 9503 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 8778 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 9507 | @tagName(air_tag), | 8779 | @tagName(air_tag), |
| 9508 | cg.typeOf(bin_op.lhs).fmt(pt), | 8780 | ty.fmt(pt), |
| 9509 | ops[0].tracking(cg), | 8781 | ops[0].tracking(cg), |
| 9510 | ops[1].tracking(cg), | 8782 | ops[1].tracking(cg), |
| 9511 | }), | 8783 | }), |
| ... | @@ -92399,6 +91671,748 @@ const Temp = struct { | ... | @@ -92399,6 +91671,748 @@ const Temp = struct { |
| 92399 | return res[0]; | 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 | fn finish( | 92416 | fn finish( |
| 92403 | temp: Temp, | 92417 | temp: Temp, |
| 92404 | inst: Air.Inst.Index, | 92418 | inst: Air.Inst.Index, |
Jacob Young <jacobly@ziglang.org> 2025-02-14 19:53:27-05:00
src