| ... | @@ -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(12_900); | 2421 | @setEvalBranchQuota(13_600); |
| 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; |
| ... | @@ -2475,7 +2475,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2475,7 +2475,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2475 | | 2475 | |
| 2476 | .bitcast => try cg.airBitCast(inst), | 2476 | .bitcast => try cg.airBitCast(inst), |
| 2477 | | 2477 | |
| 2478 | .bit_reverse => try cg.airBitReverse(inst), | | |
| 2479 | .splat => try cg.airSplat(inst), | 2478 | .splat => try cg.airSplat(inst), |
| 2480 | .select => try cg.airSelect(inst), | 2479 | .select => try cg.airSelect(inst), |
| 2481 | .shuffle => try cg.airShuffle(inst), | 2480 | .shuffle => try cg.airShuffle(inst), |
| ... | @@ -32018,6 +32017,3142 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -32018,6 +32017,3142 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32018 | }; | 32017 | }; |
| 32019 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 32018 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 32020 | }, | 32019 | }, |
| | 32020 | .bit_reverse => |air_tag| if (use_old) try cg.airBitReverse(inst) else fallback: { |
| | 32021 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| | 32022 | if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airByteSwap(inst); |
| | 32023 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| | 32024 | var res: [1]Temp = undefined; |
| | 32025 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| | 32026 | .src_constraints = .{ .{ .exact_int = 1 }, .any, .any }, |
| | 32027 | .patterns = &.{ |
| | 32028 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 32029 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 32030 | }, |
| | 32031 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32032 | .each = .{ .once = &.{} }, |
| | 32033 | }, .{ |
| | 32034 | .required_features = .{ .avx, .gfni, null, null }, |
| | 32035 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32036 | .patterns = &.{ |
| | 32037 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32038 | }, |
| | 32039 | .extra_temps = .{ |
| | 32040 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32041 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32042 | .unused, |
| | 32043 | .unused, |
| | 32044 | .unused, |
| | 32045 | .unused, |
| | 32046 | .unused, |
| | 32047 | .unused, |
| | 32048 | .unused, |
| | 32049 | .unused, |
| | 32050 | .unused, |
| | 32051 | }, |
| | 32052 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 32053 | .each = .{ .once = &.{ |
| | 32054 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32055 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp1x), .ui(0) }, |
| | 32056 | } }, |
| | 32057 | }, .{ |
| | 32058 | .required_features = .{ .gfni, null, null, null }, |
| | 32059 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32060 | .patterns = &.{ |
| | 32061 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32062 | }, |
| | 32063 | .extra_temps = .{ |
| | 32064 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32065 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32066 | .unused, |
| | 32067 | .unused, |
| | 32068 | .unused, |
| | 32069 | .unused, |
| | 32070 | .unused, |
| | 32071 | .unused, |
| | 32072 | .unused, |
| | 32073 | .unused, |
| | 32074 | .unused, |
| | 32075 | }, |
| | 32076 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32077 | .each = .{ .once = &.{ |
| | 32078 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32079 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 32080 | } }, |
| | 32081 | }, .{ |
| | 32082 | .required_features = .{ .avx2, null, null, null }, |
| | 32083 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32084 | .patterns = &.{ |
| | 32085 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32086 | }, |
| | 32087 | .extra_temps = .{ |
| | 32088 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32089 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32090 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32091 | .unused, |
| | 32092 | .unused, |
| | 32093 | .unused, |
| | 32094 | .unused, |
| | 32095 | .unused, |
| | 32096 | .unused, |
| | 32097 | .unused, |
| | 32098 | .unused, |
| | 32099 | }, |
| | 32100 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32101 | .each = .{ .once = &.{ |
| | 32102 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32103 | .{ ._, .vp_b, .broadcast, .tmp1x, .src0x, ._, ._ }, |
| | 32104 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32105 | .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32106 | .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32107 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ }, |
| | 32108 | } }, |
| | 32109 | }, .{ |
| | 32110 | .required_features = .{ .avx, null, null, null }, |
| | 32111 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32112 | .patterns = &.{ |
| | 32113 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32114 | }, |
| | 32115 | .extra_temps = .{ |
| | 32116 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32117 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32118 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32119 | .unused, |
| | 32120 | .unused, |
| | 32121 | .unused, |
| | 32122 | .unused, |
| | 32123 | .unused, |
| | 32124 | .unused, |
| | 32125 | .unused, |
| | 32126 | .unused, |
| | 32127 | }, |
| | 32128 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32129 | .each = .{ .once = &.{ |
| | 32130 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32131 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 32132 | .{ ._, .vp_b, .shuf, .tmp1x, .src0x, .tmp2x, ._ }, |
| | 32133 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32134 | .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32135 | .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32136 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ }, |
| | 32137 | } }, |
| | 32138 | }, .{ |
| | 32139 | .required_features = .{ .ssse3, null, null, null }, |
| | 32140 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32141 | .patterns = &.{ |
| | 32142 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32143 | }, |
| | 32144 | .extra_temps = .{ |
| | 32145 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32146 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32147 | .unused, |
| | 32148 | .unused, |
| | 32149 | .unused, |
| | 32150 | .unused, |
| | 32151 | .unused, |
| | 32152 | .unused, |
| | 32153 | .unused, |
| | 32154 | .unused, |
| | 32155 | .unused, |
| | 32156 | }, |
| | 32157 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32158 | .each = .{ .once = &.{ |
| | 32159 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32160 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 32161 | .{ ._, .p_b, .shuf, .src0x, .tmp1x, ._, ._ }, |
| | 32162 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ }, |
| | 32163 | .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ }, |
| | 32164 | .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ }, |
| | 32165 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32166 | } }, |
| | 32167 | }, .{ |
| | 32168 | .required_features = .{ .sse2, null, null, null }, |
| | 32169 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32170 | .patterns = &.{ |
| | 32171 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32172 | }, |
| | 32173 | .extra_temps = .{ |
| | 32174 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32175 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32176 | .unused, |
| | 32177 | .unused, |
| | 32178 | .unused, |
| | 32179 | .unused, |
| | 32180 | .unused, |
| | 32181 | .unused, |
| | 32182 | .unused, |
| | 32183 | .unused, |
| | 32184 | .unused, |
| | 32185 | }, |
| | 32186 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32187 | .each = .{ .once = &.{ |
| | 32188 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32189 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 32190 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ }, |
| | 32191 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 32192 | .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ }, |
| | 32193 | .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ }, |
| | 32194 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32195 | } }, |
| | 32196 | }, .{ |
| | 32197 | .src_constraints = .{ .{ .exact_int = 8 }, .any, .any }, |
| | 32198 | .patterns = &.{ |
| | 32199 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 32200 | }, |
| | 32201 | .extra_temps = .{ |
| | 32202 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32203 | .unused, |
| | 32204 | .unused, |
| | 32205 | .unused, |
| | 32206 | .unused, |
| | 32207 | .unused, |
| | 32208 | .unused, |
| | 32209 | .unused, |
| | 32210 | .unused, |
| | 32211 | .unused, |
| | 32212 | .unused, |
| | 32213 | }, |
| | 32214 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32215 | .clobbers = .{ .eflags = true }, |
| | 32216 | .each = .{ .once = &.{ |
| | 32217 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 32218 | .{ ._, ._r, .sh, .src0b, .ui(4), ._, ._ }, |
| | 32219 | .{ ._, ._l, .sh, .tmp0b, .ui(4), ._, ._ }, |
| | 32220 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32221 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32222 | .{ ._, ._r, .sh, .dst0b, .ui(2), ._, ._ }, |
| | 32223 | .{ ._, ._l, .sh, .tmp0b, .ui(2), ._, ._ }, |
| | 32224 | .{ ._, ._, .@"and", .dst0b, .ui(0b00110011), ._, ._ }, |
| | 32225 | .{ ._, ._, .@"and", .tmp0b, .ui(0b11001100), ._, ._ }, |
| | 32226 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32227 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32228 | .{ ._, ._r, .sh, .dst0b, .ui(1), ._, ._ }, |
| | 32229 | .{ ._, ._l, .sh, .tmp0b, .ui(1), ._, ._ }, |
| | 32230 | .{ ._, ._, .@"and", .dst0b, .ui(0b01010101), ._, ._ }, |
| | 32231 | .{ ._, ._, .@"and", .tmp0b, .ui(0b10101010), ._, ._ }, |
| | 32232 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32233 | } }, |
| | 32234 | }, .{ |
| | 32235 | .required_features = .{ .avx, .gfni, null, null }, |
| | 32236 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32237 | .patterns = &.{ |
| | 32238 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32239 | }, |
| | 32240 | .extra_temps = .{ |
| | 32241 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32242 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32243 | .unused, |
| | 32244 | .unused, |
| | 32245 | .unused, |
| | 32246 | .unused, |
| | 32247 | .unused, |
| | 32248 | .unused, |
| | 32249 | .unused, |
| | 32250 | .unused, |
| | 32251 | .unused, |
| | 32252 | }, |
| | 32253 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 32254 | .each = .{ .once = &.{ |
| | 32255 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32256 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp1x), .ui(0) }, |
| | 32257 | .{ ._, .vp_, .unpcklbw, .dst0x, .dst0x, .dst0x, ._ }, |
| | 32258 | .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| | 32259 | } }, |
| | 32260 | }, .{ |
| | 32261 | .required_features = .{ .gfni, null, null, null }, |
| | 32262 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32263 | .patterns = &.{ |
| | 32264 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32265 | }, |
| | 32266 | .extra_temps = .{ |
| | 32267 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32268 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32269 | .unused, |
| | 32270 | .unused, |
| | 32271 | .unused, |
| | 32272 | .unused, |
| | 32273 | .unused, |
| | 32274 | .unused, |
| | 32275 | .unused, |
| | 32276 | .unused, |
| | 32277 | .unused, |
| | 32278 | }, |
| | 32279 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32280 | .each = .{ .once = &.{ |
| | 32281 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32282 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 32283 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 32284 | .{ ._, .p_w, .sra, .src0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 32285 | } }, |
| | 32286 | }, .{ |
| | 32287 | .required_features = .{ .avx2, null, null, null }, |
| | 32288 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32289 | .patterns = &.{ |
| | 32290 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32291 | }, |
| | 32292 | .extra_temps = .{ |
| | 32293 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32294 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32295 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32296 | .unused, |
| | 32297 | .unused, |
| | 32298 | .unused, |
| | 32299 | .unused, |
| | 32300 | .unused, |
| | 32301 | .unused, |
| | 32302 | .unused, |
| | 32303 | .unused, |
| | 32304 | }, |
| | 32305 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32306 | .clobbers = .{ .eflags = true }, |
| | 32307 | .each = .{ .once = &.{ |
| | 32308 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32309 | .{ ._, .vp_b, .broadcast, .tmp1x, .src0x, ._, ._ }, |
| | 32310 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32311 | .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32312 | .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32313 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ }, |
| | 32314 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32315 | } }, |
| | 32316 | }, .{ |
| | 32317 | .required_features = .{ .avx, null, null, null }, |
| | 32318 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32319 | .patterns = &.{ |
| | 32320 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32321 | }, |
| | 32322 | .extra_temps = .{ |
| | 32323 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32324 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32325 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32326 | .unused, |
| | 32327 | .unused, |
| | 32328 | .unused, |
| | 32329 | .unused, |
| | 32330 | .unused, |
| | 32331 | .unused, |
| | 32332 | .unused, |
| | 32333 | .unused, |
| | 32334 | }, |
| | 32335 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32336 | .clobbers = .{ .eflags = true }, |
| | 32337 | .each = .{ .once = &.{ |
| | 32338 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32339 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 32340 | .{ ._, .vp_b, .shuf, .tmp1x, .src0x, .tmp2x, ._ }, |
| | 32341 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32342 | .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32343 | .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32344 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ }, |
| | 32345 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32346 | } }, |
| | 32347 | }, .{ |
| | 32348 | .required_features = .{ .ssse3, null, null, null }, |
| | 32349 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32350 | .patterns = &.{ |
| | 32351 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32352 | }, |
| | 32353 | .extra_temps = .{ |
| | 32354 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32355 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32356 | .unused, |
| | 32357 | .unused, |
| | 32358 | .unused, |
| | 32359 | .unused, |
| | 32360 | .unused, |
| | 32361 | .unused, |
| | 32362 | .unused, |
| | 32363 | .unused, |
| | 32364 | .unused, |
| | 32365 | }, |
| | 32366 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32367 | .clobbers = .{ .eflags = true }, |
| | 32368 | .each = .{ .once = &.{ |
| | 32369 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32370 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 32371 | .{ ._, .p_b, .shuf, .src0x, .tmp1x, ._, ._ }, |
| | 32372 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ }, |
| | 32373 | .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ }, |
| | 32374 | .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ }, |
| | 32375 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32376 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32377 | } }, |
| | 32378 | }, .{ |
| | 32379 | .required_features = .{ .sse2, null, null, null }, |
| | 32380 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32381 | .patterns = &.{ |
| | 32382 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32383 | }, |
| | 32384 | .extra_temps = .{ |
| | 32385 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32386 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32387 | .unused, |
| | 32388 | .unused, |
| | 32389 | .unused, |
| | 32390 | .unused, |
| | 32391 | .unused, |
| | 32392 | .unused, |
| | 32393 | .unused, |
| | 32394 | .unused, |
| | 32395 | .unused, |
| | 32396 | }, |
| | 32397 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32398 | .clobbers = .{ .eflags = true }, |
| | 32399 | .each = .{ .once = &.{ |
| | 32400 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32401 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 32402 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ }, |
| | 32403 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 32404 | .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ }, |
| | 32405 | .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ }, |
| | 32406 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32407 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32408 | } }, |
| | 32409 | }, .{ |
| | 32410 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| | 32411 | .patterns = &.{ |
| | 32412 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 32413 | }, |
| | 32414 | .extra_temps = .{ |
| | 32415 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32416 | .unused, |
| | 32417 | .unused, |
| | 32418 | .unused, |
| | 32419 | .unused, |
| | 32420 | .unused, |
| | 32421 | .unused, |
| | 32422 | .unused, |
| | 32423 | .unused, |
| | 32424 | .unused, |
| | 32425 | .unused, |
| | 32426 | }, |
| | 32427 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32428 | .clobbers = .{ .eflags = true }, |
| | 32429 | .each = .{ .once = &.{ |
| | 32430 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 32431 | .{ ._, ._r, .sh, .src0b, .ui(4), ._, ._ }, |
| | 32432 | .{ ._, ._l, .sh, .tmp0b, .ui(4), ._, ._ }, |
| | 32433 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32434 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32435 | .{ ._, ._r, .sh, .dst0b, .ui(2), ._, ._ }, |
| | 32436 | .{ ._, ._l, .sh, .tmp0b, .ui(2), ._, ._ }, |
| | 32437 | .{ ._, ._, .@"and", .dst0b, .ui(0b00110011), ._, ._ }, |
| | 32438 | .{ ._, ._, .@"and", .tmp0b, .ui(0b11001100), ._, ._ }, |
| | 32439 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32440 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32441 | .{ ._, ._r, .sh, .dst0b, .ui(1), ._, ._ }, |
| | 32442 | .{ ._, ._l, .sh, .tmp0b, .ui(1), ._, ._ }, |
| | 32443 | .{ ._, ._, .@"and", .dst0b, .ui(0b01010101), ._, ._ }, |
| | 32444 | .{ ._, ._, .@"and", .tmp0b, .ui(0b10101010), ._, ._ }, |
| | 32445 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32446 | .{ ._, ._r, .sa, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32447 | } }, |
| | 32448 | }, .{ |
| | 32449 | .required_features = .{ .avx, .gfni, null, null }, |
| | 32450 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32451 | .patterns = &.{ |
| | 32452 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32453 | }, |
| | 32454 | .extra_temps = .{ |
| | 32455 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32456 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32457 | .unused, |
| | 32458 | .unused, |
| | 32459 | .unused, |
| | 32460 | .unused, |
| | 32461 | .unused, |
| | 32462 | .unused, |
| | 32463 | .unused, |
| | 32464 | .unused, |
| | 32465 | .unused, |
| | 32466 | }, |
| | 32467 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 32468 | .each = .{ .once = &.{ |
| | 32469 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32470 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp1x), .ui(0) }, |
| | 32471 | .{ ._, .vp_, .unpcklbw, .dst0x, .dst0x, .dst0x, ._ }, |
| | 32472 | .{ ._, .vp_w, .srl, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| | 32473 | } }, |
| | 32474 | }, .{ |
| | 32475 | .required_features = .{ .gfni, null, null, null }, |
| | 32476 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32477 | .patterns = &.{ |
| | 32478 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32479 | }, |
| | 32480 | .extra_temps = .{ |
| | 32481 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32482 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32483 | .unused, |
| | 32484 | .unused, |
| | 32485 | .unused, |
| | 32486 | .unused, |
| | 32487 | .unused, |
| | 32488 | .unused, |
| | 32489 | .unused, |
| | 32490 | .unused, |
| | 32491 | .unused, |
| | 32492 | }, |
| | 32493 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32494 | .each = .{ .once = &.{ |
| | 32495 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32496 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 32497 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 32498 | .{ ._, .p_w, .srl, .src0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 32499 | } }, |
| | 32500 | }, .{ |
| | 32501 | .required_features = .{ .avx2, null, null, null }, |
| | 32502 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32503 | .patterns = &.{ |
| | 32504 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32505 | }, |
| | 32506 | .extra_temps = .{ |
| | 32507 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32508 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32509 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32510 | .unused, |
| | 32511 | .unused, |
| | 32512 | .unused, |
| | 32513 | .unused, |
| | 32514 | .unused, |
| | 32515 | .unused, |
| | 32516 | .unused, |
| | 32517 | .unused, |
| | 32518 | }, |
| | 32519 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32520 | .clobbers = .{ .eflags = true }, |
| | 32521 | .each = .{ .once = &.{ |
| | 32522 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32523 | .{ ._, .vp_b, .broadcast, .tmp1x, .src0x, ._, ._ }, |
| | 32524 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32525 | .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32526 | .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32527 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ }, |
| | 32528 | .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32529 | } }, |
| | 32530 | }, .{ |
| | 32531 | .required_features = .{ .avx, null, null, null }, |
| | 32532 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32533 | .patterns = &.{ |
| | 32534 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32535 | }, |
| | 32536 | .extra_temps = .{ |
| | 32537 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32538 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32539 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32540 | .unused, |
| | 32541 | .unused, |
| | 32542 | .unused, |
| | 32543 | .unused, |
| | 32544 | .unused, |
| | 32545 | .unused, |
| | 32546 | .unused, |
| | 32547 | .unused, |
| | 32548 | }, |
| | 32549 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32550 | .clobbers = .{ .eflags = true }, |
| | 32551 | .each = .{ .once = &.{ |
| | 32552 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32553 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 32554 | .{ ._, .vp_b, .shuf, .tmp1x, .src0x, .tmp2x, ._ }, |
| | 32555 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32556 | .{ ._, .vp_, .@"and", .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32557 | .{ ._, .vp_b, .cmpeq, .tmp1x, .tmp1x, .tmp2x, ._ }, |
| | 32558 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp1x, ._, ._ }, |
| | 32559 | .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32560 | } }, |
| | 32561 | }, .{ |
| | 32562 | .required_features = .{ .ssse3, null, null, null }, |
| | 32563 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32564 | .patterns = &.{ |
| | 32565 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32566 | }, |
| | 32567 | .extra_temps = .{ |
| | 32568 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32569 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32570 | .unused, |
| | 32571 | .unused, |
| | 32572 | .unused, |
| | 32573 | .unused, |
| | 32574 | .unused, |
| | 32575 | .unused, |
| | 32576 | .unused, |
| | 32577 | .unused, |
| | 32578 | .unused, |
| | 32579 | }, |
| | 32580 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32581 | .clobbers = .{ .eflags = true }, |
| | 32582 | .each = .{ .once = &.{ |
| | 32583 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32584 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 32585 | .{ ._, .p_b, .shuf, .src0x, .tmp1x, ._, ._ }, |
| | 32586 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ }, |
| | 32587 | .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ }, |
| | 32588 | .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ }, |
| | 32589 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32590 | .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32591 | } }, |
| | 32592 | }, .{ |
| | 32593 | .required_features = .{ .sse2, null, null, null }, |
| | 32594 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32595 | .patterns = &.{ |
| | 32596 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32597 | }, |
| | 32598 | .extra_temps = .{ |
| | 32599 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32600 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32601 | .unused, |
| | 32602 | .unused, |
| | 32603 | .unused, |
| | 32604 | .unused, |
| | 32605 | .unused, |
| | 32606 | .unused, |
| | 32607 | .unused, |
| | 32608 | .unused, |
| | 32609 | .unused, |
| | 32610 | }, |
| | 32611 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32612 | .clobbers = .{ .eflags = true }, |
| | 32613 | .each = .{ .once = &.{ |
| | 32614 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32615 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 32616 | .{ ._, ._dqa, .mov, .tmp1x, .lea(.dst0x), ._, ._ }, |
| | 32617 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 32618 | .{ ._, .p_, .@"and", .src0x, .tmp1x, ._, ._ }, |
| | 32619 | .{ ._, .p_b, .cmpeq, .src0x, .tmp1x, ._, ._ }, |
| | 32620 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32621 | .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32622 | } }, |
| | 32623 | }, .{ |
| | 32624 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| | 32625 | .patterns = &.{ |
| | 32626 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 32627 | }, |
| | 32628 | .extra_temps = .{ |
| | 32629 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32630 | .unused, |
| | 32631 | .unused, |
| | 32632 | .unused, |
| | 32633 | .unused, |
| | 32634 | .unused, |
| | 32635 | .unused, |
| | 32636 | .unused, |
| | 32637 | .unused, |
| | 32638 | .unused, |
| | 32639 | .unused, |
| | 32640 | }, |
| | 32641 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32642 | .clobbers = .{ .eflags = true }, |
| | 32643 | .each = .{ .once = &.{ |
| | 32644 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 32645 | .{ ._, ._r, .sh, .src0b, .ui(4), ._, ._ }, |
| | 32646 | .{ ._, ._l, .sh, .tmp0b, .ui(4), ._, ._ }, |
| | 32647 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32648 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32649 | .{ ._, ._r, .sh, .dst0b, .ui(2), ._, ._ }, |
| | 32650 | .{ ._, ._l, .sh, .tmp0b, .ui(2), ._, ._ }, |
| | 32651 | .{ ._, ._, .@"and", .dst0b, .ui(0b00110011), ._, ._ }, |
| | 32652 | .{ ._, ._, .@"and", .tmp0b, .ui(0b11001100), ._, ._ }, |
| | 32653 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32654 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32655 | .{ ._, ._r, .sh, .dst0b, .ui(1), ._, ._ }, |
| | 32656 | .{ ._, ._l, .sh, .tmp0b, .ui(1), ._, ._ }, |
| | 32657 | .{ ._, ._, .@"and", .dst0b, .ui(0b01010101), ._, ._ }, |
| | 32658 | .{ ._, ._, .@"and", .tmp0b, .ui(0b10101010), ._, ._ }, |
| | 32659 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| | 32660 | .{ ._, ._r, .sh, .dst0b, .uia(8, .dst0, .sub_bit_size), ._, ._ }, |
| | 32661 | } }, |
| | 32662 | }, .{ |
| | 32663 | .required_features = .{ .avx, .gfni, null, null }, |
| | 32664 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| | 32665 | .patterns = &.{ |
| | 32666 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32667 | }, |
| | 32668 | .extra_temps = .{ |
| | 32669 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32670 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, |
| | 32671 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32672 | .unused, |
| | 32673 | .unused, |
| | 32674 | .unused, |
| | 32675 | .unused, |
| | 32676 | .unused, |
| | 32677 | .unused, |
| | 32678 | .unused, |
| | 32679 | .unused, |
| | 32680 | }, |
| | 32681 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 32682 | .each = .{ .once = &.{ |
| | 32683 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 32684 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 32685 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 32686 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 32687 | } }, |
| | 32688 | }, .{ |
| | 32689 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 32690 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| | 32691 | .patterns = &.{ |
| | 32692 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32693 | }, |
| | 32694 | .extra_temps = .{ |
| | 32695 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32696 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, |
| | 32697 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32698 | .unused, |
| | 32699 | .unused, |
| | 32700 | .unused, |
| | 32701 | .unused, |
| | 32702 | .unused, |
| | 32703 | .unused, |
| | 32704 | .unused, |
| | 32705 | .unused, |
| | 32706 | }, |
| | 32707 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32708 | .each = .{ .once = &.{ |
| | 32709 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 32710 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 32711 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 32712 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 32713 | } }, |
| | 32714 | }, .{ |
| | 32715 | .required_features = .{ .gfni, null, null, null }, |
| | 32716 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| | 32717 | .patterns = &.{ |
| | 32718 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32719 | }, |
| | 32720 | .extra_temps = .{ |
| | 32721 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32722 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32723 | .unused, |
| | 32724 | .unused, |
| | 32725 | .unused, |
| | 32726 | .unused, |
| | 32727 | .unused, |
| | 32728 | .unused, |
| | 32729 | .unused, |
| | 32730 | .unused, |
| | 32731 | .unused, |
| | 32732 | }, |
| | 32733 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32734 | .each = .{ .once = &.{ |
| | 32735 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32736 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 32737 | .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ }, |
| | 32738 | .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ }, |
| | 32739 | } }, |
| | 32740 | }, .{ |
| | 32741 | .required_features = .{ .avx, null, null, null }, |
| | 32742 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| | 32743 | .patterns = &.{ |
| | 32744 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32745 | }, |
| | 32746 | .extra_temps = .{ |
| | 32747 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, |
| | 32748 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32749 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32750 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32751 | .unused, |
| | 32752 | .unused, |
| | 32753 | .unused, |
| | 32754 | .unused, |
| | 32755 | .unused, |
| | 32756 | .unused, |
| | 32757 | .unused, |
| | 32758 | }, |
| | 32759 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32760 | .each = .{ .once = &.{ |
| | 32761 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32762 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.dst0x), ._ }, |
| | 32763 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 32764 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.dst0x), ._, ._ }, |
| | 32765 | .{ ._, .vp_, .@"and", .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 32766 | .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 32767 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp2x, ._, ._ }, |
| | 32768 | } }, |
| | 32769 | }, .{ |
| | 32770 | .required_features = .{ .ssse3, null, null, null }, |
| | 32771 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| | 32772 | .patterns = &.{ |
| | 32773 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32774 | }, |
| | 32775 | .extra_temps = .{ |
| | 32776 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, |
| | 32777 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32778 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32779 | .unused, |
| | 32780 | .unused, |
| | 32781 | .unused, |
| | 32782 | .unused, |
| | 32783 | .unused, |
| | 32784 | .unused, |
| | 32785 | .unused, |
| | 32786 | .unused, |
| | 32787 | }, |
| | 32788 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32789 | .each = .{ .once = &.{ |
| | 32790 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32791 | .{ ._, .p_b, .shuf, .src0x, .lea(.dst0x), ._, ._ }, |
| | 32792 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 32793 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32794 | .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, |
| | 32795 | .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, |
| | 32796 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32797 | } }, |
| | 32798 | }, .{ |
| | 32799 | .src_constraints = .{ .{ .exact_int = 16 }, .any, .any }, |
| | 32800 | .patterns = &.{ |
| | 32801 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 32802 | }, |
| | 32803 | .extra_temps = .{ |
| | 32804 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 32805 | .unused, |
| | 32806 | .unused, |
| | 32807 | .unused, |
| | 32808 | .unused, |
| | 32809 | .unused, |
| | 32810 | .unused, |
| | 32811 | .unused, |
| | 32812 | .unused, |
| | 32813 | .unused, |
| | 32814 | .unused, |
| | 32815 | }, |
| | 32816 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32817 | .clobbers = .{ .eflags = true }, |
| | 32818 | .each = .{ .once = &.{ |
| | 32819 | .{ ._, ._r, .ro, .src0w, .ui(8), ._, ._ }, |
| | 32820 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 32821 | .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ }, |
| | 32822 | .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ }, |
| | 32823 | .{ ._, ._, .@"and", .src0d, .ui(0b0000111100001111), ._, ._ }, |
| | 32824 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1111000011110000), ._, ._ }, |
| | 32825 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 32826 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32827 | .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ }, |
| | 32828 | .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ }, |
| | 32829 | .{ ._, ._, .@"and", .dst0d, .ui(0b0011001100110011), ._, ._ }, |
| | 32830 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1100110011001100), ._, ._ }, |
| | 32831 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 32832 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 32833 | .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ }, |
| | 32834 | .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ }, |
| | 32835 | .{ ._, ._, .@"and", .dst0d, .ui(0b0101010101010101), ._, ._ }, |
| | 32836 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1010101010101010), ._, ._ }, |
| | 32837 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 32838 | } }, |
| | 32839 | }, .{ |
| | 32840 | .required_features = .{ .avx, .gfni, null, null }, |
| | 32841 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| | 32842 | .patterns = &.{ |
| | 32843 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32844 | }, |
| | 32845 | .extra_temps = .{ |
| | 32846 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32847 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, |
| | 32848 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32849 | .unused, |
| | 32850 | .unused, |
| | 32851 | .unused, |
| | 32852 | .unused, |
| | 32853 | .unused, |
| | 32854 | .unused, |
| | 32855 | .unused, |
| | 32856 | .unused, |
| | 32857 | }, |
| | 32858 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 32859 | .each = .{ .once = &.{ |
| | 32860 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 32861 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 32862 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 32863 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 32864 | .{ ._, .vp_w, .sra, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| | 32865 | } }, |
| | 32866 | }, .{ |
| | 32867 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 32868 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| | 32869 | .patterns = &.{ |
| | 32870 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32871 | }, |
| | 32872 | .extra_temps = .{ |
| | 32873 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32874 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, |
| | 32875 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32876 | .unused, |
| | 32877 | .unused, |
| | 32878 | .unused, |
| | 32879 | .unused, |
| | 32880 | .unused, |
| | 32881 | .unused, |
| | 32882 | .unused, |
| | 32883 | .unused, |
| | 32884 | }, |
| | 32885 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32886 | .each = .{ .once = &.{ |
| | 32887 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 32888 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 32889 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 32890 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 32891 | .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 32892 | } }, |
| | 32893 | }, .{ |
| | 32894 | .required_features = .{ .gfni, null, null, null }, |
| | 32895 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| | 32896 | .patterns = &.{ |
| | 32897 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32898 | }, |
| | 32899 | .extra_temps = .{ |
| | 32900 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 32901 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32902 | .unused, |
| | 32903 | .unused, |
| | 32904 | .unused, |
| | 32905 | .unused, |
| | 32906 | .unused, |
| | 32907 | .unused, |
| | 32908 | .unused, |
| | 32909 | .unused, |
| | 32910 | .unused, |
| | 32911 | }, |
| | 32912 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 32913 | .each = .{ .once = &.{ |
| | 32914 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 32915 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 32916 | .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ }, |
| | 32917 | .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ }, |
| | 32918 | .{ ._, .p_w, .sra, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 32919 | } }, |
| | 32920 | }, .{ |
| | 32921 | .required_features = .{ .avx, null, null, null }, |
| | 32922 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| | 32923 | .patterns = &.{ |
| | 32924 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 32925 | }, |
| | 32926 | .extra_temps = .{ |
| | 32927 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, |
| | 32928 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32929 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 32930 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32931 | .unused, |
| | 32932 | .unused, |
| | 32933 | .unused, |
| | 32934 | .unused, |
| | 32935 | .unused, |
| | 32936 | .unused, |
| | 32937 | .unused, |
| | 32938 | }, |
| | 32939 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32940 | .clobbers = .{ .eflags = true }, |
| | 32941 | .each = .{ .once = &.{ |
| | 32942 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32943 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.dst0x), ._ }, |
| | 32944 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 32945 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.dst0x), ._, ._ }, |
| | 32946 | .{ ._, .vp_, .@"and", .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 32947 | .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 32948 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp2x, ._, ._ }, |
| | 32949 | .{ ._, ._r, .sa, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 32950 | } }, |
| | 32951 | }, .{ |
| | 32952 | .required_features = .{ .ssse3, null, null, null }, |
| | 32953 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| | 32954 | .patterns = &.{ |
| | 32955 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 32956 | }, |
| | 32957 | .extra_temps = .{ |
| | 32958 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, |
| | 32959 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 32960 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 32961 | .unused, |
| | 32962 | .unused, |
| | 32963 | .unused, |
| | 32964 | .unused, |
| | 32965 | .unused, |
| | 32966 | .unused, |
| | 32967 | .unused, |
| | 32968 | .unused, |
| | 32969 | }, |
| | 32970 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 32971 | .clobbers = .{ .eflags = true }, |
| | 32972 | .each = .{ .once = &.{ |
| | 32973 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 32974 | .{ ._, .p_b, .shuf, .src0x, .lea(.dst0x), ._, ._ }, |
| | 32975 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 32976 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 32977 | .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, |
| | 32978 | .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, |
| | 32979 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 32980 | .{ ._, ._r, .sa, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 32981 | } }, |
| | 32982 | }, .{ |
| | 32983 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| | 32984 | .patterns = &.{ |
| | 32985 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 32986 | }, |
| | 32987 | .extra_temps = .{ |
| | 32988 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 32989 | .unused, |
| | 32990 | .unused, |
| | 32991 | .unused, |
| | 32992 | .unused, |
| | 32993 | .unused, |
| | 32994 | .unused, |
| | 32995 | .unused, |
| | 32996 | .unused, |
| | 32997 | .unused, |
| | 32998 | .unused, |
| | 32999 | }, |
| | 33000 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33001 | .clobbers = .{ .eflags = true }, |
| | 33002 | .each = .{ .once = &.{ |
| | 33003 | .{ ._, ._r, .ro, .src0w, .ui(8), ._, ._ }, |
| | 33004 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 33005 | .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ }, |
| | 33006 | .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ }, |
| | 33007 | .{ ._, ._, .@"and", .src0d, .ui(0b0000111100001111), ._, ._ }, |
| | 33008 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1111000011110000), ._, ._ }, |
| | 33009 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33010 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33011 | .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ }, |
| | 33012 | .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ }, |
| | 33013 | .{ ._, ._, .@"and", .dst0d, .ui(0b0011001100110011), ._, ._ }, |
| | 33014 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1100110011001100), ._, ._ }, |
| | 33015 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33016 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33017 | .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ }, |
| | 33018 | .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ }, |
| | 33019 | .{ ._, ._, .@"and", .dst0d, .ui(0b0101010101010101), ._, ._ }, |
| | 33020 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1010101010101010), ._, ._ }, |
| | 33021 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33022 | .{ ._, ._r, .sa, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 33023 | } }, |
| | 33024 | }, .{ |
| | 33025 | .required_features = .{ .avx, .gfni, null, null }, |
| | 33026 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| | 33027 | .patterns = &.{ |
| | 33028 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33029 | }, |
| | 33030 | .extra_temps = .{ |
| | 33031 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33032 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, |
| | 33033 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33034 | .unused, |
| | 33035 | .unused, |
| | 33036 | .unused, |
| | 33037 | .unused, |
| | 33038 | .unused, |
| | 33039 | .unused, |
| | 33040 | .unused, |
| | 33041 | .unused, |
| | 33042 | }, |
| | 33043 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 33044 | .each = .{ .once = &.{ |
| | 33045 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33046 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 33047 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33048 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 33049 | .{ ._, .vp_w, .srl, .dst0x, .dst0x, .uia(16, .dst0, .sub_bit_size), ._ }, |
| | 33050 | } }, |
| | 33051 | }, .{ |
| | 33052 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 33053 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| | 33054 | .patterns = &.{ |
| | 33055 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33056 | }, |
| | 33057 | .extra_temps = .{ |
| | 33058 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33059 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } }, |
| | 33060 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33061 | .unused, |
| | 33062 | .unused, |
| | 33063 | .unused, |
| | 33064 | .unused, |
| | 33065 | .unused, |
| | 33066 | .unused, |
| | 33067 | .unused, |
| | 33068 | .unused, |
| | 33069 | }, |
| | 33070 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33071 | .each = .{ .once = &.{ |
| | 33072 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33073 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 33074 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33075 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 33076 | .{ ._, .p_w, .srl, .dst0x, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 33077 | } }, |
| | 33078 | }, .{ |
| | 33079 | .required_features = .{ .gfni, null, null, null }, |
| | 33080 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| | 33081 | .patterns = &.{ |
| | 33082 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33083 | }, |
| | 33084 | .extra_temps = .{ |
| | 33085 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33086 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33087 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 33088 | .unused, |
| | 33089 | .unused, |
| | 33090 | .unused, |
| | 33091 | .unused, |
| | 33092 | .unused, |
| | 33093 | .unused, |
| | 33094 | .unused, |
| | 33095 | .unused, |
| | 33096 | }, |
| | 33097 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33098 | .each = .{ .once = &.{ |
| | 33099 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 33100 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 33101 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 33102 | .{ ._, .p_w, .srl, .dst0x, .uia(24, .dst0, .sub_bit_size), ._, ._ }, |
| | 33103 | .{ ._, .p_w, .sll, .tmp2x, .sia(-8, .dst0, .add_bit_size), ._, ._ }, |
| | 33104 | .{ ._, .p_, .@"or", .dst0x, .tmp2x, ._, ._ }, |
| | 33105 | } }, |
| | 33106 | }, .{ |
| | 33107 | .required_features = .{ .avx, null, null, null }, |
| | 33108 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| | 33109 | .patterns = &.{ |
| | 33110 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33111 | }, |
| | 33112 | .extra_temps = .{ |
| | 33113 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, |
| | 33114 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 33115 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 33116 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 33117 | .unused, |
| | 33118 | .unused, |
| | 33119 | .unused, |
| | 33120 | .unused, |
| | 33121 | .unused, |
| | 33122 | .unused, |
| | 33123 | .unused, |
| | 33124 | }, |
| | 33125 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33126 | .clobbers = .{ .eflags = true }, |
| | 33127 | .each = .{ .once = &.{ |
| | 33128 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33129 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.dst0x), ._ }, |
| | 33130 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 33131 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.dst0x), ._, ._ }, |
| | 33132 | .{ ._, .vp_, .@"and", .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 33133 | .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 33134 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp2x, ._, ._ }, |
| | 33135 | .{ ._, ._r, .sh, .dst0d, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 33136 | } }, |
| | 33137 | }, .{ |
| | 33138 | .required_features = .{ .ssse3, null, null, null }, |
| | 33139 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| | 33140 | .patterns = &.{ |
| | 33141 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33142 | }, |
| | 33143 | .extra_temps = .{ |
| | 33144 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } }, |
| | 33145 | .{ .type = .vector_16_u8, .kind = .reverse_bits }, |
| | 33146 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 33147 | .unused, |
| | 33148 | .unused, |
| | 33149 | .unused, |
| | 33150 | .unused, |
| | 33151 | .unused, |
| | 33152 | .unused, |
| | 33153 | .unused, |
| | 33154 | .unused, |
| | 33155 | }, |
| | 33156 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33157 | .clobbers = .{ .eflags = true }, |
| | 33158 | .each = .{ .once = &.{ |
| | 33159 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33160 | .{ ._, .p_b, .shuf, .src0x, .lea(.dst0x), ._, ._ }, |
| | 33161 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 33162 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.dst0x), ._, ._ }, |
| | 33163 | .{ ._, .p_, .@"and", .src0x, .tmp2x, ._, ._ }, |
| | 33164 | .{ ._, .p_b, .cmpeq, .src0x, .tmp2x, ._, ._ }, |
| | 33165 | .{ ._, .p_b, .movmsk, .dst0d, .src0x, ._, ._ }, |
| | 33166 | .{ ._, ._r, .sh, .dst0w, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 33167 | } }, |
| | 33168 | }, .{ |
| | 33169 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| | 33170 | .patterns = &.{ |
| | 33171 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33172 | }, |
| | 33173 | .extra_temps = .{ |
| | 33174 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 33175 | .unused, |
| | 33176 | .unused, |
| | 33177 | .unused, |
| | 33178 | .unused, |
| | 33179 | .unused, |
| | 33180 | .unused, |
| | 33181 | .unused, |
| | 33182 | .unused, |
| | 33183 | .unused, |
| | 33184 | .unused, |
| | 33185 | }, |
| | 33186 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33187 | .clobbers = .{ .eflags = true }, |
| | 33188 | .each = .{ .once = &.{ |
| | 33189 | .{ ._, ._r, .ro, .src0w, .ui(8), ._, ._ }, |
| | 33190 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 33191 | .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ }, |
| | 33192 | .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ }, |
| | 33193 | .{ ._, ._, .@"and", .src0d, .ui(0b0000111100001111), ._, ._ }, |
| | 33194 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1111000011110000), ._, ._ }, |
| | 33195 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33196 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33197 | .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ }, |
| | 33198 | .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ }, |
| | 33199 | .{ ._, ._, .@"and", .dst0d, .ui(0b0011001100110011), ._, ._ }, |
| | 33200 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1100110011001100), ._, ._ }, |
| | 33201 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33202 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33203 | .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ }, |
| | 33204 | .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ }, |
| | 33205 | .{ ._, ._, .@"and", .dst0d, .ui(0b0101010101010101), ._, ._ }, |
| | 33206 | .{ ._, ._, .@"and", .tmp0d, .ui(0b1010101010101010), ._, ._ }, |
| | 33207 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33208 | .{ ._, ._r, .sh, .dst0d, .uia(16, .dst0, .sub_bit_size), ._, ._ }, |
| | 33209 | } }, |
| | 33210 | }, .{ |
| | 33211 | .required_features = .{ .avx, .gfni, null, null }, |
| | 33212 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| | 33213 | .patterns = &.{ |
| | 33214 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33215 | }, |
| | 33216 | .extra_temps = .{ |
| | 33217 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33218 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, |
| | 33219 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33220 | .unused, |
| | 33221 | .unused, |
| | 33222 | .unused, |
| | 33223 | .unused, |
| | 33224 | .unused, |
| | 33225 | .unused, |
| | 33226 | .unused, |
| | 33227 | .unused, |
| | 33228 | }, |
| | 33229 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 33230 | .each = .{ .once = &.{ |
| | 33231 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33232 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 33233 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33234 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 33235 | } }, |
| | 33236 | }, .{ |
| | 33237 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 33238 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| | 33239 | .patterns = &.{ |
| | 33240 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33241 | }, |
| | 33242 | .extra_temps = .{ |
| | 33243 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33244 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, |
| | 33245 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33246 | .unused, |
| | 33247 | .unused, |
| | 33248 | .unused, |
| | 33249 | .unused, |
| | 33250 | .unused, |
| | 33251 | .unused, |
| | 33252 | .unused, |
| | 33253 | .unused, |
| | 33254 | }, |
| | 33255 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33256 | .each = .{ .once = &.{ |
| | 33257 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33258 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 33259 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33260 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 33261 | } }, |
| | 33262 | }, .{ |
| | 33263 | .required_features = .{ .gfni, null, null, null }, |
| | 33264 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| | 33265 | .patterns = &.{ |
| | 33266 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33267 | }, |
| | 33268 | .extra_temps = .{ |
| | 33269 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33270 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33271 | .unused, |
| | 33272 | .unused, |
| | 33273 | .unused, |
| | 33274 | .unused, |
| | 33275 | .unused, |
| | 33276 | .unused, |
| | 33277 | .unused, |
| | 33278 | .unused, |
| | 33279 | .unused, |
| | 33280 | }, |
| | 33281 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33282 | .each = .{ .once = &.{ |
| | 33283 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 33284 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 33285 | .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ }, |
| | 33286 | .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ }, |
| | 33287 | .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b00_10_00_10), ._ }, |
| | 33288 | } }, |
| | 33289 | }, .{ |
| | 33290 | .required_features = .{ .avx2, null, null, null }, |
| | 33291 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| | 33292 | .patterns = &.{ |
| | 33293 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33294 | }, |
| | 33295 | .extra_temps = .{ |
| | 33296 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } }, |
| | 33297 | .{ .type = .vector_32_u8, .kind = .reverse_bits }, |
| | 33298 | .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 33299 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 33300 | .unused, |
| | 33301 | .unused, |
| | 33302 | .unused, |
| | 33303 | .unused, |
| | 33304 | .unused, |
| | 33305 | .unused, |
| | 33306 | .unused, |
| | 33307 | }, |
| | 33308 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33309 | .each = .{ .once = &.{ |
| | 33310 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33311 | .{ ._, .vp_d, .broadcast, .tmp2y, .src0x, ._, ._ }, |
| | 33312 | .{ ._, .vp_b, .shuf, .tmp2y, .tmp2y, .lea(.dst0y), ._ }, |
| | 33313 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 33314 | .{ ._, .v_dqa, .mov, .tmp3y, .lea(.dst0y), ._, ._ }, |
| | 33315 | .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 33316 | .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 33317 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp2y, ._, ._ }, |
| | 33318 | } }, |
| | 33319 | }, .{ |
| | 33320 | .src_constraints = .{ .{ .exact_int = 32 }, .any, .any }, |
| | 33321 | .patterns = &.{ |
| | 33322 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33323 | }, |
| | 33324 | .extra_temps = .{ |
| | 33325 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 33326 | .unused, |
| | 33327 | .unused, |
| | 33328 | .unused, |
| | 33329 | .unused, |
| | 33330 | .unused, |
| | 33331 | .unused, |
| | 33332 | .unused, |
| | 33333 | .unused, |
| | 33334 | .unused, |
| | 33335 | .unused, |
| | 33336 | }, |
| | 33337 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33338 | .clobbers = .{ .eflags = true }, |
| | 33339 | .each = .{ .once = &.{ |
| | 33340 | .{ ._, ._, .bswap, .src0d, ._, ._, ._ }, |
| | 33341 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 33342 | .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ }, |
| | 33343 | .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ }, |
| | 33344 | .{ ._, ._, .@"and", .src0d, .ui(0b00001111000011110000111100001111), ._, ._ }, |
| | 33345 | .{ ._, ._, .@"and", .tmp0d, .ui(0b11110000111100001111000011110000), ._, ._ }, |
| | 33346 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33347 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33348 | .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ }, |
| | 33349 | .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ }, |
| | 33350 | .{ ._, ._, .@"and", .dst0d, .ui(0b00110011001100110011001100110011), ._, ._ }, |
| | 33351 | .{ ._, ._, .@"and", .tmp0d, .ui(0b11001100110011001100110011001100), ._, ._ }, |
| | 33352 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33353 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33354 | .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ }, |
| | 33355 | .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ }, |
| | 33356 | .{ ._, ._, .@"and", .dst0d, .ui(0b01010101010101010101010101010101), ._, ._ }, |
| | 33357 | .{ ._, ._, .@"and", .tmp0d, .ui(0b10101010101010101010101010101010), ._, ._ }, |
| | 33358 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33359 | } }, |
| | 33360 | }, .{ |
| | 33361 | .required_features = .{ .avx, .gfni, null, null }, |
| | 33362 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| | 33363 | .patterns = &.{ |
| | 33364 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33365 | }, |
| | 33366 | .extra_temps = .{ |
| | 33367 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33368 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, |
| | 33369 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33370 | .unused, |
| | 33371 | .unused, |
| | 33372 | .unused, |
| | 33373 | .unused, |
| | 33374 | .unused, |
| | 33375 | .unused, |
| | 33376 | .unused, |
| | 33377 | .unused, |
| | 33378 | }, |
| | 33379 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 33380 | .each = .{ .once = &.{ |
| | 33381 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33382 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 33383 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33384 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 33385 | .{ ._, .vp_d, .sra, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| | 33386 | } }, |
| | 33387 | }, .{ |
| | 33388 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 33389 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| | 33390 | .patterns = &.{ |
| | 33391 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33392 | }, |
| | 33393 | .extra_temps = .{ |
| | 33394 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33395 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, |
| | 33396 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33397 | .unused, |
| | 33398 | .unused, |
| | 33399 | .unused, |
| | 33400 | .unused, |
| | 33401 | .unused, |
| | 33402 | .unused, |
| | 33403 | .unused, |
| | 33404 | .unused, |
| | 33405 | }, |
| | 33406 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33407 | .each = .{ .once = &.{ |
| | 33408 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33409 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 33410 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33411 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 33412 | .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33413 | } }, |
| | 33414 | }, .{ |
| | 33415 | .required_features = .{ .gfni, null, null, null }, |
| | 33416 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| | 33417 | .patterns = &.{ |
| | 33418 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33419 | }, |
| | 33420 | .extra_temps = .{ |
| | 33421 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33422 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33423 | .unused, |
| | 33424 | .unused, |
| | 33425 | .unused, |
| | 33426 | .unused, |
| | 33427 | .unused, |
| | 33428 | .unused, |
| | 33429 | .unused, |
| | 33430 | .unused, |
| | 33431 | .unused, |
| | 33432 | }, |
| | 33433 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33434 | .each = .{ .once = &.{ |
| | 33435 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 33436 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 33437 | .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ }, |
| | 33438 | .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ }, |
| | 33439 | .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b00_10_00_10), ._ }, |
| | 33440 | .{ ._, .p_d, .sra, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33441 | } }, |
| | 33442 | }, .{ |
| | 33443 | .required_features = .{ .avx2, null, null, null }, |
| | 33444 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| | 33445 | .patterns = &.{ |
| | 33446 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33447 | }, |
| | 33448 | .extra_temps = .{ |
| | 33449 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } }, |
| | 33450 | .{ .type = .vector_32_u8, .kind = .reverse_bits }, |
| | 33451 | .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 33452 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 33453 | .unused, |
| | 33454 | .unused, |
| | 33455 | .unused, |
| | 33456 | .unused, |
| | 33457 | .unused, |
| | 33458 | .unused, |
| | 33459 | .unused, |
| | 33460 | }, |
| | 33461 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33462 | .clobbers = .{ .eflags = true }, |
| | 33463 | .each = .{ .once = &.{ |
| | 33464 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33465 | .{ ._, .vp_d, .broadcast, .tmp2y, .src0x, ._, ._ }, |
| | 33466 | .{ ._, .vp_b, .shuf, .tmp2y, .tmp2y, .lea(.dst0y), ._ }, |
| | 33467 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 33468 | .{ ._, .v_dqa, .mov, .tmp3y, .lea(.dst0y), ._, ._ }, |
| | 33469 | .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 33470 | .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 33471 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp2y, ._, ._ }, |
| | 33472 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33473 | } }, |
| | 33474 | }, .{ |
| | 33475 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| | 33476 | .patterns = &.{ |
| | 33477 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33478 | }, |
| | 33479 | .extra_temps = .{ |
| | 33480 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 33481 | .unused, |
| | 33482 | .unused, |
| | 33483 | .unused, |
| | 33484 | .unused, |
| | 33485 | .unused, |
| | 33486 | .unused, |
| | 33487 | .unused, |
| | 33488 | .unused, |
| | 33489 | .unused, |
| | 33490 | .unused, |
| | 33491 | }, |
| | 33492 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33493 | .clobbers = .{ .eflags = true }, |
| | 33494 | .each = .{ .once = &.{ |
| | 33495 | .{ ._, ._, .bswap, .src0d, ._, ._, ._ }, |
| | 33496 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 33497 | .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ }, |
| | 33498 | .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ }, |
| | 33499 | .{ ._, ._, .@"and", .src0d, .ui(0b00001111000011110000111100001111), ._, ._ }, |
| | 33500 | .{ ._, ._, .@"and", .tmp0d, .ui(0b11110000111100001111000011110000), ._, ._ }, |
| | 33501 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33502 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33503 | .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ }, |
| | 33504 | .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ }, |
| | 33505 | .{ ._, ._, .@"and", .dst0d, .ui(0b00110011001100110011001100110011), ._, ._ }, |
| | 33506 | .{ ._, ._, .@"and", .tmp0d, .ui(0b11001100110011001100110011001100), ._, ._ }, |
| | 33507 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33508 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33509 | .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ }, |
| | 33510 | .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ }, |
| | 33511 | .{ ._, ._, .@"and", .dst0d, .ui(0b01010101010101010101010101010101), ._, ._ }, |
| | 33512 | .{ ._, ._, .@"and", .tmp0d, .ui(0b10101010101010101010101010101010), ._, ._ }, |
| | 33513 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33514 | .{ ._, ._r, .sa, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33515 | } }, |
| | 33516 | }, .{ |
| | 33517 | .required_features = .{ .avx, .gfni, null, null }, |
| | 33518 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| | 33519 | .patterns = &.{ |
| | 33520 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33521 | }, |
| | 33522 | .extra_temps = .{ |
| | 33523 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33524 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, |
| | 33525 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33526 | .unused, |
| | 33527 | .unused, |
| | 33528 | .unused, |
| | 33529 | .unused, |
| | 33530 | .unused, |
| | 33531 | .unused, |
| | 33532 | .unused, |
| | 33533 | .unused, |
| | 33534 | }, |
| | 33535 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 33536 | .each = .{ .once = &.{ |
| | 33537 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33538 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 33539 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33540 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 33541 | .{ ._, .vp_d, .srl, .dst0x, .dst0x, .uia(32, .dst0, .sub_bit_size), ._ }, |
| | 33542 | } }, |
| | 33543 | }, .{ |
| | 33544 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 33545 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| | 33546 | .patterns = &.{ |
| | 33547 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33548 | }, |
| | 33549 | .extra_temps = .{ |
| | 33550 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33551 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } }, |
| | 33552 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33553 | .unused, |
| | 33554 | .unused, |
| | 33555 | .unused, |
| | 33556 | .unused, |
| | 33557 | .unused, |
| | 33558 | .unused, |
| | 33559 | .unused, |
| | 33560 | .unused, |
| | 33561 | }, |
| | 33562 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33563 | .each = .{ .once = &.{ |
| | 33564 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33565 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 33566 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33567 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 33568 | .{ ._, .p_d, .srl, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33569 | } }, |
| | 33570 | }, .{ |
| | 33571 | .required_features = .{ .gfni, null, null, null }, |
| | 33572 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| | 33573 | .patterns = &.{ |
| | 33574 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33575 | }, |
| | 33576 | .extra_temps = .{ |
| | 33577 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33578 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33579 | .unused, |
| | 33580 | .unused, |
| | 33581 | .unused, |
| | 33582 | .unused, |
| | 33583 | .unused, |
| | 33584 | .unused, |
| | 33585 | .unused, |
| | 33586 | .unused, |
| | 33587 | .unused, |
| | 33588 | }, |
| | 33589 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33590 | .each = .{ .once = &.{ |
| | 33591 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ }, |
| | 33592 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp1x), .ui(0), ._ }, |
| | 33593 | .{ ._, .p_, .unpcklwd, .dst0x, .dst0x, ._, ._ }, |
| | 33594 | .{ ._, .p_dq, .srl, .dst0x, .ui(1), ._, ._ }, |
| | 33595 | .{ ._, .p_w, .shufl, .dst0x, .dst0x, .ui(0b00_10_00_10), ._ }, |
| | 33596 | .{ ._, .p_d, .srl, .dst0x, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33597 | } }, |
| | 33598 | }, .{ |
| | 33599 | .required_features = .{ .avx2, null, null, null }, |
| | 33600 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| | 33601 | .patterns = &.{ |
| | 33602 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33603 | }, |
| | 33604 | .extra_temps = .{ |
| | 33605 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } }, |
| | 33606 | .{ .type = .vector_32_u8, .kind = .reverse_bits }, |
| | 33607 | .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 33608 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 33609 | .unused, |
| | 33610 | .unused, |
| | 33611 | .unused, |
| | 33612 | .unused, |
| | 33613 | .unused, |
| | 33614 | .unused, |
| | 33615 | .unused, |
| | 33616 | }, |
| | 33617 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33618 | .clobbers = .{ .eflags = true }, |
| | 33619 | .each = .{ .once = &.{ |
| | 33620 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33621 | .{ ._, .vp_d, .broadcast, .tmp2y, .src0x, ._, ._ }, |
| | 33622 | .{ ._, .vp_b, .shuf, .tmp2y, .tmp2y, .lea(.dst0y), ._ }, |
| | 33623 | .{ ._, ._, .lea, .dst0p, .mem(.tmp1), ._, ._ }, |
| | 33624 | .{ ._, .v_dqa, .mov, .tmp3y, .lea(.dst0y), ._, ._ }, |
| | 33625 | .{ ._, .vp_, .@"and", .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 33626 | .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 33627 | .{ ._, .vp_b, .movmsk, .dst0d, .tmp2y, ._, ._ }, |
| | 33628 | .{ ._, ._r, .sh, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33629 | } }, |
| | 33630 | }, .{ |
| | 33631 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| | 33632 | .patterns = &.{ |
| | 33633 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33634 | }, |
| | 33635 | .extra_temps = .{ |
| | 33636 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 33637 | .unused, |
| | 33638 | .unused, |
| | 33639 | .unused, |
| | 33640 | .unused, |
| | 33641 | .unused, |
| | 33642 | .unused, |
| | 33643 | .unused, |
| | 33644 | .unused, |
| | 33645 | .unused, |
| | 33646 | .unused, |
| | 33647 | }, |
| | 33648 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33649 | .clobbers = .{ .eflags = true }, |
| | 33650 | .each = .{ .once = &.{ |
| | 33651 | .{ ._, ._, .bswap, .src0d, ._, ._, ._ }, |
| | 33652 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 33653 | .{ ._, ._r, .sh, .src0d, .ui(4), ._, ._ }, |
| | 33654 | .{ ._, ._l, .sh, .tmp0d, .ui(4), ._, ._ }, |
| | 33655 | .{ ._, ._, .@"and", .src0d, .ui(0b00001111000011110000111100001111), ._, ._ }, |
| | 33656 | .{ ._, ._, .@"and", .tmp0d, .ui(0b11110000111100001111000011110000), ._, ._ }, |
| | 33657 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33658 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33659 | .{ ._, ._r, .sh, .dst0d, .ui(2), ._, ._ }, |
| | 33660 | .{ ._, ._l, .sh, .tmp0d, .ui(2), ._, ._ }, |
| | 33661 | .{ ._, ._, .@"and", .dst0d, .ui(0b00110011001100110011001100110011), ._, ._ }, |
| | 33662 | .{ ._, ._, .@"and", .tmp0d, .ui(0b11001100110011001100110011001100), ._, ._ }, |
| | 33663 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33664 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 33665 | .{ ._, ._r, .sh, .dst0d, .ui(1), ._, ._ }, |
| | 33666 | .{ ._, ._l, .sh, .tmp0d, .ui(1), ._, ._ }, |
| | 33667 | .{ ._, ._, .@"and", .dst0d, .ui(0b01010101010101010101010101010101), ._, ._ }, |
| | 33668 | .{ ._, ._, .@"and", .tmp0d, .ui(0b10101010101010101010101010101010), ._, ._ }, |
| | 33669 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| | 33670 | .{ ._, ._r, .sh, .dst0d, .uia(32, .dst0, .sub_bit_size), ._, ._ }, |
| | 33671 | } }, |
| | 33672 | }, .{ |
| | 33673 | .required_features = .{ .avx, .gfni, null, null }, |
| | 33674 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| | 33675 | .patterns = &.{ |
| | 33676 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33677 | }, |
| | 33678 | .extra_temps = .{ |
| | 33679 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33680 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, |
| | 33681 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33682 | .unused, |
| | 33683 | .unused, |
| | 33684 | .unused, |
| | 33685 | .unused, |
| | 33686 | .unused, |
| | 33687 | .unused, |
| | 33688 | .unused, |
| | 33689 | .unused, |
| | 33690 | }, |
| | 33691 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 33692 | .each = .{ .once = &.{ |
| | 33693 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33694 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 33695 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33696 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 33697 | } }, |
| | 33698 | }, .{ |
| | 33699 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 33700 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| | 33701 | .patterns = &.{ |
| | 33702 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33703 | }, |
| | 33704 | .extra_temps = .{ |
| | 33705 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33706 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, |
| | 33707 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33708 | .unused, |
| | 33709 | .unused, |
| | 33710 | .unused, |
| | 33711 | .unused, |
| | 33712 | .unused, |
| | 33713 | .unused, |
| | 33714 | .unused, |
| | 33715 | .unused, |
| | 33716 | }, |
| | 33717 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33718 | .each = .{ .once = &.{ |
| | 33719 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33720 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 33721 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33722 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 33723 | } }, |
| | 33724 | }, .{ |
| | 33725 | .required_features = .{ .@"64bit", .gfni, null, null }, |
| | 33726 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| | 33727 | .patterns = &.{ |
| | 33728 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33729 | }, |
| | 33730 | .extra_temps = .{ |
| | 33731 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33732 | .unused, |
| | 33733 | .unused, |
| | 33734 | .unused, |
| | 33735 | .unused, |
| | 33736 | .unused, |
| | 33737 | .unused, |
| | 33738 | .unused, |
| | 33739 | .unused, |
| | 33740 | .unused, |
| | 33741 | .unused, |
| | 33742 | }, |
| | 33743 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33744 | .each = .{ .once = &.{ |
| | 33745 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33746 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.dst0x), .ui(0), ._ }, |
| | 33747 | .{ ._, ._q, .mov, .dst0q, .src0x, ._, ._ }, |
| | 33748 | .{ ._, ._, .bswap, .dst0q, ._, ._, ._ }, |
| | 33749 | } }, |
| | 33750 | }, .{ |
| | 33751 | .required_features = .{ .@"64bit", null, null, null }, |
| | 33752 | .src_constraints = .{ .{ .exact_int = 64 }, .any, .any }, |
| | 33753 | .patterns = &.{ |
| | 33754 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33755 | }, |
| | 33756 | .extra_temps = .{ |
| | 33757 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33758 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33759 | .unused, |
| | 33760 | .unused, |
| | 33761 | .unused, |
| | 33762 | .unused, |
| | 33763 | .unused, |
| | 33764 | .unused, |
| | 33765 | .unused, |
| | 33766 | .unused, |
| | 33767 | .unused, |
| | 33768 | }, |
| | 33769 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33770 | .clobbers = .{ .eflags = true }, |
| | 33771 | .each = .{ .once = &.{ |
| | 33772 | .{ ._, ._, .bswap, .src0q, ._, ._, ._ }, |
| | 33773 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| | 33774 | .{ ._, ._, .mov, .tmp1q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 33775 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33776 | .{ ._, ._r, .sh, .src0q, .ui(4), ._, ._ }, |
| | 33777 | .{ ._, ._l, .sh, .tmp0q, .ui(4), ._, ._ }, |
| | 33778 | .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ }, |
| | 33779 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 33780 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 33781 | .{ ._, ._, .mov, .tmp1q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 33782 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33783 | .{ ._, ._r, .sh, .dst0q, .ui(2), ._, ._ }, |
| | 33784 | .{ ._, ._l, .sh, .tmp0q, .ui(2), ._, ._ }, |
| | 33785 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| | 33786 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 33787 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 33788 | .{ ._, ._, .mov, .tmp1q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 33789 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33790 | .{ ._, ._r, .sh, .dst0q, .ui(1), ._, ._ }, |
| | 33791 | .{ ._, ._l, .sh, .tmp0q, .ui(1), ._, ._ }, |
| | 33792 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| | 33793 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 33794 | } }, |
| | 33795 | }, .{ |
| | 33796 | .required_features = .{ .@"64bit", .avx, .gfni, null }, |
| | 33797 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| | 33798 | .patterns = &.{ |
| | 33799 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33800 | }, |
| | 33801 | .extra_temps = .{ |
| | 33802 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33803 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 33804 | .unused, |
| | 33805 | .unused, |
| | 33806 | .unused, |
| | 33807 | .unused, |
| | 33808 | .unused, |
| | 33809 | .unused, |
| | 33810 | .unused, |
| | 33811 | .unused, |
| | 33812 | .unused, |
| | 33813 | }, |
| | 33814 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33815 | .clobbers = .{ .eflags = true }, |
| | 33816 | .each = .{ .once = &.{ |
| | 33817 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33818 | .{ ._, .v_b, .gf2p8affineq, .tmp1x, .src0x, .lea(.dst0x), .ui(0) }, |
| | 33819 | .{ ._, .v_q, .mov, .dst0q, .tmp1x, ._, ._ }, |
| | 33820 | .{ ._, ._, .bswap, .dst0q, ._, ._, ._ }, |
| | 33821 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| | 33822 | } }, |
| | 33823 | }, .{ |
| | 33824 | .required_features = .{ .@"64bit", .gfni, null, null }, |
| | 33825 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| | 33826 | .patterns = &.{ |
| | 33827 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33828 | }, |
| | 33829 | .extra_temps = .{ |
| | 33830 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33831 | .unused, |
| | 33832 | .unused, |
| | 33833 | .unused, |
| | 33834 | .unused, |
| | 33835 | .unused, |
| | 33836 | .unused, |
| | 33837 | .unused, |
| | 33838 | .unused, |
| | 33839 | .unused, |
| | 33840 | .unused, |
| | 33841 | }, |
| | 33842 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33843 | .clobbers = .{ .eflags = true }, |
| | 33844 | .each = .{ .once = &.{ |
| | 33845 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33846 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.dst0x), .ui(0), ._ }, |
| | 33847 | .{ ._, ._q, .mov, .dst0q, .src0x, ._, ._ }, |
| | 33848 | .{ ._, ._, .bswap, .dst0q, ._, ._, ._ }, |
| | 33849 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| | 33850 | } }, |
| | 33851 | }, .{ |
| | 33852 | .required_features = .{ .@"64bit", null, null, null }, |
| | 33853 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| | 33854 | .patterns = &.{ |
| | 33855 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33856 | }, |
| | 33857 | .extra_temps = .{ |
| | 33858 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33859 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33860 | .unused, |
| | 33861 | .unused, |
| | 33862 | .unused, |
| | 33863 | .unused, |
| | 33864 | .unused, |
| | 33865 | .unused, |
| | 33866 | .unused, |
| | 33867 | .unused, |
| | 33868 | .unused, |
| | 33869 | }, |
| | 33870 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33871 | .clobbers = .{ .eflags = true }, |
| | 33872 | .each = .{ .once = &.{ |
| | 33873 | .{ ._, ._, .bswap, .src0q, ._, ._, ._ }, |
| | 33874 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| | 33875 | .{ ._, ._, .mov, .tmp1q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 33876 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33877 | .{ ._, ._r, .sh, .src0q, .ui(4), ._, ._ }, |
| | 33878 | .{ ._, ._l, .sh, .tmp0q, .ui(4), ._, ._ }, |
| | 33879 | .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ }, |
| | 33880 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 33881 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 33882 | .{ ._, ._, .mov, .tmp1q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 33883 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33884 | .{ ._, ._r, .sh, .dst0q, .ui(2), ._, ._ }, |
| | 33885 | .{ ._, ._l, .sh, .tmp0q, .ui(2), ._, ._ }, |
| | 33886 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| | 33887 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 33888 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 33889 | .{ ._, ._, .mov, .tmp1q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 33890 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33891 | .{ ._, ._r, .sh, .dst0q, .ui(1), ._, ._ }, |
| | 33892 | .{ ._, ._l, .sh, .tmp0q, .ui(1), ._, ._ }, |
| | 33893 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| | 33894 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 33895 | .{ ._, ._r, .sa, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| | 33896 | } }, |
| | 33897 | }, .{ |
| | 33898 | .required_features = .{ .avx, .gfni, null, null }, |
| | 33899 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| | 33900 | .patterns = &.{ |
| | 33901 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 33902 | }, |
| | 33903 | .extra_temps = .{ |
| | 33904 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33905 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, |
| | 33906 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33907 | .unused, |
| | 33908 | .unused, |
| | 33909 | .unused, |
| | 33910 | .unused, |
| | 33911 | .unused, |
| | 33912 | .unused, |
| | 33913 | .unused, |
| | 33914 | .unused, |
| | 33915 | }, |
| | 33916 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 33917 | .each = .{ .once = &.{ |
| | 33918 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33919 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 33920 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33921 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 33922 | .{ ._, .vp_q, .srl, .dst0x, .dst0x, .uia(64, .dst0, .sub_bit_size), ._ }, |
| | 33923 | } }, |
| | 33924 | }, .{ |
| | 33925 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 33926 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| | 33927 | .patterns = &.{ |
| | 33928 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33929 | }, |
| | 33930 | .extra_temps = .{ |
| | 33931 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33932 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } }, |
| | 33933 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33934 | .unused, |
| | 33935 | .unused, |
| | 33936 | .unused, |
| | 33937 | .unused, |
| | 33938 | .unused, |
| | 33939 | .unused, |
| | 33940 | .unused, |
| | 33941 | .unused, |
| | 33942 | }, |
| | 33943 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33944 | .each = .{ .once = &.{ |
| | 33945 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 33946 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 33947 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 33948 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 33949 | .{ ._, .p_q, .srl, .dst0x, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| | 33950 | } }, |
| | 33951 | }, .{ |
| | 33952 | .required_features = .{ .@"64bit", .gfni, null, null }, |
| | 33953 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| | 33954 | .patterns = &.{ |
| | 33955 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 33956 | }, |
| | 33957 | .extra_temps = .{ |
| | 33958 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 33959 | .unused, |
| | 33960 | .unused, |
| | 33961 | .unused, |
| | 33962 | .unused, |
| | 33963 | .unused, |
| | 33964 | .unused, |
| | 33965 | .unused, |
| | 33966 | .unused, |
| | 33967 | .unused, |
| | 33968 | .unused, |
| | 33969 | }, |
| | 33970 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 33971 | .clobbers = .{ .eflags = true }, |
| | 33972 | .each = .{ .once = &.{ |
| | 33973 | .{ ._, ._, .lea, .dst0p, .mem(.tmp0), ._, ._ }, |
| | 33974 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.dst0x), .ui(0), ._ }, |
| | 33975 | .{ ._, ._q, .mov, .dst0q, .src0x, ._, ._ }, |
| | 33976 | .{ ._, ._, .bswap, .dst0q, ._, ._, ._ }, |
| | 33977 | .{ ._, ._r, .sh, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| | 33978 | } }, |
| | 33979 | }, .{ |
| | 33980 | .required_features = .{ .@"64bit", null, null, null }, |
| | 33981 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| | 33982 | .patterns = &.{ |
| | 33983 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 33984 | }, |
| | 33985 | .extra_temps = .{ |
| | 33986 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33987 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33988 | .unused, |
| | 33989 | .unused, |
| | 33990 | .unused, |
| | 33991 | .unused, |
| | 33992 | .unused, |
| | 33993 | .unused, |
| | 33994 | .unused, |
| | 33995 | .unused, |
| | 33996 | .unused, |
| | 33997 | }, |
| | 33998 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 33999 | .clobbers = .{ .eflags = true }, |
| | 34000 | .each = .{ .once = &.{ |
| | 34001 | .{ ._, ._, .bswap, .src0q, ._, ._, ._ }, |
| | 34002 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| | 34003 | .{ ._, ._, .mov, .tmp1q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34004 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 34005 | .{ ._, ._r, .sh, .src0q, .ui(4), ._, ._ }, |
| | 34006 | .{ ._, ._l, .sh, .tmp0q, .ui(4), ._, ._ }, |
| | 34007 | .{ ._, ._, .@"and", .src0q, .tmp1q, ._, ._ }, |
| | 34008 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 34009 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 34010 | .{ ._, ._, .mov, .tmp1q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34011 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 34012 | .{ ._, ._r, .sh, .dst0q, .ui(2), ._, ._ }, |
| | 34013 | .{ ._, ._l, .sh, .tmp0q, .ui(2), ._, ._ }, |
| | 34014 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| | 34015 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 34016 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 34017 | .{ ._, ._, .mov, .tmp1q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34018 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 34019 | .{ ._, ._r, .sh, .dst0q, .ui(1), ._, ._ }, |
| | 34020 | .{ ._, ._l, .sh, .tmp0q, .ui(1), ._, ._ }, |
| | 34021 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| | 34022 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 34023 | .{ ._, ._r, .sh, .dst0q, .uia(64, .dst0, .sub_bit_size), ._, ._ }, |
| | 34024 | } }, |
| | 34025 | }, .{ |
| | 34026 | .required_features = .{ .avx, .gfni, null, null }, |
| | 34027 | .src_constraints = .{ .{ .exact_int = 128 }, .any, .any }, |
| | 34028 | .patterns = &.{ |
| | 34029 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 34030 | }, |
| | 34031 | .extra_temps = .{ |
| | 34032 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34033 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34034 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34035 | .unused, |
| | 34036 | .unused, |
| | 34037 | .unused, |
| | 34038 | .unused, |
| | 34039 | .unused, |
| | 34040 | .unused, |
| | 34041 | .unused, |
| | 34042 | .unused, |
| | 34043 | }, |
| | 34044 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 34045 | .each = .{ .once = &.{ |
| | 34046 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34047 | .{ ._, .v_b, .gf2p8affineq, .dst0x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 34048 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34049 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp2x), ._ }, |
| | 34050 | } }, |
| | 34051 | }, .{ |
| | 34052 | .required_features = .{ .ssse3, .gfni, null, null }, |
| | 34053 | .src_constraints = .{ .{ .exact_int = 128 }, .any, .any }, |
| | 34054 | .patterns = &.{ |
| | 34055 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 34056 | }, |
| | 34057 | .extra_temps = .{ |
| | 34058 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34059 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34060 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34061 | .unused, |
| | 34062 | .unused, |
| | 34063 | .unused, |
| | 34064 | .unused, |
| | 34065 | .unused, |
| | 34066 | .unused, |
| | 34067 | .unused, |
| | 34068 | .unused, |
| | 34069 | }, |
| | 34070 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 34071 | .each = .{ .once = &.{ |
| | 34072 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34073 | .{ ._, ._b, .gf2p8affineq, .dst0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 34074 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34075 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp2x), ._, ._ }, |
| | 34076 | } }, |
| | 34077 | }, .{ |
| | 34078 | .required_features = .{ .@"64bit", .avx, .gfni, null }, |
| | 34079 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| | 34080 | .patterns = &.{ |
| | 34081 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 34082 | }, |
| | 34083 | .extra_temps = .{ |
| | 34084 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34085 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34086 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34087 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 34088 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34089 | .unused, |
| | 34090 | .unused, |
| | 34091 | .unused, |
| | 34092 | .unused, |
| | 34093 | .unused, |
| | 34094 | .unused, |
| | 34095 | }, |
| | 34096 | .dst_temps = .{ .mem, .unused }, |
| | 34097 | .clobbers = .{ .eflags = true }, |
| | 34098 | .each = .{ .once = &.{ |
| | 34099 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34100 | .{ ._, .v_b, .gf2p8affineq, .tmp3x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 34101 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34102 | .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .lea(.tmp2x), ._ }, |
| | 34103 | .{ ._, .v_q, .mov, .tmp2q, .tmp3x, ._, ._ }, |
| | 34104 | .{ ._, .vp_q, .extr, .tmp4q, .tmp3x, .ui(1), ._ }, |
| | 34105 | .{ ._, ._rd, .sh, .tmp2q, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._ }, |
| | 34106 | .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ }, |
| | 34107 | .{ ._, ._r, .sa, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._, ._ }, |
| | 34108 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, |
| | 34109 | } }, |
| | 34110 | }, .{ |
| | 34111 | .required_features = .{ .@"64bit", .ssse3, .gfni, null }, |
| | 34112 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| | 34113 | .patterns = &.{ |
| | 34114 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 34115 | }, |
| | 34116 | .extra_temps = .{ |
| | 34117 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34118 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34119 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34120 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34121 | .unused, |
| | 34122 | .unused, |
| | 34123 | .unused, |
| | 34124 | .unused, |
| | 34125 | .unused, |
| | 34126 | .unused, |
| | 34127 | .unused, |
| | 34128 | }, |
| | 34129 | .dst_temps = .{ .mem, .unused }, |
| | 34130 | .clobbers = .{ .eflags = true }, |
| | 34131 | .each = .{ .once = &.{ |
| | 34132 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34133 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 34134 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34135 | .{ ._, .p_b, .shuf, .src0x, .lea(.tmp2x), ._, ._ }, |
| | 34136 | .{ ._, ._q, .mov, .tmp2q, .src0x, ._, ._ }, |
| | 34137 | .{ ._, .p_q, .extr, .tmp3q, .src0x, .ui(1), ._ }, |
| | 34138 | .{ ._, ._rd, .sh, .tmp2q, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._ }, |
| | 34139 | .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ }, |
| | 34140 | .{ ._, ._r, .sa, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._, ._ }, |
| | 34141 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp3q, ._, ._ }, |
| | 34142 | } }, |
| | 34143 | }, .{ |
| | 34144 | .required_features = .{ .@"64bit", .avx, .gfni, null }, |
| | 34145 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| | 34146 | .patterns = &.{ |
| | 34147 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 34148 | }, |
| | 34149 | .extra_temps = .{ |
| | 34150 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34151 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34152 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34153 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 34154 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34155 | .unused, |
| | 34156 | .unused, |
| | 34157 | .unused, |
| | 34158 | .unused, |
| | 34159 | .unused, |
| | 34160 | .unused, |
| | 34161 | }, |
| | 34162 | .dst_temps = .{ .mem, .unused }, |
| | 34163 | .clobbers = .{ .eflags = true }, |
| | 34164 | .each = .{ .once = &.{ |
| | 34165 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34166 | .{ ._, .v_b, .gf2p8affineq, .tmp3x, .src0x, .lea(.tmp2x), .ui(0) }, |
| | 34167 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34168 | .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .lea(.tmp2x), ._ }, |
| | 34169 | .{ ._, .v_q, .mov, .tmp2q, .tmp3x, ._, ._ }, |
| | 34170 | .{ ._, .vp_q, .extr, .tmp4q, .tmp3x, .ui(1), ._ }, |
| | 34171 | .{ ._, ._rd, .sh, .tmp2q, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._ }, |
| | 34172 | .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ }, |
| | 34173 | .{ ._, ._r, .sh, .tmp4q, .uia(128, .dst0, .sub_bit_size), ._, ._ }, |
| | 34174 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, |
| | 34175 | } }, |
| | 34176 | }, .{ |
| | 34177 | .required_features = .{ .@"64bit", .ssse3, .gfni, null }, |
| | 34178 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| | 34179 | .patterns = &.{ |
| | 34180 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 34181 | }, |
| | 34182 | .extra_temps = .{ |
| | 34183 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34184 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34185 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34186 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34187 | .unused, |
| | 34188 | .unused, |
| | 34189 | .unused, |
| | 34190 | .unused, |
| | 34191 | .unused, |
| | 34192 | .unused, |
| | 34193 | .unused, |
| | 34194 | }, |
| | 34195 | .dst_temps = .{ .mem, .unused }, |
| | 34196 | .clobbers = .{ .eflags = true }, |
| | 34197 | .each = .{ .once = &.{ |
| | 34198 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34199 | .{ ._, ._b, .gf2p8affineq, .src0x, .lea(.tmp2x), .ui(0), ._ }, |
| | 34200 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34201 | .{ ._, .p_b, .shuf, .src0x, .lea(.tmp2x), ._, ._ }, |
| | 34202 | .{ ._, ._q, .mov, .tmp2q, .src0x, ._, ._ }, |
| | 34203 | .{ ._, .p_q, .extr, .tmp3q, .src0x, .ui(1), ._ }, |
| | 34204 | .{ ._, ._rd, .sh, .tmp2q, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._ }, |
| | 34205 | .{ ._, ._, .mov, .dst0q, .tmp2q, ._, ._ }, |
| | 34206 | .{ ._, ._r, .sh, .tmp3q, .uia(128, .dst0, .sub_bit_size), ._, ._ }, |
| | 34207 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp3q, ._, ._ }, |
| | 34208 | } }, |
| | 34209 | }, .{ |
| | 34210 | .required_features = .{ .avx2, .gfni, null, null }, |
| | 34211 | .src_constraints = .{ .{ .exact_int = 256 }, .any, .any }, |
| | 34212 | .patterns = &.{ |
| | 34213 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 34214 | }, |
| | 34215 | .extra_temps = .{ |
| | 34216 | .{ .type = .vector_32_u8, .kind = .forward_bits }, |
| | 34217 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } }, |
| | 34218 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34219 | .unused, |
| | 34220 | .unused, |
| | 34221 | .unused, |
| | 34222 | .unused, |
| | 34223 | .unused, |
| | 34224 | .unused, |
| | 34225 | .unused, |
| | 34226 | .unused, |
| | 34227 | }, |
| | 34228 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 34229 | .each = .{ .once = &.{ |
| | 34230 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34231 | .{ ._, .v_b, .gf2p8affineq, .dst0y, .src0y, .lea(.tmp2y), .ui(0) }, |
| | 34232 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34233 | .{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp2y), ._ }, |
| | 34234 | .{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b01_00_11_10), ._ }, |
| | 34235 | } }, |
| | 34236 | }, .{ |
| | 34237 | .required_features = .{ .avx, .gfni, null, null }, |
| | 34238 | .src_constraints = .{ .{ .exact_int = 256 }, .any, .any }, |
| | 34239 | .patterns = &.{ |
| | 34240 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 34241 | }, |
| | 34242 | .extra_temps = .{ |
| | 34243 | .{ .type = .vector_32_u8, .kind = .forward_bits }, |
| | 34244 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } }, |
| | 34245 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34246 | .unused, |
| | 34247 | .unused, |
| | 34248 | .unused, |
| | 34249 | .unused, |
| | 34250 | .unused, |
| | 34251 | .unused, |
| | 34252 | .unused, |
| | 34253 | .unused, |
| | 34254 | }, |
| | 34255 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 34256 | .each = .{ .once = &.{ |
| | 34257 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp0), ._, ._ }, |
| | 34258 | .{ ._, .v_b, .gf2p8affineq, .dst0y, .src0y, .lea(.tmp2y), .ui(0) }, |
| | 34259 | .{ ._, ._, .lea, .tmp2p, .mem(.tmp1), ._, ._ }, |
| | 34260 | .{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp2y), ._ }, |
| | 34261 | .{ ._, .v_pd, .perm, .dst0y, .dst0y, .ui(0b01_00_11_10), ._ }, |
| | 34262 | } }, |
| | 34263 | }, .{ |
| | 34264 | .required_features = .{ .avx2, .gfni, null, null }, |
| | 34265 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 34266 | .patterns = &.{ |
| | 34267 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34268 | }, |
| | 34269 | .extra_temps = .{ |
| | 34270 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34272 | .{ .type = .vector_32_u8, .kind = .forward_bits }, |
| | 34273 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } }, |
| | 34274 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 34275 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 34276 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 34277 | .unused, |
| | 34278 | .unused, |
| | 34279 | .unused, |
| | 34280 | .unused, |
| | 34281 | }, |
| | 34282 | .dst_temps = .{ .mem, .unused }, |
| | 34283 | .clobbers = .{ .eflags = true }, |
| | 34284 | .each = .{ .once = &.{ |
| | 34285 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 34286 | .{ ._, .v_dqa, .mov, .tmp4y, .lea(.tmp0y), ._, ._ }, |
| | 34287 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| | 34288 | .{ ._, .v_dqa, .mov, .tmp5y, .lea(.tmp0y), ._, ._ }, |
| | 34289 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, |
| | 34290 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34291 | .{ .@"0:", .v_q, .perm, .tmp6y, .lea(.tmp1y), .ui(0b01_00_11_10), ._ }, |
| | 34292 | .{ ._, .v_b, .gf2p8affineq, .tmp6y, .tmp6y, .tmp4y, .ui(0) }, |
| | 34293 | .{ ._, .vp_b, .shuf, .tmp6y, .tmp6y, .tmp5y, ._ }, |
| | 34294 | .{ ._, .v_dqu, .mov, .memi(.dst0y, .tmp0), .tmp6y, ._, ._ }, |
| | 34295 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 32), ._, ._ }, |
| | 34296 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 34297 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34298 | } }, |
| | 34299 | }, .{ |
| | 34300 | .required_features = .{ .avx, .gfni, null, null }, |
| | 34301 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 34302 | .patterns = &.{ |
| | 34303 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34304 | }, |
| | 34305 | .extra_temps = .{ |
| | 34306 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34307 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34308 | .{ .type = .vector_32_u8, .kind = .forward_bits }, |
| | 34309 | .{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } }, |
| | 34310 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 34311 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 34312 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 34313 | .unused, |
| | 34314 | .unused, |
| | 34315 | .unused, |
| | 34316 | .unused, |
| | 34317 | }, |
| | 34318 | .dst_temps = .{ .mem, .unused }, |
| | 34319 | .clobbers = .{ .eflags = true }, |
| | 34320 | .each = .{ .once = &.{ |
| | 34321 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 34322 | .{ ._, .v_dqa, .mov, .tmp4y, .lea(.tmp0y), ._, ._ }, |
| | 34323 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| | 34324 | .{ ._, .v_dqa, .mov, .tmp5y, .lea(.tmp0y), ._, ._ }, |
| | 34325 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, |
| | 34326 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34327 | .{ .@"0:", .v_pd, .perm, .tmp6y, .lea(.tmp1y), .ui(0b01_00_11_10), ._ }, |
| | 34328 | .{ ._, .v_b, .gf2p8affineq, .tmp6y, .tmp6y, .tmp4y, .ui(0) }, |
| | 34329 | .{ ._, .vp_b, .shuf, .tmp6y, .tmp6y, .tmp5y, ._ }, |
| | 34330 | .{ ._, .v_dqu, .mov, .memi(.dst0y, .tmp0), .tmp6y, ._, ._ }, |
| | 34331 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 32), ._, ._ }, |
| | 34332 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 34333 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34334 | } }, |
| | 34335 | }, .{ |
| | 34336 | .required_features = .{ .avx, .gfni, null, null }, |
| | 34337 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 34338 | .patterns = &.{ |
| | 34339 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34340 | }, |
| | 34341 | .extra_temps = .{ |
| | 34342 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34343 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34344 | .{ .type = .vector_16_u8, .kind = .forward_bits }, |
| | 34345 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } }, |
| | 34346 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 34347 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 34348 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 34349 | .unused, |
| | 34350 | .unused, |
| | 34351 | .unused, |
| | 34352 | .unused, |
| | 34353 | }, |
| | 34354 | .dst_temps = .{ .mem, .unused }, |
| | 34355 | .clobbers = .{ .eflags = true }, |
| | 34356 | .each = .{ .once = &.{ |
| | 34357 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 34358 | .{ ._, .v_dqa, .mov, .tmp4x, .lea(.tmp0x), ._, ._ }, |
| | 34359 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp3), ._, ._ }, |
| | 34360 | .{ ._, .v_dqa, .mov, .tmp5x, .lea(.tmp0x), ._, ._ }, |
| | 34361 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34362 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34363 | .{ .@"0:", .v_dqa, .mov, .tmp6x, .lea(.tmp1x), ._, ._ }, |
| | 34364 | .{ ._, .v_b, .gf2p8affineq, .tmp6x, .tmp6x, .tmp4x, .ui(0) }, |
| | 34365 | .{ ._, .vp_b, .shuf, .tmp6x, .tmp6x, .tmp5x, ._ }, |
| | 34366 | .{ ._, .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp6x, ._, ._ }, |
| | 34367 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| | 34368 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 34369 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34370 | } }, |
| | 34371 | }, .{ |
| | 34372 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 34373 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 34374 | .patterns = &.{ |
| | 34375 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34376 | }, |
| | 34377 | .extra_temps = .{ |
| | 34378 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34379 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34380 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34381 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34382 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34383 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34384 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34385 | .unused, |
| | 34386 | .unused, |
| | 34387 | .unused, |
| | 34388 | .unused, |
| | 34389 | }, |
| | 34390 | .dst_temps = .{ .mem, .unused }, |
| | 34391 | .clobbers = .{ .eflags = true }, |
| | 34392 | .each = .{ .once = &.{ |
| | 34393 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 34394 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34395 | .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34396 | .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34397 | .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34398 | .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 34399 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34400 | .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ }, |
| | 34401 | .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ }, |
| | 34402 | .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34403 | .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ }, |
| | 34404 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34405 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34406 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34407 | .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ }, |
| | 34408 | .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34409 | .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ }, |
| | 34410 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34411 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34412 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34413 | .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ }, |
| | 34414 | .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34415 | .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ }, |
| | 34416 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34417 | .{ ._, ._, .movbe, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ }, |
| | 34418 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34419 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34420 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34421 | } }, |
| | 34422 | }, .{ |
| | 34423 | .required_features = .{ .@"64bit", null, null, null }, |
| | 34424 | .src_constraints = .{ .{ .exact_remainder_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 34425 | .patterns = &.{ |
| | 34426 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34427 | }, |
| | 34428 | .extra_temps = .{ |
| | 34429 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34430 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34431 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34432 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34433 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34434 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34435 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34436 | .unused, |
| | 34437 | .unused, |
| | 34438 | .unused, |
| | 34439 | .unused, |
| | 34440 | }, |
| | 34441 | .dst_temps = .{ .mem, .unused }, |
| | 34442 | .clobbers = .{ .eflags = true }, |
| | 34443 | .each = .{ .once = &.{ |
| | 34444 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 34445 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34446 | .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34447 | .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34448 | .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34449 | .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 34450 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34451 | .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ }, |
| | 34452 | .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ }, |
| | 34453 | .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34454 | .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ }, |
| | 34455 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34456 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34457 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34458 | .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ }, |
| | 34459 | .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34460 | .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ }, |
| | 34461 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34462 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34463 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34464 | .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ }, |
| | 34465 | .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34466 | .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ }, |
| | 34467 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34468 | .{ ._, ._, .bswap, .tmp5q, ._, ._, ._ }, |
| | 34469 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ }, |
| | 34470 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34471 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34472 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34473 | } }, |
| | 34474 | }, .{ |
| | 34475 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 34476 | .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34477 | .patterns = &.{ |
| | 34478 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34479 | }, |
| | 34480 | .extra_temps = .{ |
| | 34481 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34482 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34483 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34484 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34485 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34486 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34487 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34488 | .unused, |
| | 34489 | .unused, |
| | 34490 | .unused, |
| | 34491 | .unused, |
| | 34492 | }, |
| | 34493 | .dst_temps = .{ .mem, .unused }, |
| | 34494 | .clobbers = .{ .eflags = true }, |
| | 34495 | .each = .{ .once = &.{ |
| | 34496 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34497 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34498 | .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ }, |
| | 34499 | .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34500 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34501 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| | 34502 | .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34503 | .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34504 | .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34505 | .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 34506 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34507 | .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ }, |
| | 34508 | .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ }, |
| | 34509 | .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34510 | .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ }, |
| | 34511 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34512 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34513 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34514 | .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ }, |
| | 34515 | .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34516 | .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ }, |
| | 34517 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34518 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34519 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34520 | .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ }, |
| | 34521 | .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34522 | .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ }, |
| | 34523 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34524 | .{ ._, ._, .movbe, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ }, |
| | 34525 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34526 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34527 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34528 | } }, |
| | 34529 | }, .{ |
| | 34530 | .required_features = .{ .@"64bit", null, null, null }, |
| | 34531 | .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34532 | .patterns = &.{ |
| | 34533 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34534 | }, |
| | 34535 | .extra_temps = .{ |
| | 34536 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34537 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34538 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34539 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34540 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34541 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34542 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34543 | .unused, |
| | 34544 | .unused, |
| | 34545 | .unused, |
| | 34546 | .unused, |
| | 34547 | }, |
| | 34548 | .dst_temps = .{ .mem, .unused }, |
| | 34549 | .clobbers = .{ .eflags = true }, |
| | 34550 | .each = .{ .once = &.{ |
| | 34551 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34552 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34553 | .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ }, |
| | 34554 | .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34555 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34556 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| | 34557 | .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34558 | .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34559 | .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34560 | .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 34561 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34562 | .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ }, |
| | 34563 | .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ }, |
| | 34564 | .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34565 | .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ }, |
| | 34566 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34567 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34568 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34569 | .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ }, |
| | 34570 | .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34571 | .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ }, |
| | 34572 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34573 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34574 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34575 | .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ }, |
| | 34576 | .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34577 | .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ }, |
| | 34578 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34579 | .{ ._, ._, .bswap, .tmp5q, ._, ._, ._ }, |
| | 34580 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ }, |
| | 34581 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34582 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34583 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34584 | } }, |
| | 34585 | }, .{ |
| | 34586 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 34587 | .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34588 | .patterns = &.{ |
| | 34589 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34590 | }, |
| | 34591 | .extra_temps = .{ |
| | 34592 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34593 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34594 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34595 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34596 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34597 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34598 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34599 | .unused, |
| | 34600 | .unused, |
| | 34601 | .unused, |
| | 34602 | .unused, |
| | 34603 | }, |
| | 34604 | .dst_temps = .{ .mem, .unused }, |
| | 34605 | .clobbers = .{ .eflags = true }, |
| | 34606 | .each = .{ .once = &.{ |
| | 34607 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34608 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34609 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 34610 | .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34611 | .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34612 | .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34613 | .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 34614 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34615 | .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ }, |
| | 34616 | .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ }, |
| | 34617 | .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34618 | .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ }, |
| | 34619 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34620 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34621 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34622 | .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ }, |
| | 34623 | .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34624 | .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ }, |
| | 34625 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34626 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34627 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34628 | .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ }, |
| | 34629 | .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34630 | .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ }, |
| | 34631 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34632 | .{ ._, ._, .movbe, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ }, |
| | 34633 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34634 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34635 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34636 | } }, |
| | 34637 | }, .{ |
| | 34638 | .required_features = .{ .@"64bit", null, null, null }, |
| | 34639 | .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34640 | .patterns = &.{ |
| | 34641 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34642 | }, |
| | 34643 | .extra_temps = .{ |
| | 34644 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34645 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34646 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34647 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34648 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34649 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34650 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34651 | .unused, |
| | 34652 | .unused, |
| | 34653 | .unused, |
| | 34654 | .unused, |
| | 34655 | }, |
| | 34656 | .dst_temps = .{ .mem, .unused }, |
| | 34657 | .clobbers = .{ .eflags = true }, |
| | 34658 | .each = .{ .once = &.{ |
| | 34659 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34660 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34661 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 34662 | .{ ._, ._, .mov, .tmp2q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34663 | .{ ._, ._, .mov, .tmp3q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34664 | .{ ._, ._, .mov, .tmp4q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34665 | .{ .@"0:", ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 34666 | .{ ._, ._, .bswap, .tmp5q, ._, ._, ._ }, |
| | 34667 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34668 | .{ ._, ._, .@"and", .tmp6q, .tmp2q, ._, ._ }, |
| | 34669 | .{ ._, ._r, .sh, .tmp5q, .ui(4), ._, ._ }, |
| | 34670 | .{ ._, ._l, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34671 | .{ ._, ._, .@"and", .tmp5q, .tmp2q, ._, ._ }, |
| | 34672 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34673 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34674 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34675 | .{ ._, ._r, .sh, .tmp5q, .ui(2), ._, ._ }, |
| | 34676 | .{ ._, ._l, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34677 | .{ ._, ._, .@"and", .tmp5q, .tmp3q, ._, ._ }, |
| | 34678 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34679 | .{ ._, ._, .mov, .tmp6q, .tmp5q, ._, ._ }, |
| | 34680 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34681 | .{ ._, ._r, .sh, .tmp5q, .ui(1), ._, ._ }, |
| | 34682 | .{ ._, ._l, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34683 | .{ ._, ._, .@"and", .tmp5q, .tmp4q, ._, ._ }, |
| | 34684 | .{ ._, ._, .@"or", .tmp5q, .tmp6q, ._, ._ }, |
| | 34685 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp5q, ._, ._ }, |
| | 34686 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34687 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34688 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34689 | } }, |
| | 34690 | }, .{ |
| | 34691 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 34692 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34693 | .patterns = &.{ |
| | 34694 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34695 | }, |
| | 34696 | .extra_temps = .{ |
| | 34697 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34698 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34699 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34700 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34701 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34702 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34703 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34704 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34705 | .unused, |
| | 34706 | .unused, |
| | 34707 | .unused, |
| | 34708 | }, |
| | 34709 | .dst_temps = .{ .mem, .unused }, |
| | 34710 | .clobbers = .{ .eflags = true }, |
| | 34711 | .each = .{ .once = &.{ |
| | 34712 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34713 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34714 | .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ }, |
| | 34715 | .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34716 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34717 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| | 34718 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34719 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34720 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34721 | .{ .@"0:", ._, .movbe, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 34722 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34723 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 34724 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34725 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 34726 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34727 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34728 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34729 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 34730 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34731 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 34732 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34733 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34734 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34735 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 34736 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34737 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 34738 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 34739 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34740 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34741 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 34742 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 34743 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 34744 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34745 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34746 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34747 | } }, |
| | 34748 | }, .{ |
| | 34749 | .required_features = .{ .@"64bit", null, null, null }, |
| | 34750 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34751 | .patterns = &.{ |
| | 34752 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34753 | }, |
| | 34754 | .extra_temps = .{ |
| | 34755 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34756 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34757 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34758 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34759 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34760 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34761 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34762 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34763 | .unused, |
| | 34764 | .unused, |
| | 34765 | .unused, |
| | 34766 | }, |
| | 34767 | .dst_temps = .{ .mem, .unused }, |
| | 34768 | .clobbers = .{ .eflags = true }, |
| | 34769 | .each = .{ .once = &.{ |
| | 34770 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34771 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34772 | .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ }, |
| | 34773 | .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34774 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34775 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| | 34776 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34777 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34778 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34779 | .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 34780 | .{ ._, ._, .bswap, .tmp6q, ._, ._, ._ }, |
| | 34781 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34782 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 34783 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34784 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 34785 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34786 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34787 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34788 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 34789 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34790 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 34791 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34792 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34793 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34794 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 34795 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34796 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 34797 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 34798 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34799 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34800 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 34801 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 34802 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 34803 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34804 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34805 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34806 | } }, |
| | 34807 | }, .{ |
| | 34808 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 34809 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34810 | .patterns = &.{ |
| | 34811 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34812 | }, |
| | 34813 | .extra_temps = .{ |
| | 34814 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34815 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34816 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34817 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34818 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34819 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34820 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34821 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34822 | .unused, |
| | 34823 | .unused, |
| | 34824 | .unused, |
| | 34825 | }, |
| | 34826 | .dst_temps = .{ .mem, .unused }, |
| | 34827 | .clobbers = .{ .eflags = true }, |
| | 34828 | .each = .{ .once = &.{ |
| | 34829 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34830 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34831 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 34832 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| | 34833 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34834 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34835 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34836 | .{ .@"0:", ._, .movbe, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 34837 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34838 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 34839 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34840 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 34841 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34842 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34843 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34844 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 34845 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34846 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 34847 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34848 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34849 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34850 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 34851 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34852 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 34853 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 34854 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34855 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34856 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 34857 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 34858 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 34859 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34860 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34861 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34862 | } }, |
| | 34863 | }, .{ |
| | 34864 | .required_features = .{ .@"64bit", null, null, null }, |
| | 34865 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 34866 | .patterns = &.{ |
| | 34867 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34868 | }, |
| | 34869 | .extra_temps = .{ |
| | 34870 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34871 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34872 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34873 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34874 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34875 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34876 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34877 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34878 | .unused, |
| | 34879 | .unused, |
| | 34880 | .unused, |
| | 34881 | }, |
| | 34882 | .dst_temps = .{ .mem, .unused }, |
| | 34883 | .clobbers = .{ .eflags = true }, |
| | 34884 | .each = .{ .once = &.{ |
| | 34885 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 34886 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34887 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 34888 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp2q, ._, ._ }, |
| | 34889 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34890 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34891 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34892 | .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 34893 | .{ ._, ._, .bswap, .tmp6q, ._, ._, ._ }, |
| | 34894 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34895 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 34896 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34897 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 34898 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34899 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34900 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34901 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 34902 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34903 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 34904 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34905 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34906 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34907 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 34908 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34909 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 34910 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 34911 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34912 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34913 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 34914 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 34915 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 34916 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34917 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34918 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34919 | } }, |
| | 34920 | }, .{ |
| | 34921 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 34922 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 34923 | .patterns = &.{ |
| | 34924 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34925 | }, |
| | 34926 | .extra_temps = .{ |
| | 34927 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34928 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34929 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34930 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34931 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34932 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34933 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34934 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34935 | .unused, |
| | 34936 | .unused, |
| | 34937 | .unused, |
| | 34938 | }, |
| | 34939 | .dst_temps = .{ .mem, .unused }, |
| | 34940 | .clobbers = .{ .eflags = true }, |
| | 34941 | .each = .{ .once = &.{ |
| | 34942 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 34943 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 34944 | .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ }, |
| | 34945 | .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34946 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 34947 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 34948 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 34949 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 34950 | .{ .@"0:", ._, .movbe, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 34951 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34952 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 34953 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 34954 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 34955 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 34956 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34957 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34958 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 34959 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 34960 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 34961 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 34962 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34963 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34964 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 34965 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 34966 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 34967 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 34968 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 34969 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 34970 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 34971 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 34972 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 34973 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 34974 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 34975 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 34976 | } }, |
| | 34977 | }, .{ |
| | 34978 | .required_features = .{ .@"64bit", null, null, null }, |
| | 34979 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 34980 | .patterns = &.{ |
| | 34981 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 34982 | }, |
| | 34983 | .extra_temps = .{ |
| | 34984 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 34985 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 34986 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34987 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34988 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34989 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34990 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34991 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 34992 | .unused, |
| | 34993 | .unused, |
| | 34994 | .unused, |
| | 34995 | }, |
| | 34996 | .dst_temps = .{ .mem, .unused }, |
| | 34997 | .clobbers = .{ .eflags = true }, |
| | 34998 | .each = .{ .once = &.{ |
| | 34999 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 35000 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 35001 | .{ ._, ._, .mov, .tmp2d, .mem(.src0d), ._, ._ }, |
| | 35002 | .{ ._, ._l, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 35003 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 35004 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 35005 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 35006 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 35007 | .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 35008 | .{ ._, ._, .bswap, .tmp6q, ._, ._, ._ }, |
| | 35009 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35010 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 35011 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 35012 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 35013 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 35014 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35015 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35016 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 35017 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 35018 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 35019 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 35020 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35021 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35022 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 35023 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 35024 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 35025 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 35026 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35027 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35028 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 35029 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 35030 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 35031 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 35032 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 35033 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 35034 | } }, |
| | 35035 | }, .{ |
| | 35036 | .required_features = .{ .@"64bit", .movbe, null, null }, |
| | 35037 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 35038 | .patterns = &.{ |
| | 35039 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 35040 | }, |
| | 35041 | .extra_temps = .{ |
| | 35042 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 35043 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 35044 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35045 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35046 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35047 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35048 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35049 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35050 | .unused, |
| | 35051 | .unused, |
| | 35052 | .unused, |
| | 35053 | }, |
| | 35054 | .dst_temps = .{ .mem, .unused }, |
| | 35055 | .clobbers = .{ .eflags = true }, |
| | 35056 | .each = .{ .once = &.{ |
| | 35057 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 35058 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 35059 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 35060 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 35061 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 35062 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 35063 | .{ .@"0:", ._, .movbe, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 35064 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35065 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 35066 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 35067 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 35068 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 35069 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35070 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35071 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 35072 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 35073 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 35074 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 35075 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35076 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35077 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 35078 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 35079 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 35080 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 35081 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35082 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35083 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 35084 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 35085 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 35086 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 35087 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 35088 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 35089 | } }, |
| | 35090 | }, .{ |
| | 35091 | .required_features = .{ .@"64bit", null, null, null }, |
| | 35092 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 35093 | .patterns = &.{ |
| | 35094 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 35095 | }, |
| | 35096 | .extra_temps = .{ |
| | 35097 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 35098 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 35099 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35100 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35101 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35102 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35103 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35104 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 35105 | .unused, |
| | 35106 | .unused, |
| | 35107 | .unused, |
| | 35108 | }, |
| | 35109 | .dst_temps = .{ .mem, .unused }, |
| | 35110 | .clobbers = .{ .eflags = true }, |
| | 35111 | .each = .{ .once = &.{ |
| | 35112 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 35113 | .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ }, |
| | 35114 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 35115 | .{ ._, ._, .mov, .tmp3q, .uia(0b00001111000011110000111100001111, .none, .repeat), ._, ._ }, |
| | 35116 | .{ ._, ._, .mov, .tmp4q, .uia(0b00110011001100110011001100110011, .none, .repeat), ._, ._ }, |
| | 35117 | .{ ._, ._, .mov, .tmp5q, .uia(0b01010101010101010101010101010101, .none, .repeat), ._, ._ }, |
| | 35118 | .{ .@"0:", ._, .mov, .tmp6q, .lea(.tmp1q), ._, ._ }, |
| | 35119 | .{ ._, ._, .bswap, .tmp6q, ._, ._, ._ }, |
| | 35120 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35121 | .{ ._, ._, .@"and", .tmp7q, .tmp3q, ._, ._ }, |
| | 35122 | .{ ._, ._r, .sh, .tmp6q, .ui(4), ._, ._ }, |
| | 35123 | .{ ._, ._l, .sh, .tmp7q, .ui(4), ._, ._ }, |
| | 35124 | .{ ._, ._, .@"and", .tmp6q, .tmp3q, ._, ._ }, |
| | 35125 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35126 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35127 | .{ ._, ._, .@"and", .tmp7q, .tmp4q, ._, ._ }, |
| | 35128 | .{ ._, ._r, .sh, .tmp6q, .ui(2), ._, ._ }, |
| | 35129 | .{ ._, ._l, .sh, .tmp7q, .ui(2), ._, ._ }, |
| | 35130 | .{ ._, ._, .@"and", .tmp6q, .tmp4q, ._, ._ }, |
| | 35131 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35132 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35133 | .{ ._, ._, .@"and", .tmp7q, .tmp5q, ._, ._ }, |
| | 35134 | .{ ._, ._r, .sh, .tmp6q, .ui(1), ._, ._ }, |
| | 35135 | .{ ._, ._l, .sh, .tmp7q, .ui(1), ._, ._ }, |
| | 35136 | .{ ._, ._, .@"and", .tmp6q, .tmp5q, ._, ._ }, |
| | 35137 | .{ ._, ._, .@"or", .tmp6q, .tmp7q, ._, ._ }, |
| | 35138 | .{ ._, ._, .mov, .tmp7q, .tmp6q, ._, ._ }, |
| | 35139 | .{ ._, ._rd, .sh, .tmp6q, .tmp2q, .uia(64, .src0, .sub_bit_size_rem_64), ._ }, |
| | 35140 | .{ ._, ._, .mov, .tmp2q, .tmp7q, ._, ._ }, |
| | 35141 | .{ ._, ._, .mov, .memi(.dst0q, .tmp0), .tmp6q, ._, ._ }, |
| | 35142 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 35143 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 35144 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 35145 | } }, |
| | 35146 | } }) catch |err| switch (err) { |
| | 35147 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| | 35148 | @tagName(air_tag), |
| | 35149 | ty_op.ty.toType().fmt(pt), |
| | 35150 | ops[0].tracking(cg), |
| | 35151 | }), |
| | 35152 | else => |e| return e, |
| | 35153 | }; |
| | 35154 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| | 35155 | }, |
| 32021 | | 35156 | |
| 32022 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { | 35157 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { |
| 32023 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 35158 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| ... | @@ -59301,7 +62436,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -59301,7 +62436,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 59301 | }, | 62436 | }, |
| 59302 | .extra_temps = .{ | 62437 | .extra_temps = .{ |
| 59303 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 62438 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 59304 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 62439 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 59305 | .unused, | 62440 | .unused, |
| 59306 | .unused, | 62441 | .unused, |
| 59307 | .unused, | 62442 | .unused, |
| ... | @@ -59328,7 +62463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -59328,7 +62463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 59328 | }, | 62463 | }, |
| 59329 | .extra_temps = .{ | 62464 | .extra_temps = .{ |
| 59330 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 62465 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59331 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 62466 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 59332 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 62467 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 59333 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 62468 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 59334 | .unused, | 62469 | .unused, |
| ... | @@ -60950,7 +64085,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -60950,7 +64085,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 60950 | }, | 64085 | }, |
| 60951 | .extra_temps = .{ | 64086 | .extra_temps = .{ |
| 60952 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 64087 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 60953 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 64088 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 60954 | .unused, | 64089 | .unused, |
| 60955 | .unused, | 64090 | .unused, |
| 60956 | .unused, | 64091 | .unused, |
| ... | @@ -60977,7 +64112,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -60977,7 +64112,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 60977 | }, | 64112 | }, |
| 60978 | .extra_temps = .{ | 64113 | .extra_temps = .{ |
| 60979 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 64114 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 60980 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 64115 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 60981 | .unused, | 64116 | .unused, |
| 60982 | .unused, | 64117 | .unused, |
| 60983 | .unused, | 64118 | .unused, |
| ... | @@ -61003,7 +64138,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -61003,7 +64138,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 61003 | }, | 64138 | }, |
| 61004 | .extra_temps = .{ | 64139 | .extra_temps = .{ |
| 61005 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 64140 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61006 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 64141 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 61007 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 64142 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61008 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 64143 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61009 | .unused, | 64144 | .unused, |
| ... | @@ -61034,7 +64169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -61034,7 +64169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 61034 | }, | 64169 | }, |
| 61035 | .extra_temps = .{ | 64170 | .extra_temps = .{ |
| 61036 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 64171 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61037 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 64172 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 61038 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 64173 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61039 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 64174 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61040 | .unused, | 64175 | .unused, |
| ... | @@ -62506,7 +65641,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -62506,7 +65641,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62506 | }, | 65641 | }, |
| 62507 | .extra_temps = .{ | 65642 | .extra_temps = .{ |
| 62508 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 65643 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 62509 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 65644 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 62510 | .unused, | 65645 | .unused, |
| 62511 | .unused, | 65646 | .unused, |
| 62512 | .unused, | 65647 | .unused, |
| ... | @@ -62533,7 +65668,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -62533,7 +65668,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62533 | }, | 65668 | }, |
| 62534 | .extra_temps = .{ | 65669 | .extra_temps = .{ |
| 62535 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 65670 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 62536 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 65671 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 62537 | .unused, | 65672 | .unused, |
| 62538 | .unused, | 65673 | .unused, |
| 62539 | .unused, | 65674 | .unused, |
| ... | @@ -62560,7 +65695,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -62560,7 +65695,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62560 | }, | 65695 | }, |
| 62561 | .extra_temps = .{ | 65696 | .extra_temps = .{ |
| 62562 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 65697 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 62563 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 65698 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 62564 | .unused, | 65699 | .unused, |
| 62565 | .unused, | 65700 | .unused, |
| 62566 | .unused, | 65701 | .unused, |
| ... | @@ -62586,7 +65721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -62586,7 +65721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62586 | }, | 65721 | }, |
| 62587 | .extra_temps = .{ | 65722 | .extra_temps = .{ |
| 62588 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 65723 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62589 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 65724 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 62590 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 65725 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62591 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 65726 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62592 | .unused, | 65727 | .unused, |
| ... | @@ -62618,7 +65753,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -62618,7 +65753,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62618 | }, | 65753 | }, |
| 62619 | .extra_temps = .{ | 65754 | .extra_temps = .{ |
| 62620 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 65755 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62621 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, | 65756 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .dword, .to = .byte } } }, |
| 62622 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 65757 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62623 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 65758 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62624 | .unused, | 65759 | .unused, |
| ... | @@ -91576,9 +94711,12 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -91576,9 +94711,12 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 91576 | } | 94711 | } |
| 91577 | | 94712 | |
| 91578 | const MoveStrategy = union(enum) { | 94713 | const MoveStrategy = union(enum) { |
| 91579 | move: Mir.Inst.FixedTag, | 94714 | move_through_gpr, |
| 91580 | x87_load_store, | 94715 | load_store_through_frame, |
| | 94716 | load_store: Mir.Inst.FixedTag, |
| | 94717 | load_store_x87, |
| 91581 | insert_extract: InsertExtract, | 94718 | insert_extract: InsertExtract, |
| | 94719 | insert_or_extract_through_gpr: InsertExtract, |
| 91582 | vex_insert_extract: InsertExtract, | 94720 | vex_insert_extract: InsertExtract, |
| 91583 | | 94721 | |
| 91584 | const InsertExtract = struct { | 94722 | const InsertExtract = struct { |
| ... | @@ -91586,194 +94724,215 @@ const MoveStrategy = union(enum) { | ... | @@ -91586,194 +94724,215 @@ const MoveStrategy = union(enum) { |
| 91586 | extract: Mir.Inst.FixedTag, | 94724 | extract: Mir.Inst.FixedTag, |
| 91587 | }; | 94725 | }; |
| 91588 | | 94726 | |
| 91589 | pub fn read(strat: MoveStrategy, self: *CodeGen, dst_reg: Register, src_mem: Memory) !void { | 94727 | pub fn read(strat: MoveStrategy, cg: *CodeGen, dst_reg: Register, src_mem: Memory) !void { |
| 91590 | switch (strat) { | 94728 | switch (strat) { |
| 91591 | .move => |tag| try self.asmRegisterMemory(tag, switch (tag[1]) { | 94729 | .move_through_gpr => { |
| 91592 | else => dst_reg, | 94730 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 91593 | .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), | 94731 | try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), src_mem); |
| 91594 | }, src_mem), | 94732 | try cg.asmRegisterRegister(.{ ._d, .mov }, dst_reg, tmp_reg.to32()); |
| 91595 | .x87_load_store => if (dst_reg != .st0 and self.register_manager.isKnownRegFree(.st7)) { | 94733 | }, |
| 91596 | try self.asmMemory(.{ .f_, .ld }, src_mem); | 94734 | .load_store_through_frame => { |
| | 94735 | const tmp_frame_index = try cg.allocFrameIndex(.init(.{ |
| | 94736 | .size = 16, |
| | 94737 | .alignment = .@"16", |
| | 94738 | })); |
| | 94739 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| | 94740 | try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), src_mem); |
| | 94741 | try cg.asmMemoryRegister(.{ ._, .mov }, .{ |
| | 94742 | .base = .{ .frame = tmp_frame_index }, |
| | 94743 | .mod = .{ .rm = .{ .size = .dword } }, |
| | 94744 | }, tmp_reg.to32()); |
| | 94745 | try cg.asmRegisterMemory(.{ ._ps, .mova }, dst_reg, .{ |
| | 94746 | .base = .{ .frame = tmp_frame_index }, |
| | 94747 | .mod = .{ .rm = .{ .size = .xword } }, |
| | 94748 | }); |
| | 94749 | }, |
| | 94750 | .load_store => |tag| { |
| | 94751 | if (tag[0] == ._ps and tag[1] == .movl) try cg.asmRegisterRegister(.{ .p_, .xor }, dst_reg, dst_reg); |
| | 94752 | try cg.asmRegisterMemory(tag, switch (tag[1]) { |
| | 94753 | else => dst_reg, |
| | 94754 | .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), |
| | 94755 | }, src_mem); |
| | 94756 | }, |
| | 94757 | .load_store_x87 => if (dst_reg != .st0 and cg.register_manager.isKnownRegFree(.st7)) { |
| | 94758 | try cg.asmMemory(.{ .f_, .ld }, src_mem); |
| 91597 | switch (dst_reg) { | 94759 | switch (dst_reg) { |
| 91598 | .st1, .st2, .st3, .st4, .st5, .st6 => try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)), | 94760 | .st1, .st2, .st3, .st4, .st5, .st6 => try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)), |
| 91599 | .st7 => try self.asmOpOnly(.{ .f_cstp, .in }), | 94761 | .st7 => try cg.asmOpOnly(.{ .f_cstp, .in }), |
| 91600 | else => unreachable, | 94762 | else => unreachable, |
| 91601 | } | 94763 | } |
| 91602 | } else { | 94764 | } else { |
| 91603 | try self.asmRegister(.{ .f_p, .st }, dst_reg); | 94765 | try cg.asmRegister(.{ .f_p, .st }, dst_reg); |
| 91604 | try self.asmMemory(.{ .f_, .ld }, src_mem); | 94766 | try cg.asmMemory(.{ .f_, .ld }, src_mem); |
| 91605 | switch (dst_reg) { | 94767 | switch (dst_reg) { |
| 91606 | .st0 => {}, | 94768 | .st0 => {}, |
| 91607 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, dst_reg), | 94769 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try cg.asmRegister(.{ .f_, .xch }, dst_reg), |
| 91608 | else => unreachable, | 94770 | else => unreachable, |
| 91609 | } | 94771 | } |
| 91610 | }, | 94772 | }, |
| 91611 | .insert_extract => |ie| if (ie.insert[0] != .p_w or self.hasFeature(.sse2)) | 94773 | .insert_extract, .insert_or_extract_through_gpr => |ie| { |
| 91612 | try self.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)) | 94774 | try cg.asmRegisterRegister(.{ .p_, .xor }, dst_reg, dst_reg); |
| 91613 | else { | 94775 | try cg.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)); |
| 91614 | const tmp_frame_index = try self.allocFrameIndex(.init(.{ | 94776 | }, |
| | 94777 | .vex_insert_extract => |ie| { |
| | 94778 | try cg.asmRegisterRegisterRegister(.{ .vp_, .xor }, dst_reg, dst_reg, dst_reg); |
| | 94779 | try cg.asmRegisterRegisterMemoryImmediate(ie.insert, dst_reg, dst_reg, src_mem, .u(0)); |
| | 94780 | }, |
| | 94781 | } |
| | 94782 | } |
| | 94783 | pub fn write(strat: MoveStrategy, cg: *CodeGen, dst_mem: Memory, src_reg: Register) !void { |
| | 94784 | switch (strat) { |
| | 94785 | .move_through_gpr => { |
| | 94786 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| | 94787 | try cg.asmRegisterRegister(.{ ._d, .mov }, tmp_reg.to32(), src_reg.to128()); |
| | 94788 | try cg.asmMemoryRegister( |
| | 94789 | .{ ._, .mov }, |
| | 94790 | dst_mem, |
| | 94791 | registerAlias(tmp_reg, @intCast(@divExact(dst_mem.mod.rm.size.bitSize(cg.target), 8))), |
| | 94792 | ); |
| | 94793 | }, |
| | 94794 | .load_store_through_frame => { |
| | 94795 | const tmp_frame_index = try cg.allocFrameIndex(.init(.{ |
| 91615 | .size = 16, | 94796 | .size = 16, |
| 91616 | .alignment = .@"16", | 94797 | .alignment = .@"16", |
| 91617 | })); | 94798 | })); |
| 91618 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); | 94799 | try cg.asmMemoryRegister(.{ ._ps, .mova }, .{ |
| 91619 | try self.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), src_mem); | | |
| 91620 | try self.asmMemoryRegister(.{ ._, .mov }, .{ | | |
| 91621 | .base = .{ .frame = tmp_frame_index }, | | |
| 91622 | .mod = .{ .rm = .{ .size = .word } }, | | |
| 91623 | }, tmp_reg.to16()); | | |
| 91624 | try self.asmRegisterMemory(.{ ._ps, .mova }, dst_reg.to128(), .{ | | |
| 91625 | .base = .{ .frame = tmp_frame_index }, | 94800 | .base = .{ .frame = tmp_frame_index }, |
| 91626 | .mod = .{ .rm = .{ .size = .xword } }, | 94801 | .mod = .{ .rm = .{ .size = .xword } }, |
| | 94802 | }, src_reg.to128()); |
| | 94803 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| | 94804 | try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), .{ |
| | 94805 | .base = .{ .frame = tmp_frame_index }, |
| | 94806 | .mod = .{ .rm = .{ .size = .word } }, |
| 91627 | }); | 94807 | }); |
| | 94808 | try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); |
| 91628 | }, | 94809 | }, |
| 91629 | .vex_insert_extract => |ie| try self.asmRegisterRegisterMemoryImmediate( | 94810 | .load_store => |tag| try cg.asmMemoryRegister(tag, dst_mem, src_reg), |
| 91630 | ie.insert, | 94811 | .load_store_x87 => if (cg.register_manager.isKnownRegFree(.st7)) { |
| 91631 | dst_reg, | 94812 | try cg.asmRegister(.{ .f_, .ld }, src_reg); |
| 91632 | dst_reg, | 94813 | try cg.asmMemory(.{ .f_p, .st }, dst_mem); |
| 91633 | src_mem, | | |
| 91634 | .u(0), | | |
| 91635 | ), | | |
| 91636 | } | | |
| 91637 | } | | |
| 91638 | pub fn write(strat: MoveStrategy, self: *CodeGen, dst_mem: Memory, src_reg: Register) !void { | | |
| 91639 | switch (strat) { | | |
| 91640 | .move => |tag| try self.asmMemoryRegister(tag, dst_mem, src_reg), | | |
| 91641 | .x87_load_store => if (self.register_manager.isKnownRegFree(.st7)) { | | |
| 91642 | try self.asmRegister(.{ .f_, .ld }, src_reg); | | |
| 91643 | try self.asmMemory(.{ .f_p, .st }, dst_mem); | | |
| 91644 | } else { | 94814 | } else { |
| 91645 | switch (src_reg) { | 94815 | switch (src_reg) { |
| 91646 | .st0 => {}, | 94816 | .st0 => {}, |
| 91647 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, src_reg), | 94817 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try cg.asmRegister(.{ .f_, .xch }, src_reg), |
| 91648 | else => unreachable, | 94818 | else => unreachable, |
| 91649 | } | 94819 | } |
| 91650 | try self.asmMemory(.{ .f_p, .st }, dst_mem); | 94820 | try cg.asmMemory(.{ .f_p, .st }, dst_mem); |
| 91651 | try self.asmMemory(.{ .f_, .ld }, dst_mem); | 94821 | try cg.asmMemory(.{ .f_, .ld }, dst_mem); |
| 91652 | switch (src_reg) { | 94822 | switch (src_reg) { |
| 91653 | .st0 => {}, | 94823 | .st0 => {}, |
| 91654 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try self.asmRegister(.{ .f_, .xch }, src_reg), | 94824 | .st1, .st2, .st3, .st4, .st5, .st6, .st7 => try cg.asmRegister(.{ .f_, .xch }, src_reg), |
| 91655 | else => unreachable, | 94825 | else => unreachable, |
| 91656 | } | 94826 | } |
| 91657 | }, | 94827 | }, |
| 91658 | .insert_extract, .vex_insert_extract => |ie| if (ie.extract[0] != .p_w or self.hasFeature(.sse4_1)) | 94828 | .insert_extract, .vex_insert_extract => |ie| try cg.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)), |
| 91659 | try self.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)) | 94829 | .insert_or_extract_through_gpr => |ie| { |
| 91660 | else if (self.hasFeature(.sse2)) { | 94830 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 91661 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); | 94831 | try cg.asmRegisterRegisterImmediate(ie.extract, tmp_reg.to32(), src_reg.to128(), .u(0)); |
| 91662 | try self.asmRegisterRegisterImmediate(ie.extract, tmp_reg.to32(), src_reg.to128(), .u(0)); | 94832 | try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); |
| 91663 | try self.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); | | |
| 91664 | } else { | | |
| 91665 | const tmp_frame_index = try self.allocFrameIndex(.init(.{ | | |
| 91666 | .size = 16, | | |
| 91667 | .alignment = .@"16", | | |
| 91668 | })); | | |
| 91669 | try self.asmMemoryRegister(.{ ._ps, .mova }, .{ | | |
| 91670 | .base = .{ .frame = tmp_frame_index }, | | |
| 91671 | .mod = .{ .rm = .{ .size = .xword } }, | | |
| 91672 | }, src_reg.to128()); | | |
| 91673 | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); | | |
| 91674 | try self.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), .{ | | |
| 91675 | .base = .{ .frame = tmp_frame_index }, | | |
| 91676 | .mod = .{ .rm = .{ .size = .word } }, | | |
| 91677 | }); | | |
| 91678 | try self.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); | | |
| 91679 | }, | 94833 | }, |
| 91680 | } | 94834 | } |
| 91681 | } | 94835 | } |
| 91682 | }; | 94836 | }; |
| 91683 | fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !MoveStrategy { | 94837 | fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !MoveStrategy { |
| 91684 | const pt = self.pt; | 94838 | const pt = cg.pt; |
| 91685 | const zcu = pt.zcu; | 94839 | const zcu = pt.zcu; |
| 91686 | switch (class) { | 94840 | switch (class) { |
| 91687 | .general_purpose, .segment => return .{ .move = .{ ._, .mov } }, | 94841 | .general_purpose, .segment => return .{ .load_store = .{ ._, .mov } }, |
| 91688 | .x87 => return .x87_load_store, | 94842 | .x87 => return .load_store_x87, |
| 91689 | .mmx => {}, | 94843 | .mmx => {}, |
| 91690 | .sse => switch (ty.zigTypeTag(zcu)) { | 94844 | .sse => switch (ty.zigTypeTag(zcu)) { |
| 91691 | else => { | 94845 | else => { |
| 91692 | const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target.*, .other), .none); | 94846 | const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target.*, .other), .none); |
| 91693 | assert(std.mem.indexOfNone(abi.Class, classes, &.{ | 94847 | assert(std.mem.indexOfNone(abi.Class, classes, &.{ |
| 91694 | .integer, .sse, .sseup, .memory, .float, .float_combine, | 94848 | .integer, .sse, .sseup, .memory, .float, .float_combine, |
| 91695 | }) == null); | 94849 | }) == null); |
| 91696 | const abi_size = ty.abiSize(zcu); | 94850 | const abi_size = ty.abiSize(zcu); |
| 91697 | if (abi_size < 4 or | 94851 | if (abi_size < 4 or std.mem.indexOfScalar(abi.Class, classes, .integer) != null) switch (abi_size) { |
| 91698 | std.mem.indexOfScalar(abi.Class, classes, .integer) != null) switch (abi_size) { | 94852 | 1 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91699 | 1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{ | | |
| 91700 | .insert = .{ .vp_b, .insr }, | 94853 | .insert = .{ .vp_b, .insr }, |
| 91701 | .extract = .{ .vp_b, .extr }, | 94854 | .extract = .{ .vp_b, .extr }, |
| 91702 | } } else if (self.hasFeature(.sse4_2)) return .{ .insert_extract = .{ | 94855 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91703 | .insert = .{ .p_b, .insr }, | 94856 | .insert = .{ .p_b, .insr }, |
| 91704 | .extract = .{ .p_b, .extr }, | 94857 | .extract = .{ .p_b, .extr }, |
| 91705 | } }, | 94858 | } } else if (cg.hasFeature(.sse2)) .move_through_gpr else .load_store_through_frame, |
| 91706 | 2 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ | 94859 | 2 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91707 | .insert = .{ .vp_w, .insr }, | 94860 | .insert = .{ .vp_w, .insr }, |
| 91708 | .extract = .{ .vp_w, .extr }, | 94861 | .extract = .{ .vp_w, .extr }, |
| 91709 | } } else .{ .insert_extract = .{ | 94862 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91710 | .insert = .{ .p_w, .insr }, | 94863 | .insert = .{ .p_w, .insr }, |
| 91711 | .extract = .{ .p_w, .extr }, | 94864 | .extract = .{ .p_w, .extr }, |
| 91712 | } }, | 94865 | } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{ |
| 91713 | 3...4 => return .{ .move = .{ if (self.hasFeature(.avx)) | 94866 | .insert = .{ .p_w, .insr }, |
| | 94867 | .extract = .{ .p_w, .extr }, |
| | 94868 | } } else .load_store_through_frame, |
| | 94869 | 3...4 => return .{ .load_store = .{ if (cg.hasFeature(.avx)) |
| 91714 | .v_d | 94870 | .v_d |
| 91715 | else if (self.hasFeature(.sse2)) | 94871 | else if (cg.hasFeature(.sse2)) |
| 91716 | ._d | 94872 | ._d |
| 91717 | else | 94873 | else |
| 91718 | ._ss, .mov } }, | 94874 | ._ss, .mov } }, |
| 91719 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) | 94875 | 5...8 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91720 | .{ .v_q, .mov } | 94876 | .{ .v_q, .mov } |
| 91721 | else if (self.hasFeature(.sse2)) | 94877 | else if (cg.hasFeature(.sse2)) |
| 91722 | .{ ._q, .mov } | 94878 | .{ ._q, .mov } |
| 91723 | else | 94879 | else |
| 91724 | .{ ._ps, .movl } }, | 94880 | .{ ._ps, .movl } }, |
| 91725 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) | 94881 | 9...16 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91726 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 94882 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91727 | else if (self.hasFeature(.sse2)) | 94883 | else if (cg.hasFeature(.sse2)) |
| 91728 | .{ if (aligned) ._dqa else ._dqu, .mov } | 94884 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91729 | else | 94885 | else |
| 91730 | .{ ._ps, if (aligned) .mova else .movu } }, | 94886 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91731 | 17...32 => if (self.hasFeature(.avx)) | 94887 | 17...32 => if (cg.hasFeature(.avx)) |
| 91732 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 94888 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91733 | else => {}, | 94889 | else => {}, |
| 91734 | } else switch (abi_size) { | 94890 | } else switch (abi_size) { |
| 91735 | 4 => return .{ .move = if (self.hasFeature(.avx)) | 94891 | 4 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91736 | .{ .v_ss, .mov } | 94892 | .{ .v_ss, .mov } |
| 91737 | else | 94893 | else |
| 91738 | .{ ._ss, .mov } }, | 94894 | .{ ._ss, .mov } }, |
| 91739 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) | 94895 | 5...8 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91740 | .{ .v_sd, .mov } | 94896 | .{ .v_sd, .mov } |
| 91741 | else if (self.hasFeature(.sse2)) | 94897 | else if (cg.hasFeature(.sse2)) |
| 91742 | .{ ._sd, .mov } | 94898 | .{ ._sd, .mov } |
| 91743 | else | 94899 | else |
| 91744 | .{ ._ps, .movl } }, | 94900 | .{ ._ps, .movl } }, |
| 91745 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) | 94901 | 9...16 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91746 | .{ .v_pd, if (aligned) .mova else .movu } | 94902 | .{ .v_pd, if (aligned) .mova else .movu } |
| 91747 | else if (self.hasFeature(.sse2)) | 94903 | else if (cg.hasFeature(.sse2)) |
| 91748 | .{ ._pd, if (aligned) .mova else .movu } | 94904 | .{ ._pd, if (aligned) .mova else .movu } |
| 91749 | else | 94905 | else |
| 91750 | .{ ._ps, if (aligned) .mova else .movu } }, | 94906 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91751 | 17...32 => if (self.hasFeature(.avx)) | 94907 | 17...32 => if (cg.hasFeature(.avx)) |
| 91752 | return .{ .move = .{ .v_pd, if (aligned) .mova else .movu } }, | 94908 | return .{ .load_store = .{ .v_pd, if (aligned) .mova else .movu } }, |
| 91753 | else => {}, | 94909 | else => {}, |
| 91754 | } | 94910 | } |
| 91755 | }, | 94911 | }, |
| 91756 | .float => switch (ty.floatBits(self.target.*)) { | 94912 | .float => switch (ty.floatBits(cg.target.*)) { |
| 91757 | 16 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ | 94913 | 16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91758 | .insert = .{ .vp_w, .insr }, | 94914 | .insert = .{ .vp_w, .insr }, |
| 91759 | .extract = .{ .vp_w, .extr }, | 94915 | .extract = .{ .vp_w, .extr }, |
| 91760 | } } else .{ .insert_extract = .{ | 94916 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91761 | .insert = .{ .p_w, .insr }, | 94917 | .insert = .{ .p_w, .insr }, |
| 91762 | .extract = .{ .p_w, .extr }, | 94918 | .extract = .{ .p_w, .extr }, |
| 91763 | } }, | 94919 | } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{ |
| 91764 | 32 => return .{ .move = if (self.hasFeature(.avx)) | 94920 | .insert = .{ .p_w, .insr }, |
| | 94921 | .extract = .{ .p_w, .extr }, |
| | 94922 | } } else .load_store_through_frame, |
| | 94923 | 32 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91765 | .{ .v_ss, .mov } | 94924 | .{ .v_ss, .mov } |
| 91766 | else | 94925 | else |
| 91767 | .{ ._ss, .mov } }, | 94926 | .{ ._ss, .mov } }, |
| 91768 | 64 => return .{ .move = if (self.hasFeature(.avx)) | 94927 | 64 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91769 | .{ .v_sd, .mov } | 94928 | .{ .v_sd, .mov } |
| 91770 | else if (self.hasFeature(.sse2)) | 94929 | else if (cg.hasFeature(.sse2)) |
| 91771 | .{ ._sd, .mov } | 94930 | .{ ._sd, .mov } |
| 91772 | else | 94931 | else |
| 91773 | .{ ._ps, .movl } }, | 94932 | .{ ._ps, .movl } }, |
| 91774 | 128 => return .{ .move = if (self.hasFeature(.avx)) | 94933 | 128 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91775 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 94934 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91776 | else if (self.hasFeature(.sse2)) | 94935 | else if (cg.hasFeature(.sse2)) |
| 91777 | .{ if (aligned) ._dqa else ._dqu, .mov } | 94936 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91778 | else | 94937 | else |
| 91779 | .{ ._ps, if (aligned) .mova else .movu } }, | 94938 | .{ ._ps, if (aligned) .mova else .movu } }, |
| ... | @@ -91781,160 +94940,163 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) | ... | @@ -91781,160 +94940,163 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 91781 | }, | 94940 | }, |
| 91782 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { | 94941 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { |
| 91783 | .bool => switch (ty.vectorLen(zcu)) { | 94942 | .bool => switch (ty.vectorLen(zcu)) { |
| 91784 | 1...8 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{ | 94943 | 1...8 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91785 | .insert = .{ .vp_b, .insr }, | 94944 | .insert = .{ .vp_b, .insr }, |
| 91786 | .extract = .{ .vp_b, .extr }, | 94945 | .extract = .{ .vp_b, .extr }, |
| 91787 | } } else if (self.hasFeature(.sse4_2)) return .{ .insert_extract = .{ | 94946 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91788 | .insert = .{ .p_b, .insr }, | 94947 | .insert = .{ .p_b, .insr }, |
| 91789 | .extract = .{ .p_b, .extr }, | 94948 | .extract = .{ .p_b, .extr }, |
| 91790 | } }, | 94949 | } } else if (cg.hasFeature(.sse2)) .move_through_gpr else .load_store_through_frame, |
| 91791 | 9...16 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ | 94950 | 9...16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91792 | .insert = .{ .vp_w, .insr }, | 94951 | .insert = .{ .vp_w, .insr }, |
| 91793 | .extract = .{ .vp_w, .extr }, | 94952 | .extract = .{ .vp_w, .extr }, |
| 91794 | } } else .{ .insert_extract = .{ | 94953 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91795 | .insert = .{ .p_w, .insr }, | 94954 | .insert = .{ .p_w, .insr }, |
| 91796 | .extract = .{ .p_w, .extr }, | 94955 | .extract = .{ .p_w, .extr }, |
| 91797 | } }, | 94956 | } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{ |
| 91798 | 17...32 => return .{ .move = .{ if (self.hasFeature(.avx)) | 94957 | .insert = .{ .p_w, .insr }, |
| | 94958 | .extract = .{ .p_w, .extr }, |
| | 94959 | } } else .load_store_through_frame, |
| | 94960 | 17...32 => return .{ .load_store = .{ if (cg.hasFeature(.avx)) |
| 91799 | .v_d | 94961 | .v_d |
| 91800 | else if (self.hasFeature(.sse2)) | 94962 | else if (cg.hasFeature(.sse2)) |
| 91801 | ._d | 94963 | ._d |
| 91802 | else | 94964 | else |
| 91803 | ._ss, .mov } }, | 94965 | ._ss, .mov } }, |
| 91804 | 33...64 => return .{ .move = if (self.hasFeature(.avx)) | 94966 | 33...64 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91805 | .{ .v_q, .mov } | 94967 | .{ .v_q, .mov } |
| 91806 | else if (self.hasFeature(.sse2)) | 94968 | else if (cg.hasFeature(.sse2)) |
| 91807 | .{ ._q, .mov } | 94969 | .{ ._q, .mov } |
| 91808 | else | 94970 | else |
| 91809 | .{ ._ps, .movl } }, | 94971 | .{ ._ps, .movl } }, |
| 91810 | 65...128 => return .{ .move = if (self.hasFeature(.avx)) | 94972 | 65...128 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91811 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 94973 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91812 | else if (self.hasFeature(.sse2)) | 94974 | else if (cg.hasFeature(.sse2)) |
| 91813 | .{ if (aligned) ._dqa else ._dqu, .mov } | 94975 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91814 | else | 94976 | else |
| 91815 | .{ ._ps, if (aligned) .mova else .movu } }, | 94977 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91816 | 129...256 => if (self.hasFeature(.avx)) | 94978 | 129...256 => if (cg.hasFeature(.avx)) |
| 91817 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 94979 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91818 | else => {}, | 94980 | else => {}, |
| 91819 | }, | 94981 | }, |
| 91820 | .int => switch (ty.childType(zcu).intInfo(zcu).bits) { | 94982 | .int => switch (ty.childType(zcu).intInfo(zcu).bits) { |
| 91821 | 1...8 => switch (ty.vectorLen(zcu)) { | 94983 | 1...8 => switch (ty.vectorLen(zcu)) { |
| 91822 | 1...16 => return .{ .move = if (self.hasFeature(.avx)) | 94984 | 1...16 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91823 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 94985 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91824 | else if (self.hasFeature(.sse2)) | 94986 | else if (cg.hasFeature(.sse2)) |
| 91825 | .{ if (aligned) ._dqa else ._dqu, .mov } | 94987 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91826 | else | 94988 | else |
| 91827 | .{ ._ps, if (aligned) .mova else .movu } }, | 94989 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91828 | 17...32 => if (self.hasFeature(.avx)) | 94990 | 17...32 => if (cg.hasFeature(.avx)) |
| 91829 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 94991 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91830 | else => {}, | 94992 | else => {}, |
| 91831 | }, | 94993 | }, |
| 91832 | 9...16 => switch (ty.vectorLen(zcu)) { | 94994 | 9...16 => switch (ty.vectorLen(zcu)) { |
| 91833 | 1...8 => return .{ .move = if (self.hasFeature(.avx)) | 94995 | 1...8 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91834 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 94996 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91835 | else if (self.hasFeature(.sse2)) | 94997 | else if (cg.hasFeature(.sse2)) |
| 91836 | .{ if (aligned) ._dqa else ._dqu, .mov } | 94998 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91837 | else | 94999 | else |
| 91838 | .{ ._ps, if (aligned) .mova else .movu } }, | 95000 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91839 | 9...16 => if (self.hasFeature(.avx)) | 95001 | 9...16 => if (cg.hasFeature(.avx)) |
| 91840 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95002 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91841 | else => {}, | 95003 | else => {}, |
| 91842 | }, | 95004 | }, |
| 91843 | 17...32 => switch (ty.vectorLen(zcu)) { | 95005 | 17...32 => switch (ty.vectorLen(zcu)) { |
| 91844 | 1...4 => return .{ .move = if (self.hasFeature(.avx)) | 95006 | 1...4 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91845 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 95007 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91846 | else if (self.hasFeature(.sse2)) | 95008 | else if (cg.hasFeature(.sse2)) |
| 91847 | .{ if (aligned) ._dqa else ._dqu, .mov } | 95009 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91848 | else | 95010 | else |
| 91849 | .{ ._ps, if (aligned) .mova else .movu } }, | 95011 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91850 | 5...8 => if (self.hasFeature(.avx)) | 95012 | 5...8 => if (cg.hasFeature(.avx)) |
| 91851 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95013 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91852 | else => {}, | 95014 | else => {}, |
| 91853 | }, | 95015 | }, |
| 91854 | 33...64 => switch (ty.vectorLen(zcu)) { | 95016 | 33...64 => switch (ty.vectorLen(zcu)) { |
| 91855 | 1...2 => return .{ .move = if (self.hasFeature(.avx)) | 95017 | 1...2 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91856 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 95018 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91857 | else if (self.hasFeature(.sse2)) | 95019 | else if (cg.hasFeature(.sse2)) |
| 91858 | .{ if (aligned) ._dqa else ._dqu, .mov } | 95020 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91859 | else | 95021 | else |
| 91860 | .{ ._ps, if (aligned) .mova else .movu } }, | 95022 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91861 | 3...4 => if (self.hasFeature(.avx)) | 95023 | 3...4 => if (cg.hasFeature(.avx)) |
| 91862 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95024 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91863 | else => {}, | 95025 | else => {}, |
| 91864 | }, | 95026 | }, |
| 91865 | 65...128 => switch (ty.vectorLen(zcu)) { | 95027 | 65...128 => switch (ty.vectorLen(zcu)) { |
| 91866 | 1 => return .{ .move = if (self.hasFeature(.avx)) | 95028 | 1 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91867 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 95029 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91868 | else if (self.hasFeature(.sse2)) | 95030 | else if (cg.hasFeature(.sse2)) |
| 91869 | .{ if (aligned) ._dqa else ._dqu, .mov } | 95031 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91870 | else | 95032 | else |
| 91871 | .{ ._ps, if (aligned) .mova else .movu } }, | 95033 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91872 | 2 => if (self.hasFeature(.avx)) | 95034 | 2 => if (cg.hasFeature(.avx)) |
| 91873 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95035 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91874 | else => {}, | 95036 | else => {}, |
| 91875 | }, | 95037 | }, |
| 91876 | 129...256 => switch (ty.vectorLen(zcu)) { | 95038 | 129...256 => switch (ty.vectorLen(zcu)) { |
| 91877 | 1 => if (self.hasFeature(.avx)) | 95039 | 1 => if (cg.hasFeature(.avx)) |
| 91878 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95040 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91879 | else => {}, | 95041 | else => {}, |
| 91880 | }, | 95042 | }, |
| 91881 | else => {}, | 95043 | else => {}, |
| 91882 | }, | 95044 | }, |
| 91883 | .pointer, .optional => if (ty.childType(zcu).isPtrAtRuntime(zcu)) | 95045 | .pointer, .optional => if (ty.childType(zcu).isPtrAtRuntime(zcu)) |
| 91884 | switch (ty.vectorLen(zcu)) { | 95046 | switch (ty.vectorLen(zcu)) { |
| 91885 | 1...2 => return .{ .move = if (self.hasFeature(.avx)) | 95047 | 1...2 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91886 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 95048 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91887 | else if (self.hasFeature(.sse2)) | 95049 | else if (cg.hasFeature(.sse2)) |
| 91888 | .{ if (aligned) ._dqa else ._dqu, .mov } | 95050 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91889 | else | 95051 | else |
| 91890 | .{ ._ps, if (aligned) .mova else .movu } }, | 95052 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91891 | 3...4 => if (self.hasFeature(.avx)) | 95053 | 3...4 => if (cg.hasFeature(.avx)) |
| 91892 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95054 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91893 | else => {}, | 95055 | else => {}, |
| 91894 | } | 95056 | } |
| 91895 | else | 95057 | else |
| 91896 | unreachable, | 95058 | unreachable, |
| 91897 | .float => switch (ty.childType(zcu).floatBits(self.target.*)) { | 95059 | .float => switch (ty.childType(zcu).floatBits(cg.target.*)) { |
| 91898 | 16 => switch (ty.vectorLen(zcu)) { | 95060 | 16 => switch (ty.vectorLen(zcu)) { |
| 91899 | 1...8 => return .{ .move = if (self.hasFeature(.avx)) | 95061 | 1...8 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91900 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 95062 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91901 | else if (self.hasFeature(.sse2)) | 95063 | else if (cg.hasFeature(.sse2)) |
| 91902 | .{ if (aligned) ._dqa else ._dqu, .mov } | 95064 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91903 | else | 95065 | else |
| 91904 | .{ ._ps, if (aligned) .mova else .movu } }, | 95066 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91905 | 9...16 => if (self.hasFeature(.avx)) | 95067 | 9...16 => if (cg.hasFeature(.avx)) |
| 91906 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95068 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91907 | else => {}, | 95069 | else => {}, |
| 91908 | }, | 95070 | }, |
| 91909 | 32 => switch (ty.vectorLen(zcu)) { | 95071 | 32 => switch (ty.vectorLen(zcu)) { |
| 91910 | 1...4 => return .{ .move = if (self.hasFeature(.avx)) | 95072 | 1...4 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91911 | .{ .v_ps, if (aligned) .mova else .movu } | 95073 | .{ .v_ps, if (aligned) .mova else .movu } |
| 91912 | else | 95074 | else |
| 91913 | .{ ._ps, if (aligned) .mova else .movu } }, | 95075 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91914 | 5...8 => if (self.hasFeature(.avx)) | 95076 | 5...8 => if (cg.hasFeature(.avx)) |
| 91915 | return .{ .move = .{ .v_ps, if (aligned) .mova else .movu } }, | 95077 | return .{ .load_store = .{ .v_ps, if (aligned) .mova else .movu } }, |
| 91916 | else => {}, | 95078 | else => {}, |
| 91917 | }, | 95079 | }, |
| 91918 | 64 => switch (ty.vectorLen(zcu)) { | 95080 | 64 => switch (ty.vectorLen(zcu)) { |
| 91919 | 1...2 => return .{ .move = if (self.hasFeature(.avx)) | 95081 | 1...2 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91920 | .{ .v_pd, if (aligned) .mova else .movu } | 95082 | .{ .v_pd, if (aligned) .mova else .movu } |
| 91921 | else if (self.hasFeature(.sse2)) | 95083 | else if (cg.hasFeature(.sse2)) |
| 91922 | .{ ._pd, if (aligned) .mova else .movu } | 95084 | .{ ._pd, if (aligned) .mova else .movu } |
| 91923 | else | 95085 | else |
| 91924 | .{ ._ps, if (aligned) .mova else .movu } }, | 95086 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91925 | 3...4 => if (self.hasFeature(.avx)) | 95087 | 3...4 => if (cg.hasFeature(.avx)) |
| 91926 | return .{ .move = .{ .v_pd, if (aligned) .mova else .movu } }, | 95088 | return .{ .load_store = .{ .v_pd, if (aligned) .mova else .movu } }, |
| 91927 | else => {}, | 95089 | else => {}, |
| 91928 | }, | 95090 | }, |
| 91929 | 80, 128 => switch (ty.vectorLen(zcu)) { | 95091 | 80, 128 => switch (ty.vectorLen(zcu)) { |
| 91930 | 1 => return .{ .move = if (self.hasFeature(.avx)) | 95092 | 1 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91931 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 95093 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91932 | else if (self.hasFeature(.sse2)) | 95094 | else if (cg.hasFeature(.sse2)) |
| 91933 | .{ if (aligned) ._dqa else ._dqu, .mov } | 95095 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91934 | else | 95096 | else |
| 91935 | .{ ._ps, if (aligned) .mova else .movu } }, | 95097 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91936 | 2 => if (self.hasFeature(.avx)) | 95098 | 2 => if (cg.hasFeature(.avx)) |
| 91937 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, | 95099 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91938 | else => {}, | 95100 | else => {}, |
| 91939 | }, | 95101 | }, |
| 91940 | else => {}, | 95102 | else => {}, |
| ... | @@ -91944,7 +95106,7 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) | ... | @@ -91944,7 +95106,7 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 91944 | }, | 95106 | }, |
| 91945 | .ip, .cr, .dr => {}, | 95107 | .ip, .cr, .dr => {}, |
| 91946 | } | 95108 | } |
| 91947 | return self.fail("TODO moveStrategy for {}", .{ty.fmt(pt)}); | 95109 | return cg.fail("TODO moveStrategy for {}", .{ty.fmt(pt)}); |
| 91948 | } | 95110 | } |
| 91949 | | 95111 | |
| 91950 | const CopyOptions = struct { | 95112 | const CopyOptions = struct { |
| ... | @@ -92332,7 +95494,7 @@ fn genSetReg( | ... | @@ -92332,7 +95494,7 @@ fn genSetReg( |
| 92332 | .size = 16, | 95494 | .size = 16, |
| 92333 | .alignment = .@"16", | 95495 | .alignment = .@"16", |
| 92334 | })); | 95496 | })); |
| 92335 | try MoveStrategy.write(.x87_load_store, self, .{ | 95497 | try MoveStrategy.write(.load_store_x87, self, .{ |
| 92336 | .base = .{ .frame = frame_index }, | 95498 | .base = .{ .frame = frame_index }, |
| 92337 | .mod = .{ .rm = .{ .size = .tbyte } }, | 95499 | .mod = .{ .rm = .{ .size = .tbyte } }, |
| 92338 | }, src_reg); | 95500 | }, src_reg); |
| ... | @@ -92430,7 +95592,7 @@ fn genSetReg( | ... | @@ -92430,7 +95592,7 @@ fn genSetReg( |
| 92430 | => try @as(MoveStrategy, switch (src_mcv) { | 95592 | => try @as(MoveStrategy, switch (src_mcv) { |
| 92431 | .register_offset => |reg_off| switch (reg_off.off) { | 95593 | .register_offset => |reg_off| switch (reg_off.off) { |
| 92432 | 0 => return self.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts), | 95594 | 0 => return self.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts), |
| 92433 | else => .{ .move = .{ ._, .lea } }, | 95595 | else => .{ .load_store = .{ ._, .lea } }, |
| 92434 | }, | 95596 | }, |
| 92435 | .indirect => try self.moveStrategy(ty, dst_reg.class(), false), | 95597 | .indirect => try self.moveStrategy(ty, dst_reg.class(), false), |
| 92436 | .load_frame => |frame_addr| try self.moveStrategy( | 95598 | .load_frame => |frame_addr| try self.moveStrategy( |
| ... | @@ -92440,7 +95602,7 @@ fn genSetReg( | ... | @@ -92440,7 +95602,7 @@ fn genSetReg( |
| 92440 | std.math.log2_int_ceil(u10, @divExact(dst_reg.bitSize(), 8)), | 95602 | std.math.log2_int_ceil(u10, @divExact(dst_reg.bitSize(), 8)), |
| 92441 | )), | 95603 | )), |
| 92442 | ), | 95604 | ), |
| 92443 | .lea_frame => .{ .move = .{ ._, .lea } }, | 95605 | .lea_frame => .{ .load_store = .{ ._, .lea } }, |
| 92444 | else => unreachable, | 95606 | else => unreachable, |
| 92445 | }).read(self, dst_alias, switch (src_mcv) { | 95607 | }).read(self, dst_alias, switch (src_mcv) { |
| 92446 | .register_offset, .indirect => |reg_off| .{ | 95608 | .register_offset, .indirect => |reg_off| .{ |
| ... | @@ -100903,7 +104065,10 @@ const Select = struct { | ... | @@ -100903,7 +104065,10 @@ const Select = struct { |
| 100903 | f64_0x1p52_0x1p84_mem, | 104065 | f64_0x1p52_0x1p84_mem, |
| 100904 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, | 104066 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, |
| 100905 | f32_0_0x1p64_mem, | 104067 | f32_0_0x1p64_mem, |
| 100906 | pshufb_cm_mem: struct { from: Memory.Size, to: Memory.Size }, | 104068 | pshufb_trunc_mem: struct { from: Memory.Size, to: Memory.Size }, |
| | 104069 | pshufb_bswap_mem: struct { repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 }, |
| | 104070 | forward_bits, |
| | 104071 | reverse_bits, |
| 100907 | frame: FrameIndex, | 104072 | frame: FrameIndex, |
| 100908 | lazy_symbol: struct { kind: link.File.LazySymbol.Kind, ref: Select.Operand.Ref = .none }, | 104073 | lazy_symbol: struct { kind: link.File.LazySymbol.Kind, ref: Select.Operand.Ref = .none }, |
| 100909 | symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 }, | 104074 | symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 }, |
| ... | @@ -101115,10 +104280,13 @@ const Select = struct { | ... | @@ -101115,10 +104280,13 @@ const Select = struct { |
| 101115 | (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(), | 104280 | (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(), |
| 101116 | } }, | 104281 | } }, |
| 101117 | } }))), true }, | 104282 | } }))), true }, |
| 101118 | .pshufb_cm_mem => |const_spec| { | 104283 | .pshufb_trunc_mem => |trunc_spec| { |
| | 104284 | const zcu = pt.zcu; |
| | 104285 | assert(spec.type.isVector(zcu)); |
| | 104286 | assert(spec.type.childType(zcu).toIntern() == .u8_type); |
| 101119 | var bytes: [16]u8 = @splat(1 << 7); | 104287 | var bytes: [16]u8 = @splat(1 << 7); |
| 101120 | const from_bytes: u32 = @intCast(@divExact(const_spec.from.bitSize(cg.target), 8)); | 104288 | const from_bytes: u32 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8)); |
| 101121 | const to_bytes: u32 = @intCast(@divExact(const_spec.to.bitSize(cg.target), 8)); | 104289 | const to_bytes: u32 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8)); |
| 101122 | var from_index: u32 = 0; | 104290 | var from_index: u32 = 0; |
| 101123 | var to_index: u32 = 0; | 104291 | var to_index: u32 = 0; |
| 101124 | while (from_index < bytes.len) { | 104292 | while (from_index < bytes.len) { |
| ... | @@ -101126,10 +104294,43 @@ const Select = struct { | ... | @@ -101126,10 +104294,43 @@ const Select = struct { |
| 101126 | from_index += from_bytes; | 104294 | from_index += from_bytes; |
| 101127 | to_index += to_bytes; | 104295 | to_index += to_bytes; |
| 101128 | } | 104296 | } |
| | 104297 | const elems = bytes[0..spec.type.vectorLen(zcu)]; |
| | 104298 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| | 104299 | .ty = spec.type.toIntern(), |
| | 104300 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| | 104301 | } }))), true }; |
| | 104302 | }, |
| | 104303 | .pshufb_bswap_mem => |bswap_spec| { |
| 101129 | const zcu = pt.zcu; | 104304 | const zcu = pt.zcu; |
| | 104305 | assert(spec.type.isVector(zcu)); |
| | 104306 | assert(spec.type.childType(zcu).toIntern() == .u8_type); |
| | 104307 | var bytes: [32]u8 = @splat(1 << 7); |
| | 104308 | const len: usize = @intCast(@divExact(bswap_spec.size.bitSize(cg.target), 8)); |
| | 104309 | var to_index: u32 = 0; |
| | 104310 | for (0..bswap_spec.repeat) |_| for (0..len) |from_index| { |
| | 104311 | @memset(bytes[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index)); |
| | 104312 | to_index += bswap_spec.smear; |
| | 104313 | }; |
| | 104314 | const elems = bytes[0..spec.type.vectorLen(zcu)]; |
| | 104315 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| | 104316 | .ty = spec.type.toIntern(), |
| | 104317 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| | 104318 | } }))), true }; |
| | 104319 | }, |
| | 104320 | .forward_bits, .reverse_bits => { |
| | 104321 | const zcu = pt.zcu; |
| | 104322 | assert(spec.type.isVector(zcu)); |
| | 104323 | assert(spec.type.childType(zcu).toIntern() == .u8_type); |
| | 104324 | var bytes: [32]u8 = undefined; |
| | 104325 | const elems = bytes[0..spec.type.vectorLen(zcu)]; |
| | 104326 | for (elems, 0..) |*elem, index| elem.* = switch (spec.kind) { |
| | 104327 | else => unreachable, |
| | 104328 | .forward_bits => @as(u8, 1 << 0) << @truncate(index), |
| | 104329 | .reverse_bits => @as(u8, 1 << 7) >> @truncate(index), |
| | 104330 | }; |
| 101130 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ | 104331 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| 101131 | .ty = (try pt.vectorType(.{ .len = bytes.len, .child = .u8_type })).toIntern(), | 104332 | .ty = spec.type.toIntern(), |
| 101132 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, &bytes, .maybe_embedded_nulls) }, | 104333 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| 101133 | } }))), true }; | 104334 | } }))), true }; |
| 101134 | }, | 104335 | }, |
| 101135 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, | 104336 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, |
| ... | @@ -102013,9 +105214,10 @@ const Select = struct { | ... | @@ -102013,9 +105214,10 @@ const Select = struct { |
| 102013 | .div_8_down => lhs >> 3 & @as(SignedImm, -1) << rhs, | 105214 | .div_8_down => lhs >> 3 & @as(SignedImm, -1) << rhs, |
| 102014 | .rem_8_mul => lhs & (@as(SignedImm, 1) << @intCast(@as(u3, 3) + rhs)) - 1, | 105215 | .rem_8_mul => lhs & (@as(SignedImm, 1) << @intCast(@as(u3, 3) + rhs)) - 1, |
| 102015 | }; | 105216 | }; |
| | 105217 | const disp: SignedImm = @bitCast(@as(UnsignedImm, @as(u32, @bitCast(op.imm)))); |
| 102016 | return switch (op.flags.adjust.sign) { | 105218 | return switch (op.flags.adjust.sign) { |
| 102017 | .neg => op.imm - op_res, | 105219 | .neg => disp - op_res, |
| 102018 | .pos => op.imm + op_res, | 105220 | .pos => disp + op_res, |
| 102019 | }; | 105221 | }; |
| 102020 | } | 105222 | } |
| 102021 | | 105223 | |
Jacob Young <jacobly@ziglang.org> 2025-02-21 11:07:57-05:00
Andrew Kelley <andrew@ziglang.org> 2025-02-22 00:05:47-05:00
src