| ... | @@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2418 | } | 2418 | } |
| 2419 | | 2419 | |
| 2420 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2420 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2421 | @setEvalBranchQuota(14_100); | 2421 | @setEvalBranchQuota(14_200); |
| 2422 | const pt = cg.pt; | 2422 | const pt = cg.pt; |
| 2423 | const zcu = pt.zcu; | 2423 | const zcu = pt.zcu; |
| 2424 | const ip = &zcu.intern_pool; | 2424 | const ip = &zcu.intern_pool; |
| ... | @@ -2459,7 +2459,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2459,7 +2459,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2459 | .mul_sat => try cg.airMulSat(inst), | 2459 | .mul_sat => try cg.airMulSat(inst), |
| 2460 | .shl_sat => try cg.airShlSat(inst), | 2460 | .shl_sat => try cg.airShlSat(inst), |
| 2461 | | 2461 | |
| 2462 | .sub_with_overflow => try cg.airAddSubWithOverflow(inst), | | |
| 2463 | .mul_with_overflow => try cg.airMulWithOverflow(inst), | 2462 | .mul_with_overflow => try cg.airMulWithOverflow(inst), |
| 2464 | .shl_with_overflow => try cg.airShlWithOverflow(inst), | 2463 | .shl_with_overflow => try cg.airShlWithOverflow(inst), |
| 2465 | | 2464 | |
| ... | @@ -28500,8 +28499,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28500,8 +28499,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28500 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 28499 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 28501 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, | 28500 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 28502 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, | 28501 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| 28503 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, | | |
| 28504 | .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, | 28502 | .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 28503 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| 28505 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 28504 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 28506 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, | 28505 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| 28507 | } }, | 28506 | } }, |
| ... | @@ -28869,6 +28868,912 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28869,6 +28868,912 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28869 | try res[0].withOverflow(&res[1], cg); | 28868 | try res[0].withOverflow(&res[1], cg); |
| 28870 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 28869 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 28871 | }, | 28870 | }, |
| | 28871 | .sub_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: { |
| | 28872 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| | 28873 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| | 28874 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst); |
| | 28875 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| | 28876 | var res: [2]Temp = undefined; |
| | 28877 | cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ |
| | 28878 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| | 28879 | .patterns = &.{ |
| | 28880 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28881 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28882 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28883 | }, |
| | 28884 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28885 | .clobbers = .{ .eflags = true }, |
| | 28886 | .each = .{ .once = &.{ |
| | 28887 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28888 | } }, |
| | 28889 | }, .{ |
| | 28890 | .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any }, |
| | 28891 | .patterns = &.{ |
| | 28892 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28893 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28894 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28895 | }, |
| | 28896 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28897 | .clobbers = .{ .eflags = true }, |
| | 28898 | .each = .{ .once = &.{ |
| | 28899 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28900 | } }, |
| | 28901 | }, .{ |
| | 28902 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| | 28903 | .patterns = &.{ |
| | 28904 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28905 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28906 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28907 | }, |
| | 28908 | .extra_temps = .{ |
| | 28909 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28910 | .unused, |
| | 28911 | .unused, |
| | 28912 | .unused, |
| | 28913 | .unused, |
| | 28914 | .unused, |
| | 28915 | .unused, |
| | 28916 | .unused, |
| | 28917 | .unused, |
| | 28918 | .unused, |
| | 28919 | .unused, |
| | 28920 | }, |
| | 28921 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .po } }, |
| | 28922 | .clobbers = .{ .eflags = true }, |
| | 28923 | .each = .{ .once = &.{ |
| | 28924 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28925 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 28926 | .{ ._, ._l, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ }, |
| | 28927 | .{ ._, ._r, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ }, |
| | 28928 | .{ ._, ._, .@"test", .tmp0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 28929 | } }, |
| | 28930 | }, .{ |
| | 28931 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| | 28932 | .patterns = &.{ |
| | 28933 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28934 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28935 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 28936 | }, |
| | 28937 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 28938 | .clobbers = .{ .eflags = true }, |
| | 28939 | .each = .{ .once = &.{ |
| | 28940 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 28941 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28942 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 28943 | .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| | 28944 | } }, |
| | 28945 | }, .{ |
| | 28946 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| | 28947 | .patterns = &.{ |
| | 28948 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 28949 | }, |
| | 28950 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 28951 | .clobbers = .{ .eflags = true }, |
| | 28952 | .each = .{ .once = &.{ |
| | 28953 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28954 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 28955 | .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| | 28956 | } }, |
| | 28957 | }, .{ |
| | 28958 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| | 28959 | .patterns = &.{ |
| | 28960 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28961 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28962 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28963 | }, |
| | 28964 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28965 | .clobbers = .{ .eflags = true }, |
| | 28966 | .each = .{ .once = &.{ |
| | 28967 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 28968 | } }, |
| | 28969 | }, .{ |
| | 28970 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any }, |
| | 28971 | .patterns = &.{ |
| | 28972 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28973 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28974 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28975 | }, |
| | 28976 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28977 | .clobbers = .{ .eflags = true }, |
| | 28978 | .each = .{ .once = &.{ |
| | 28979 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 28980 | } }, |
| | 28981 | }, .{ |
| | 28982 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 28983 | .patterns = &.{ |
| | 28984 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28985 | }, |
| | 28986 | .extra_temps = .{ |
| | 28987 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28988 | .unused, |
| | 28989 | .unused, |
| | 28990 | .unused, |
| | 28991 | .unused, |
| | 28992 | .unused, |
| | 28993 | .unused, |
| | 28994 | .unused, |
| | 28995 | .unused, |
| | 28996 | .unused, |
| | 28997 | .unused, |
| | 28998 | }, |
| | 28999 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29000 | .clobbers = .{ .eflags = true }, |
| | 29001 | .each = .{ .once = &.{ |
| | 29002 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29003 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29004 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29005 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29006 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 29007 | } }, |
| | 29008 | }, .{ |
| | 29009 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 29010 | .patterns = &.{ |
| | 29011 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29012 | }, |
| | 29013 | .extra_temps = .{ |
| | 29014 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29015 | .unused, |
| | 29016 | .unused, |
| | 29017 | .unused, |
| | 29018 | .unused, |
| | 29019 | .unused, |
| | 29020 | .unused, |
| | 29021 | .unused, |
| | 29022 | .unused, |
| | 29023 | .unused, |
| | 29024 | .unused, |
| | 29025 | }, |
| | 29026 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29027 | .clobbers = .{ .eflags = true }, |
| | 29028 | .each = .{ .once = &.{ |
| | 29029 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29030 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29031 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29032 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29033 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 29034 | } }, |
| | 29035 | }, .{ |
| | 29036 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 29037 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29038 | .patterns = &.{ |
| | 29039 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 29040 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29041 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29042 | }, |
| | 29043 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29044 | .clobbers = .{ .eflags = true }, |
| | 29045 | .each = .{ .once = &.{ |
| | 29046 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29047 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29048 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29049 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 29050 | } }, |
| | 29051 | }, .{ |
| | 29052 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 29053 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29054 | .patterns = &.{ |
| | 29055 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29056 | }, |
| | 29057 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29058 | .clobbers = .{ .eflags = true }, |
| | 29059 | .each = .{ .once = &.{ |
| | 29060 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29061 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29062 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 29063 | } }, |
| | 29064 | }, .{ |
| | 29065 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29066 | .patterns = &.{ |
| | 29067 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 29068 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29069 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29070 | }, |
| | 29071 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29072 | .clobbers = .{ .eflags = true }, |
| | 29073 | .each = .{ .once = &.{ |
| | 29074 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29075 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29076 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29077 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29078 | } }, |
| | 29079 | }, .{ |
| | 29080 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29081 | .patterns = &.{ |
| | 29082 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29083 | }, |
| | 29084 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29085 | .clobbers = .{ .eflags = true }, |
| | 29086 | .each = .{ .once = &.{ |
| | 29087 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29088 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29089 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29090 | } }, |
| | 29091 | }, .{ |
| | 29092 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| | 29093 | .patterns = &.{ |
| | 29094 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29095 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29096 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29097 | }, |
| | 29098 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29099 | .clobbers = .{ .eflags = true }, |
| | 29100 | .each = .{ .once = &.{ |
| | 29101 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29102 | } }, |
| | 29103 | }, .{ |
| | 29104 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any }, |
| | 29105 | .patterns = &.{ |
| | 29106 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29107 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29108 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29109 | }, |
| | 29110 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29111 | .clobbers = .{ .eflags = true }, |
| | 29112 | .each = .{ .once = &.{ |
| | 29113 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29114 | } }, |
| | 29115 | }, .{ |
| | 29116 | .required_features = .{ .bmi2, null, null, null }, |
| | 29117 | .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any }, |
| | 29118 | .patterns = &.{ |
| | 29119 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29120 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29121 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29122 | }, |
| | 29123 | .extra_temps = .{ |
| | 29124 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29125 | .unused, |
| | 29126 | .unused, |
| | 29127 | .unused, |
| | 29128 | .unused, |
| | 29129 | .unused, |
| | 29130 | .unused, |
| | 29131 | .unused, |
| | 29132 | .unused, |
| | 29133 | .unused, |
| | 29134 | .unused, |
| | 29135 | }, |
| | 29136 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29137 | .clobbers = .{ .eflags = true }, |
| | 29138 | .each = .{ .once = &.{ |
| | 29139 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29140 | .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ }, |
| | 29141 | .{ ._, ._, .add, .dst0d, .dst0d, ._, ._ }, |
| | 29142 | .{ ._, ._rx, .sa, .dst0d, .dst0d, .tmp0d, ._ }, |
| | 29143 | } }, |
| | 29144 | }, .{ |
| | 29145 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| | 29146 | .patterns = &.{ |
| | 29147 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29148 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29149 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29150 | }, |
| | 29151 | .extra_temps = .{ |
| | 29152 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29153 | .unused, |
| | 29154 | .unused, |
| | 29155 | .unused, |
| | 29156 | .unused, |
| | 29157 | .unused, |
| | 29158 | .unused, |
| | 29159 | .unused, |
| | 29160 | .unused, |
| | 29161 | .unused, |
| | 29162 | .unused, |
| | 29163 | }, |
| | 29164 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29165 | .clobbers = .{ .eflags = true }, |
| | 29166 | .each = .{ .once = &.{ |
| | 29167 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29168 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29169 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29170 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29171 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 29172 | } }, |
| | 29173 | }, .{ |
| | 29174 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| | 29175 | .patterns = &.{ |
| | 29176 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29177 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29178 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29179 | }, |
| | 29180 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29181 | .clobbers = .{ .eflags = true }, |
| | 29182 | .each = .{ .once = &.{ |
| | 29183 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29184 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29185 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29186 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29187 | } }, |
| | 29188 | }, .{ |
| | 29189 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| | 29190 | .patterns = &.{ |
| | 29191 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29192 | }, |
| | 29193 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29194 | .clobbers = .{ .eflags = true }, |
| | 29195 | .each = .{ .once = &.{ |
| | 29196 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29197 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29198 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29199 | } }, |
| | 29200 | }, .{ |
| | 29201 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29202 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| | 29203 | .patterns = &.{ |
| | 29204 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29205 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29206 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29207 | }, |
| | 29208 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29209 | .clobbers = .{ .eflags = true }, |
| | 29210 | .each = .{ .once = &.{ |
| | 29211 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29212 | } }, |
| | 29213 | }, .{ |
| | 29214 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29215 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, |
| | 29216 | .patterns = &.{ |
| | 29217 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29218 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29219 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29220 | }, |
| | 29221 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29222 | .clobbers = .{ .eflags = true }, |
| | 29223 | .each = .{ .once = &.{ |
| | 29224 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29225 | } }, |
| | 29226 | }, .{ |
| | 29227 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29228 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, |
| | 29229 | .patterns = &.{ |
| | 29230 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29231 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29232 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29233 | }, |
| | 29234 | .extra_temps = .{ |
| | 29235 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29236 | .unused, |
| | 29237 | .unused, |
| | 29238 | .unused, |
| | 29239 | .unused, |
| | 29240 | .unused, |
| | 29241 | .unused, |
| | 29242 | .unused, |
| | 29243 | .unused, |
| | 29244 | .unused, |
| | 29245 | .unused, |
| | 29246 | }, |
| | 29247 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29248 | .clobbers = .{ .eflags = true }, |
| | 29249 | .each = .{ .once = &.{ |
| | 29250 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29251 | .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ }, |
| | 29252 | .{ ._, ._, .add, .dst0q, .dst0q, ._, ._ }, |
| | 29253 | .{ ._, ._rx, .sa, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 29254 | } }, |
| | 29255 | }, .{ |
| | 29256 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29257 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 29258 | .patterns = &.{ |
| | 29259 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29260 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29261 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29262 | }, |
| | 29263 | .extra_temps = .{ |
| | 29264 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29265 | .unused, |
| | 29266 | .unused, |
| | 29267 | .unused, |
| | 29268 | .unused, |
| | 29269 | .unused, |
| | 29270 | .unused, |
| | 29271 | .unused, |
| | 29272 | .unused, |
| | 29273 | .unused, |
| | 29274 | .unused, |
| | 29275 | }, |
| | 29276 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29277 | .clobbers = .{ .eflags = true }, |
| | 29278 | .each = .{ .once = &.{ |
| | 29279 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29280 | .{ ._, ._l, .ro, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 29281 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 29282 | .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 29283 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 29284 | } }, |
| | 29285 | }, .{ |
| | 29286 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29287 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29288 | .patterns = &.{ |
| | 29289 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29290 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29291 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29292 | }, |
| | 29293 | .extra_temps = .{ |
| | 29294 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 29295 | .unused, |
| | 29296 | .unused, |
| | 29297 | .unused, |
| | 29298 | .unused, |
| | 29299 | .unused, |
| | 29300 | .unused, |
| | 29301 | .unused, |
| | 29302 | .unused, |
| | 29303 | .unused, |
| | 29304 | .unused, |
| | 29305 | }, |
| | 29306 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29307 | .clobbers = .{ .eflags = true }, |
| | 29308 | .each = .{ .once = &.{ |
| | 29309 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29310 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ }, |
| | 29311 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29312 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29313 | .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 29314 | } }, |
| | 29315 | }, .{ |
| | 29316 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29317 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29318 | .patterns = &.{ |
| | 29319 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29320 | }, |
| | 29321 | .extra_temps = .{ |
| | 29322 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 29323 | .unused, |
| | 29324 | .unused, |
| | 29325 | .unused, |
| | 29326 | .unused, |
| | 29327 | .unused, |
| | 29328 | .unused, |
| | 29329 | .unused, |
| | 29330 | .unused, |
| | 29331 | .unused, |
| | 29332 | .unused, |
| | 29333 | }, |
| | 29334 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29335 | .clobbers = .{ .eflags = true }, |
| | 29336 | .each = .{ .once = &.{ |
| | 29337 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ }, |
| | 29338 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29339 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29340 | .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 29341 | } }, |
| | 29342 | }, .{ |
| | 29343 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29344 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29345 | .patterns = &.{ |
| | 29346 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29347 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29348 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29349 | }, |
| | 29350 | .dst_temps = .{ .{ .rc = .general_purpose }, .{ .rc = .general_purpose } }, |
| | 29351 | .clobbers = .{ .eflags = true }, |
| | 29352 | .each = .{ .once = &.{ |
| | 29353 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29354 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29355 | .{ ._, ._, .sub, .src0q, .src1q, ._, ._ }, |
| | 29356 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29357 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 29358 | } }, |
| | 29359 | }, .{ |
| | 29360 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29361 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29362 | .patterns = &.{ |
| | 29363 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29364 | }, |
| | 29365 | .dst_temps = .{ .{ .rc = .general_purpose }, .{ .ref = .src1 } }, |
| | 29366 | .clobbers = .{ .eflags = true }, |
| | 29367 | .each = .{ .once = &.{ |
| | 29368 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29369 | .{ ._, ._, .sub, .src0q, .src1q, ._, ._ }, |
| | 29370 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29371 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 29372 | } }, |
| | 29373 | }, .{ |
| | 29374 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29375 | .src_constraints = .{ |
| | 29376 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29377 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29378 | .any, |
| | 29379 | }, |
| | 29380 | .patterns = &.{ |
| | 29381 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29382 | }, |
| | 29383 | .extra_temps = .{ |
| | 29384 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29385 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29386 | .unused, |
| | 29387 | .unused, |
| | 29388 | .unused, |
| | 29389 | .unused, |
| | 29390 | .unused, |
| | 29391 | .unused, |
| | 29392 | .unused, |
| | 29393 | .unused, |
| | 29394 | .unused, |
| | 29395 | }, |
| | 29396 | .dst_temps = .{ .mem, .none }, |
| | 29397 | .clobbers = .{ .eflags = true }, |
| | 29398 | .each = .{ .once = &.{ |
| | 29399 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29400 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29401 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29402 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29403 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29404 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29405 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29406 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29407 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29408 | .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29409 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29410 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 29411 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29412 | } }, |
| | 29413 | }, .{ |
| | 29414 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29415 | .src_constraints = .{ |
| | 29416 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29417 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29418 | .any, |
| | 29419 | }, |
| | 29420 | .patterns = &.{ |
| | 29421 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29422 | }, |
| | 29423 | .extra_temps = .{ |
| | 29424 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29425 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29426 | .unused, |
| | 29427 | .unused, |
| | 29428 | .unused, |
| | 29429 | .unused, |
| | 29430 | .unused, |
| | 29431 | .unused, |
| | 29432 | .unused, |
| | 29433 | .unused, |
| | 29434 | .unused, |
| | 29435 | }, |
| | 29436 | .dst_temps = .{ .mem, .{ .cc = .c } }, |
| | 29437 | .clobbers = .{ .eflags = true }, |
| | 29438 | .each = .{ .once = &.{ |
| | 29439 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29440 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29441 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29442 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29443 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29444 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29445 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29446 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 29447 | } }, |
| | 29448 | }, .{ |
| | 29449 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29450 | .src_constraints = .{ |
| | 29451 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29452 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29453 | .any, |
| | 29454 | }, |
| | 29455 | .patterns = &.{ |
| | 29456 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29457 | }, |
| | 29458 | .extra_temps = .{ |
| | 29459 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29460 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29461 | .unused, |
| | 29462 | .unused, |
| | 29463 | .unused, |
| | 29464 | .unused, |
| | 29465 | .unused, |
| | 29466 | .unused, |
| | 29467 | .unused, |
| | 29468 | .unused, |
| | 29469 | .unused, |
| | 29470 | }, |
| | 29471 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 29472 | .clobbers = .{ .eflags = true }, |
| | 29473 | .each = .{ .once = &.{ |
| | 29474 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29475 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29476 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29477 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29478 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29479 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29480 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29481 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29482 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29483 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29484 | } }, |
| | 29485 | }, .{ |
| | 29486 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29487 | .src_constraints = .{ |
| | 29488 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29489 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29490 | .any, |
| | 29491 | }, |
| | 29492 | .patterns = &.{ |
| | 29493 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29494 | }, |
| | 29495 | .extra_temps = .{ |
| | 29496 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29497 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29498 | .unused, |
| | 29499 | .unused, |
| | 29500 | .unused, |
| | 29501 | .unused, |
| | 29502 | .unused, |
| | 29503 | .unused, |
| | 29504 | .unused, |
| | 29505 | .unused, |
| | 29506 | .unused, |
| | 29507 | }, |
| | 29508 | .dst_temps = .{ .mem, .{ .cc = .c } }, |
| | 29509 | .clobbers = .{ .eflags = true }, |
| | 29510 | .each = .{ .once = &.{ |
| | 29511 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| | 29512 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29513 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 29514 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 29515 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_src0_size), .tmp1q, ._, ._ }, |
| | 29516 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29517 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29518 | } }, |
| | 29519 | }, .{ |
| | 29520 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29521 | .src_constraints = .{ |
| | 29522 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29523 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29524 | .any, |
| | 29525 | }, |
| | 29526 | .patterns = &.{ |
| | 29527 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29528 | }, |
| | 29529 | .extra_temps = .{ |
| | 29530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29531 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29532 | .unused, |
| | 29533 | .unused, |
| | 29534 | .unused, |
| | 29535 | .unused, |
| | 29536 | .unused, |
| | 29537 | .unused, |
| | 29538 | .unused, |
| | 29539 | .unused, |
| | 29540 | .unused, |
| | 29541 | }, |
| | 29542 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 29543 | .clobbers = .{ .eflags = true }, |
| | 29544 | .each = .{ .once = &.{ |
| | 29545 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29546 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29547 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29548 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29549 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29550 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29551 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29552 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29553 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29554 | .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29555 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| | 29556 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29557 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29558 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 29559 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 29560 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29561 | } }, |
| | 29562 | }, .{ |
| | 29563 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29564 | .src_constraints = .{ |
| | 29565 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29566 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29567 | .any, |
| | 29568 | }, |
| | 29569 | .patterns = &.{ |
| | 29570 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29571 | }, |
| | 29572 | .extra_temps = .{ |
| | 29573 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29574 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29575 | .unused, |
| | 29576 | .unused, |
| | 29577 | .unused, |
| | 29578 | .unused, |
| | 29579 | .unused, |
| | 29580 | .unused, |
| | 29581 | .unused, |
| | 29582 | .unused, |
| | 29583 | .unused, |
| | 29584 | }, |
| | 29585 | .dst_temps = .{ .mem, .none }, |
| | 29586 | .clobbers = .{ .eflags = true }, |
| | 29587 | .each = .{ .once = &.{ |
| | 29588 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29589 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29590 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29591 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29592 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29593 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29594 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29595 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29596 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 29597 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29598 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29599 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 29600 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 29601 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 29602 | } }, |
| | 29603 | }, .{ |
| | 29604 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29605 | .src_constraints = .{ |
| | 29606 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29607 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29608 | .any, |
| | 29609 | }, |
| | 29610 | .patterns = &.{ |
| | 29611 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29612 | }, |
| | 29613 | .extra_temps = .{ |
| | 29614 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29615 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29616 | .unused, |
| | 29617 | .unused, |
| | 29618 | .unused, |
| | 29619 | .unused, |
| | 29620 | .unused, |
| | 29621 | .unused, |
| | 29622 | .unused, |
| | 29623 | .unused, |
| | 29624 | .unused, |
| | 29625 | }, |
| | 29626 | .dst_temps = .{ .mem, .none }, |
| | 29627 | .clobbers = .{ .eflags = true }, |
| | 29628 | .each = .{ .once = &.{ |
| | 29629 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29630 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29631 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29632 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29633 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29634 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29635 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29636 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29637 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29638 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29639 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29640 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 29641 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 29642 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 29643 | } }, |
| | 29644 | }, .{ |
| | 29645 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29646 | .src_constraints = .{ |
| | 29647 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29648 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29649 | .any, |
| | 29650 | }, |
| | 29651 | .patterns = &.{ |
| | 29652 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29653 | }, |
| | 29654 | .extra_temps = .{ |
| | 29655 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29656 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29657 | .unused, |
| | 29658 | .unused, |
| | 29659 | .unused, |
| | 29660 | .unused, |
| | 29661 | .unused, |
| | 29662 | .unused, |
| | 29663 | .unused, |
| | 29664 | .unused, |
| | 29665 | .unused, |
| | 29666 | }, |
| | 29667 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 29668 | .clobbers = .{ .eflags = true }, |
| | 29669 | .each = .{ .once = &.{ |
| | 29670 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29671 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29672 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29673 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29674 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29675 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29676 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29677 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29678 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29679 | .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29680 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| | 29681 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29682 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 29683 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29684 | } }, |
| | 29685 | }, .{ |
| | 29686 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29687 | .src_constraints = .{ |
| | 29688 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29689 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29690 | .any, |
| | 29691 | }, |
| | 29692 | .patterns = &.{ |
| | 29693 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29694 | }, |
| | 29695 | .extra_temps = .{ |
| | 29696 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29697 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29698 | .unused, |
| | 29699 | .unused, |
| | 29700 | .unused, |
| | 29701 | .unused, |
| | 29702 | .unused, |
| | 29703 | .unused, |
| | 29704 | .unused, |
| | 29705 | .unused, |
| | 29706 | .unused, |
| | 29707 | }, |
| | 29708 | .dst_temps = .{ .mem, .none }, |
| | 29709 | .clobbers = .{ .eflags = true }, |
| | 29710 | .each = .{ .once = &.{ |
| | 29711 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29712 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29713 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29714 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29715 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29716 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29717 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29718 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29719 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 29720 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29721 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29722 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 29723 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 29724 | } }, |
| | 29725 | }, .{ |
| | 29726 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29727 | .src_constraints = .{ |
| | 29728 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29729 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29730 | .any, |
| | 29731 | }, |
| | 29732 | .patterns = &.{ |
| | 29733 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29734 | }, |
| | 29735 | .extra_temps = .{ |
| | 29736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29737 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29738 | .unused, |
| | 29739 | .unused, |
| | 29740 | .unused, |
| | 29741 | .unused, |
| | 29742 | .unused, |
| | 29743 | .unused, |
| | 29744 | .unused, |
| | 29745 | .unused, |
| | 29746 | .unused, |
| | 29747 | }, |
| | 29748 | .dst_temps = .{ .mem, .none }, |
| | 29749 | .clobbers = .{ .eflags = true }, |
| | 29750 | .each = .{ .once = &.{ |
| | 29751 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29752 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29753 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29754 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29755 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29756 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29757 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29758 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29759 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29760 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29761 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29762 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 29763 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 29764 | } }, |
| | 29765 | } }) catch |err| switch (err) { |
| | 29766 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| | 29767 | @tagName(air_tag), |
| | 29768 | ty_pl.ty.toType().fmt(pt), |
| | 29769 | ops[0].tracking(cg), |
| | 29770 | ops[1].tracking(cg), |
| | 29771 | }), |
| | 29772 | else => |e| return e, |
| | 29773 | }; |
| | 29774 | try res[0].withOverflow(&res[1], cg); |
| | 29775 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| | 29776 | }, |
| 28872 | .alloc => if (use_old) try cg.airAlloc(inst) else { | 29777 | .alloc => if (use_old) try cg.airAlloc(inst) else { |
| 28873 | const ty = air_datas[@intFromEnum(inst)].ty; | 29778 | const ty = air_datas[@intFromEnum(inst)].ty; |
| 28874 | const slot = try cg.tempInit(ty, .{ .lea_frame = .{ | 29779 | const slot = try cg.tempInit(ty, .{ .lea_frame = .{ |
| ... | @@ -111270,6 +112175,7 @@ const Select = struct { | ... | @@ -111270,6 +112175,7 @@ const Select = struct { |
| 111270 | mut_mem, | 112175 | mut_mem, |
| 111271 | to_mut_mem, | 112176 | to_mut_mem, |
| 111272 | gpr, | 112177 | gpr, |
| | 112178 | immut_gpr, |
| 111273 | to_gpr, | 112179 | to_gpr, |
| 111274 | mut_gpr, | 112180 | mut_gpr, |
| 111275 | to_mut_gpr, | 112181 | to_mut_gpr, |
| ... | @@ -111329,6 +112235,11 @@ const Select = struct { | ... | @@ -111329,6 +112235,11 @@ const Select = struct { |
| 111329 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, | 112235 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| 111330 | else => false, | 112236 | else => false, |
| 111331 | }, | 112237 | }, |
| | 112238 | .immut_gpr => !temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| | 112239 | .register => |reg| reg.class() == .general_purpose, |
| | 112240 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| | 112241 | else => false, |
| | 112242 | }, |
| 111332 | .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { | 112243 | .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| 111333 | .register => |reg| reg.class() == .general_purpose, | 112244 | .register => |reg| reg.class() == .general_purpose, |
| 111334 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, | 112245 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| ... | @@ -111415,7 +112326,7 @@ const Select = struct { | ... | @@ -111415,7 +112326,7 @@ const Select = struct { |
| 111415 | .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*, cg), | 112326 | .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*, cg), |
| 111416 | .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index], cg), | 112327 | .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index], cg), |
| 111417 | .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*, cg), | 112328 | .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*, cg), |
| 111418 | .gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg), | 112329 | .gpr, .immut_gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg), |
| 111419 | .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), | 112330 | .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), |
| 111420 | .x87, .to_x87 => try temp.toRegClass(false, .x87, cg), | 112331 | .x87, .to_x87 => try temp.toRegClass(false, .x87, cg), |
| 111421 | .mut_x87, .to_mut_x87 => try temp.toRegClass(true, .x87, cg), | 112332 | .mut_x87, .to_mut_x87 => try temp.toRegClass(true, .x87, cg), |
Jacob Young <jacobly@ziglang.org> 2025-03-25 07:45:52-04:00
src