| ... | ... | @@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2418 | 2418 | } |
| 2419 | 2419 | |
| 2420 | 2420 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2421 | | @setEvalBranchQuota(12_900); |
| 2421 | @setEvalBranchQuota(13_600); |
| 2422 | 2422 | const pt = cg.pt; |
| 2423 | 2423 | const zcu = pt.zcu; |
| 2424 | 2424 | const ip = &zcu.intern_pool; |
| ... | ... | @@ -2475,7 +2475,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2475 | 2475 | |
| 2476 | 2476 | .bitcast => try cg.airBitCast(inst), |
| 2477 | 2477 | |
| 2478 | | .bit_reverse => try cg.airBitReverse(inst), |
| 2479 | 2478 | .splat => try cg.airSplat(inst), |
| 2480 | 2479 | .select => try cg.airSelect(inst), |
| 2481 | 2480 | .shuffle => try cg.airShuffle(inst), |
| ... | ... | @@ -32018,6 +32017,3142 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 32018 | 32017 | }; |
| 32019 | 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 | 35157 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { |
| 32023 | 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 | 62436 | }, |
| 59302 | 62437 | .extra_temps = .{ |
| 59303 | 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 | 62440 | .unused, |
| 59306 | 62441 | .unused, |
| 59307 | 62442 | .unused, |
| ... | ... | @@ -59328,7 +62463,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 59328 | 62463 | }, |
| 59329 | 62464 | .extra_temps = .{ |
| 59330 | 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 | 62467 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 59333 | 62468 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 59334 | 62469 | .unused, |
| ... | ... | @@ -60950,7 +64085,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 60950 | 64085 | }, |
| 60951 | 64086 | .extra_temps = .{ |
| 60952 | 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 | 64089 | .unused, |
| 60955 | 64090 | .unused, |
| 60956 | 64091 | .unused, |
| ... | ... | @@ -60977,7 +64112,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 60977 | 64112 | }, |
| 60978 | 64113 | .extra_temps = .{ |
| 60979 | 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 | 64116 | .unused, |
| 60982 | 64117 | .unused, |
| 60983 | 64118 | .unused, |
| ... | ... | @@ -61003,7 +64138,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 61003 | 64138 | }, |
| 61004 | 64139 | .extra_temps = .{ |
| 61005 | 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 | 64142 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61008 | 64143 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61009 | 64144 | .unused, |
| ... | ... | @@ -61034,7 +64169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 61034 | 64169 | }, |
| 61035 | 64170 | .extra_temps = .{ |
| 61036 | 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 | 64173 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61039 | 64174 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 61040 | 64175 | .unused, |
| ... | ... | @@ -62506,7 +65641,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62506 | 65641 | }, |
| 62507 | 65642 | .extra_temps = .{ |
| 62508 | 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 | 65645 | .unused, |
| 62511 | 65646 | .unused, |
| 62512 | 65647 | .unused, |
| ... | ... | @@ -62533,7 +65668,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62533 | 65668 | }, |
| 62534 | 65669 | .extra_temps = .{ |
| 62535 | 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 | 65672 | .unused, |
| 62538 | 65673 | .unused, |
| 62539 | 65674 | .unused, |
| ... | ... | @@ -62560,7 +65695,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62560 | 65695 | }, |
| 62561 | 65696 | .extra_temps = .{ |
| 62562 | 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 | 65699 | .unused, |
| 62565 | 65700 | .unused, |
| 62566 | 65701 | .unused, |
| ... | ... | @@ -62586,7 +65721,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62586 | 65721 | }, |
| 62587 | 65722 | .extra_temps = .{ |
| 62588 | 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 | 65725 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62591 | 65726 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62592 | 65727 | .unused, |
| ... | ... | @@ -62618,7 +65753,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 62618 | 65753 | }, |
| 62619 | 65754 | .extra_temps = .{ |
| 62620 | 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 | 65757 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62623 | 65758 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 62624 | 65759 | .unused, |
| ... | ... | @@ -91576,9 +94711,12 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 91576 | 94711 | } |
| 91577 | 94712 | |
| 91578 | 94713 | const MoveStrategy = union(enum) { |
| 91579 | | move: Mir.Inst.FixedTag, |
| 91580 | | x87_load_store, |
| 94714 | move_through_gpr, |
| 94715 | load_store_through_frame, |
| 94716 | load_store: Mir.Inst.FixedTag, |
| 94717 | load_store_x87, |
| 91581 | 94718 | insert_extract: InsertExtract, |
| 94719 | insert_or_extract_through_gpr: InsertExtract, |
| 91582 | 94720 | vex_insert_extract: InsertExtract, |
| 91583 | 94721 | |
| 91584 | 94722 | const InsertExtract = struct { |
| ... | ... | @@ -91586,194 +94724,215 @@ const MoveStrategy = union(enum) { |
| 91586 | 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 | 94728 | switch (strat) { |
| 91591 | | .move => |tag| try self.asmRegisterMemory(tag, switch (tag[1]) { |
| 91592 | | else => dst_reg, |
| 91593 | | .lea => if (dst_reg.bitSize() >= 32) dst_reg else dst_reg.to32(), |
| 91594 | | }, src_mem), |
| 91595 | | .x87_load_store => if (dst_reg != .st0 and self.register_manager.isKnownRegFree(.st7)) { |
| 91596 | | try self.asmMemory(.{ .f_, .ld }, src_mem); |
| 94729 | .move_through_gpr => { |
| 94730 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 94731 | try cg.asmRegisterMemory(.{ ._, .movzx }, tmp_reg.to32(), src_mem); |
| 94732 | try cg.asmRegisterRegister(.{ ._d, .mov }, dst_reg, tmp_reg.to32()); |
| 94733 | }, |
| 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 | 94759 | switch (dst_reg) { |
| 91598 | | .st1, .st2, .st3, .st4, .st5, .st6 => try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)), |
| 91599 | | .st7 => try self.asmOpOnly(.{ .f_cstp, .in }), |
| 94760 | .st1, .st2, .st3, .st4, .st5, .st6 => try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)), |
| 94761 | .st7 => try cg.asmOpOnly(.{ .f_cstp, .in }), |
| 91600 | 94762 | else => unreachable, |
| 91601 | 94763 | } |
| 91602 | 94764 | } else { |
| 91603 | | try self.asmRegister(.{ .f_p, .st }, dst_reg); |
| 91604 | | try self.asmMemory(.{ .f_, .ld }, src_mem); |
| 94765 | try cg.asmRegister(.{ .f_p, .st }, dst_reg); |
| 94766 | try cg.asmMemory(.{ .f_, .ld }, src_mem); |
| 91605 | 94767 | switch (dst_reg) { |
| 91606 | 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 | 94770 | else => unreachable, |
| 91609 | 94771 | } |
| 91610 | 94772 | }, |
| 91611 | | .insert_extract => |ie| if (ie.insert[0] != .p_w or self.hasFeature(.sse2)) |
| 91612 | | try self.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)) |
| 91613 | | else { |
| 91614 | | const tmp_frame_index = try self.allocFrameIndex(.init(.{ |
| 94773 | .insert_extract, .insert_or_extract_through_gpr => |ie| { |
| 94774 | try cg.asmRegisterRegister(.{ .p_, .xor }, dst_reg, dst_reg); |
| 94775 | try cg.asmRegisterMemoryImmediate(ie.insert, dst_reg, src_mem, .u(0)); |
| 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 | 94796 | .size = 16, |
| 91616 | 94797 | .alignment = .@"16", |
| 91617 | 94798 | })); |
| 91618 | | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 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(), .{ |
| 94799 | try cg.asmMemoryRegister(.{ ._ps, .mova }, .{ |
| 91625 | 94800 | .base = .{ .frame = tmp_frame_index }, |
| 91626 | 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( |
| 91630 | | ie.insert, |
| 91631 | | dst_reg, |
| 91632 | | dst_reg, |
| 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); |
| 94810 | .load_store => |tag| try cg.asmMemoryRegister(tag, dst_mem, src_reg), |
| 94811 | .load_store_x87 => if (cg.register_manager.isKnownRegFree(.st7)) { |
| 94812 | try cg.asmRegister(.{ .f_, .ld }, src_reg); |
| 94813 | try cg.asmMemory(.{ .f_p, .st }, dst_mem); |
| 91644 | 94814 | } else { |
| 91645 | 94815 | switch (src_reg) { |
| 91646 | 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 | 94818 | else => unreachable, |
| 91649 | 94819 | } |
| 91650 | | try self.asmMemory(.{ .f_p, .st }, dst_mem); |
| 91651 | | try self.asmMemory(.{ .f_, .ld }, dst_mem); |
| 94820 | try cg.asmMemory(.{ .f_p, .st }, dst_mem); |
| 94821 | try cg.asmMemory(.{ .f_, .ld }, dst_mem); |
| 91652 | 94822 | switch (src_reg) { |
| 91653 | 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 | 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)) |
| 91659 | | try self.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)) |
| 91660 | | else if (self.hasFeature(.sse2)) { |
| 91661 | | const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 91662 | | try self.asmRegisterRegisterImmediate(ie.extract, tmp_reg.to32(), src_reg.to128(), .u(0)); |
| 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()); |
| 94828 | .insert_extract, .vex_insert_extract => |ie| try cg.asmMemoryRegisterImmediate(ie.extract, dst_mem, src_reg, .u(0)), |
| 94829 | .insert_or_extract_through_gpr => |ie| { |
| 94830 | const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp); |
| 94831 | try cg.asmRegisterRegisterImmediate(ie.extract, tmp_reg.to32(), src_reg.to128(), .u(0)); |
| 94832 | try cg.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 { |
| 91684 | | const pt = self.pt; |
| 94837 | fn moveStrategy(cg: *CodeGen, ty: Type, class: Register.Class, aligned: bool) !MoveStrategy { |
| 94838 | const pt = cg.pt; |
| 91685 | 94839 | const zcu = pt.zcu; |
| 91686 | 94840 | switch (class) { |
| 91687 | | .general_purpose, .segment => return .{ .move = .{ ._, .mov } }, |
| 91688 | | .x87 => return .x87_load_store, |
| 94841 | .general_purpose, .segment => return .{ .load_store = .{ ._, .mov } }, |
| 94842 | .x87 => return .load_store_x87, |
| 91689 | 94843 | .mmx => {}, |
| 91690 | 94844 | .sse => switch (ty.zigTypeTag(zcu)) { |
| 91691 | 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 | 94847 | assert(std.mem.indexOfNone(abi.Class, classes, &.{ |
| 91694 | 94848 | .integer, .sse, .sseup, .memory, .float, .float_combine, |
| 91695 | 94849 | }) == null); |
| 91696 | 94850 | const abi_size = ty.abiSize(zcu); |
| 91697 | | if (abi_size < 4 or |
| 91698 | | std.mem.indexOfScalar(abi.Class, classes, .integer) != null) switch (abi_size) { |
| 91699 | | 1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{ |
| 94851 | if (abi_size < 4 or std.mem.indexOfScalar(abi.Class, classes, .integer) != null) switch (abi_size) { |
| 94852 | 1 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91700 | 94853 | .insert = .{ .vp_b, .insr }, |
| 91701 | 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 | 94856 | .insert = .{ .p_b, .insr }, |
| 91704 | 94857 | .extract = .{ .p_b, .extr }, |
| 91705 | | } }, |
| 91706 | | 2 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 94858 | } } else if (cg.hasFeature(.sse2)) .move_through_gpr else .load_store_through_frame, |
| 94859 | 2 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91707 | 94860 | .insert = .{ .vp_w, .insr }, |
| 91708 | 94861 | .extract = .{ .vp_w, .extr }, |
| 91709 | | } } else .{ .insert_extract = .{ |
| 94862 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91710 | 94863 | .insert = .{ .p_w, .insr }, |
| 91711 | 94864 | .extract = .{ .p_w, .extr }, |
| 91712 | | } }, |
| 91713 | | 3...4 => return .{ .move = .{ if (self.hasFeature(.avx)) |
| 94865 | } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{ |
| 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 | 94870 | .v_d |
| 91715 | | else if (self.hasFeature(.sse2)) |
| 94871 | else if (cg.hasFeature(.sse2)) |
| 91716 | 94872 | ._d |
| 91717 | 94873 | else |
| 91718 | 94874 | ._ss, .mov } }, |
| 91719 | | 5...8 => return .{ .move = if (self.hasFeature(.avx)) |
| 94875 | 5...8 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91720 | 94876 | .{ .v_q, .mov } |
| 91721 | | else if (self.hasFeature(.sse2)) |
| 94877 | else if (cg.hasFeature(.sse2)) |
| 91722 | 94878 | .{ ._q, .mov } |
| 91723 | 94879 | else |
| 91724 | 94880 | .{ ._ps, .movl } }, |
| 91725 | | 9...16 => return .{ .move = if (self.hasFeature(.avx)) |
| 94881 | 9...16 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91726 | 94882 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91727 | | else if (self.hasFeature(.sse2)) |
| 94883 | else if (cg.hasFeature(.sse2)) |
| 91728 | 94884 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91729 | 94885 | else |
| 91730 | 94886 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91731 | | 17...32 => if (self.hasFeature(.avx)) |
| 91732 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 94887 | 17...32 => if (cg.hasFeature(.avx)) |
| 94888 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91733 | 94889 | else => {}, |
| 91734 | 94890 | } else switch (abi_size) { |
| 91735 | | 4 => return .{ .move = if (self.hasFeature(.avx)) |
| 94891 | 4 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91736 | 94892 | .{ .v_ss, .mov } |
| 91737 | 94893 | else |
| 91738 | 94894 | .{ ._ss, .mov } }, |
| 91739 | | 5...8 => return .{ .move = if (self.hasFeature(.avx)) |
| 94895 | 5...8 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91740 | 94896 | .{ .v_sd, .mov } |
| 91741 | | else if (self.hasFeature(.sse2)) |
| 94897 | else if (cg.hasFeature(.sse2)) |
| 91742 | 94898 | .{ ._sd, .mov } |
| 91743 | 94899 | else |
| 91744 | 94900 | .{ ._ps, .movl } }, |
| 91745 | | 9...16 => return .{ .move = if (self.hasFeature(.avx)) |
| 94901 | 9...16 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91746 | 94902 | .{ .v_pd, if (aligned) .mova else .movu } |
| 91747 | | else if (self.hasFeature(.sse2)) |
| 94903 | else if (cg.hasFeature(.sse2)) |
| 91748 | 94904 | .{ ._pd, if (aligned) .mova else .movu } |
| 91749 | 94905 | else |
| 91750 | 94906 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91751 | | 17...32 => if (self.hasFeature(.avx)) |
| 91752 | | return .{ .move = .{ .v_pd, if (aligned) .mova else .movu } }, |
| 94907 | 17...32 => if (cg.hasFeature(.avx)) |
| 94908 | return .{ .load_store = .{ .v_pd, if (aligned) .mova else .movu } }, |
| 91753 | 94909 | else => {}, |
| 91754 | 94910 | } |
| 91755 | 94911 | }, |
| 91756 | | .float => switch (ty.floatBits(self.target.*)) { |
| 91757 | | 16 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 94912 | .float => switch (ty.floatBits(cg.target.*)) { |
| 94913 | 16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91758 | 94914 | .insert = .{ .vp_w, .insr }, |
| 91759 | 94915 | .extract = .{ .vp_w, .extr }, |
| 91760 | | } } else .{ .insert_extract = .{ |
| 94916 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91761 | 94917 | .insert = .{ .p_w, .insr }, |
| 91762 | 94918 | .extract = .{ .p_w, .extr }, |
| 91763 | | } }, |
| 91764 | | 32 => return .{ .move = if (self.hasFeature(.avx)) |
| 94919 | } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{ |
| 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 | 94924 | .{ .v_ss, .mov } |
| 91766 | 94925 | else |
| 91767 | 94926 | .{ ._ss, .mov } }, |
| 91768 | | 64 => return .{ .move = if (self.hasFeature(.avx)) |
| 94927 | 64 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91769 | 94928 | .{ .v_sd, .mov } |
| 91770 | | else if (self.hasFeature(.sse2)) |
| 94929 | else if (cg.hasFeature(.sse2)) |
| 91771 | 94930 | .{ ._sd, .mov } |
| 91772 | 94931 | else |
| 91773 | 94932 | .{ ._ps, .movl } }, |
| 91774 | | 128 => return .{ .move = if (self.hasFeature(.avx)) |
| 94933 | 128 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91775 | 94934 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91776 | | else if (self.hasFeature(.sse2)) |
| 94935 | else if (cg.hasFeature(.sse2)) |
| 91777 | 94936 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91778 | 94937 | else |
| 91779 | 94938 | .{ ._ps, if (aligned) .mova else .movu } }, |
| ... | ... | @@ -91781,160 +94940,163 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 91781 | 94940 | }, |
| 91782 | 94941 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { |
| 91783 | 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 | 94944 | .insert = .{ .vp_b, .insr }, |
| 91786 | 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 | 94947 | .insert = .{ .p_b, .insr }, |
| 91789 | 94948 | .extract = .{ .p_b, .extr }, |
| 91790 | | } }, |
| 91791 | | 9...16 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 94949 | } } else if (cg.hasFeature(.sse2)) .move_through_gpr else .load_store_through_frame, |
| 94950 | 9...16 => return if (cg.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 91792 | 94951 | .insert = .{ .vp_w, .insr }, |
| 91793 | 94952 | .extract = .{ .vp_w, .extr }, |
| 91794 | | } } else .{ .insert_extract = .{ |
| 94953 | } } else if (cg.hasFeature(.sse4_1)) .{ .insert_extract = .{ |
| 91795 | 94954 | .insert = .{ .p_w, .insr }, |
| 91796 | 94955 | .extract = .{ .p_w, .extr }, |
| 91797 | | } }, |
| 91798 | | 17...32 => return .{ .move = .{ if (self.hasFeature(.avx)) |
| 94956 | } } else if (cg.hasFeature(.sse2)) .{ .insert_or_extract_through_gpr = .{ |
| 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 | 94961 | .v_d |
| 91800 | | else if (self.hasFeature(.sse2)) |
| 94962 | else if (cg.hasFeature(.sse2)) |
| 91801 | 94963 | ._d |
| 91802 | 94964 | else |
| 91803 | 94965 | ._ss, .mov } }, |
| 91804 | | 33...64 => return .{ .move = if (self.hasFeature(.avx)) |
| 94966 | 33...64 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91805 | 94967 | .{ .v_q, .mov } |
| 91806 | | else if (self.hasFeature(.sse2)) |
| 94968 | else if (cg.hasFeature(.sse2)) |
| 91807 | 94969 | .{ ._q, .mov } |
| 91808 | 94970 | else |
| 91809 | 94971 | .{ ._ps, .movl } }, |
| 91810 | | 65...128 => return .{ .move = if (self.hasFeature(.avx)) |
| 94972 | 65...128 => return .{ .load_store = if (cg.hasFeature(.avx)) |
| 91811 | 94973 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91812 | | else if (self.hasFeature(.sse2)) |
| 94974 | else if (cg.hasFeature(.sse2)) |
| 91813 | 94975 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91814 | 94976 | else |
| 91815 | 94977 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91816 | | 129...256 => if (self.hasFeature(.avx)) |
| 91817 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 94978 | 129...256 => if (cg.hasFeature(.avx)) |
| 94979 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91818 | 94980 | else => {}, |
| 91819 | 94981 | }, |
| 91820 | 94982 | .int => switch (ty.childType(zcu).intInfo(zcu).bits) { |
| 91821 | 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 | 94985 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91824 | | else if (self.hasFeature(.sse2)) |
| 94986 | else if (cg.hasFeature(.sse2)) |
| 91825 | 94987 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91826 | 94988 | else |
| 91827 | 94989 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91828 | | 17...32 => if (self.hasFeature(.avx)) |
| 91829 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 94990 | 17...32 => if (cg.hasFeature(.avx)) |
| 94991 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91830 | 94992 | else => {}, |
| 91831 | 94993 | }, |
| 91832 | 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 | 94996 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91835 | | else if (self.hasFeature(.sse2)) |
| 94997 | else if (cg.hasFeature(.sse2)) |
| 91836 | 94998 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91837 | 94999 | else |
| 91838 | 95000 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91839 | | 9...16 => if (self.hasFeature(.avx)) |
| 91840 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95001 | 9...16 => if (cg.hasFeature(.avx)) |
| 95002 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91841 | 95003 | else => {}, |
| 91842 | 95004 | }, |
| 91843 | 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 | 95007 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91846 | | else if (self.hasFeature(.sse2)) |
| 95008 | else if (cg.hasFeature(.sse2)) |
| 91847 | 95009 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91848 | 95010 | else |
| 91849 | 95011 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91850 | | 5...8 => if (self.hasFeature(.avx)) |
| 91851 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95012 | 5...8 => if (cg.hasFeature(.avx)) |
| 95013 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91852 | 95014 | else => {}, |
| 91853 | 95015 | }, |
| 91854 | 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 | 95018 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91857 | | else if (self.hasFeature(.sse2)) |
| 95019 | else if (cg.hasFeature(.sse2)) |
| 91858 | 95020 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91859 | 95021 | else |
| 91860 | 95022 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91861 | | 3...4 => if (self.hasFeature(.avx)) |
| 91862 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95023 | 3...4 => if (cg.hasFeature(.avx)) |
| 95024 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91863 | 95025 | else => {}, |
| 91864 | 95026 | }, |
| 91865 | 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 | 95029 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91868 | | else if (self.hasFeature(.sse2)) |
| 95030 | else if (cg.hasFeature(.sse2)) |
| 91869 | 95031 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91870 | 95032 | else |
| 91871 | 95033 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91872 | | 2 => if (self.hasFeature(.avx)) |
| 91873 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95034 | 2 => if (cg.hasFeature(.avx)) |
| 95035 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91874 | 95036 | else => {}, |
| 91875 | 95037 | }, |
| 91876 | 95038 | 129...256 => switch (ty.vectorLen(zcu)) { |
| 91877 | | 1 => if (self.hasFeature(.avx)) |
| 91878 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95039 | 1 => if (cg.hasFeature(.avx)) |
| 95040 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91879 | 95041 | else => {}, |
| 91880 | 95042 | }, |
| 91881 | 95043 | else => {}, |
| 91882 | 95044 | }, |
| 91883 | 95045 | .pointer, .optional => if (ty.childType(zcu).isPtrAtRuntime(zcu)) |
| 91884 | 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 | 95048 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91887 | | else if (self.hasFeature(.sse2)) |
| 95049 | else if (cg.hasFeature(.sse2)) |
| 91888 | 95050 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91889 | 95051 | else |
| 91890 | 95052 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91891 | | 3...4 => if (self.hasFeature(.avx)) |
| 91892 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95053 | 3...4 => if (cg.hasFeature(.avx)) |
| 95054 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91893 | 95055 | else => {}, |
| 91894 | 95056 | } |
| 91895 | 95057 | else |
| 91896 | 95058 | unreachable, |
| 91897 | | .float => switch (ty.childType(zcu).floatBits(self.target.*)) { |
| 95059 | .float => switch (ty.childType(zcu).floatBits(cg.target.*)) { |
| 91898 | 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 | 95062 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91901 | | else if (self.hasFeature(.sse2)) |
| 95063 | else if (cg.hasFeature(.sse2)) |
| 91902 | 95064 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91903 | 95065 | else |
| 91904 | 95066 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91905 | | 9...16 => if (self.hasFeature(.avx)) |
| 91906 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95067 | 9...16 => if (cg.hasFeature(.avx)) |
| 95068 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91907 | 95069 | else => {}, |
| 91908 | 95070 | }, |
| 91909 | 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 | 95073 | .{ .v_ps, if (aligned) .mova else .movu } |
| 91912 | 95074 | else |
| 91913 | 95075 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91914 | | 5...8 => if (self.hasFeature(.avx)) |
| 91915 | | return .{ .move = .{ .v_ps, if (aligned) .mova else .movu } }, |
| 95076 | 5...8 => if (cg.hasFeature(.avx)) |
| 95077 | return .{ .load_store = .{ .v_ps, if (aligned) .mova else .movu } }, |
| 91916 | 95078 | else => {}, |
| 91917 | 95079 | }, |
| 91918 | 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 | 95082 | .{ .v_pd, if (aligned) .mova else .movu } |
| 91921 | | else if (self.hasFeature(.sse2)) |
| 95083 | else if (cg.hasFeature(.sse2)) |
| 91922 | 95084 | .{ ._pd, if (aligned) .mova else .movu } |
| 91923 | 95085 | else |
| 91924 | 95086 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91925 | | 3...4 => if (self.hasFeature(.avx)) |
| 91926 | | return .{ .move = .{ .v_pd, if (aligned) .mova else .movu } }, |
| 95087 | 3...4 => if (cg.hasFeature(.avx)) |
| 95088 | return .{ .load_store = .{ .v_pd, if (aligned) .mova else .movu } }, |
| 91927 | 95089 | else => {}, |
| 91928 | 95090 | }, |
| 91929 | 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 | 95093 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 91932 | | else if (self.hasFeature(.sse2)) |
| 95094 | else if (cg.hasFeature(.sse2)) |
| 91933 | 95095 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 91934 | 95096 | else |
| 91935 | 95097 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 91936 | | 2 => if (self.hasFeature(.avx)) |
| 91937 | | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 95098 | 2 => if (cg.hasFeature(.avx)) |
| 95099 | return .{ .load_store = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 91938 | 95100 | else => {}, |
| 91939 | 95101 | }, |
| 91940 | 95102 | else => {}, |
| ... | ... | @@ -91944,7 +95106,7 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 91944 | 95106 | }, |
| 91945 | 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 | 95112 | const CopyOptions = struct { |
| ... | ... | @@ -92332,7 +95494,7 @@ fn genSetReg( |
| 92332 | 95494 | .size = 16, |
| 92333 | 95495 | .alignment = .@"16", |
| 92334 | 95496 | })); |
| 92335 | | try MoveStrategy.write(.x87_load_store, self, .{ |
| 95497 | try MoveStrategy.write(.load_store_x87, self, .{ |
| 92336 | 95498 | .base = .{ .frame = frame_index }, |
| 92337 | 95499 | .mod = .{ .rm = .{ .size = .tbyte } }, |
| 92338 | 95500 | }, src_reg); |
| ... | ... | @@ -92430,7 +95592,7 @@ fn genSetReg( |
| 92430 | 95592 | => try @as(MoveStrategy, switch (src_mcv) { |
| 92431 | 95593 | .register_offset => |reg_off| switch (reg_off.off) { |
| 92432 | 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 | 95597 | .indirect => try self.moveStrategy(ty, dst_reg.class(), false), |
| 92436 | 95598 | .load_frame => |frame_addr| try self.moveStrategy( |
| ... | ... | @@ -92440,7 +95602,7 @@ fn genSetReg( |
| 92440 | 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 | 95606 | else => unreachable, |
| 92445 | 95607 | }).read(self, dst_alias, switch (src_mcv) { |
| 92446 | 95608 | .register_offset, .indirect => |reg_off| .{ |
| ... | ... | @@ -100903,7 +104065,10 @@ const Select = struct { |
| 100903 | 104065 | f64_0x1p52_0x1p84_mem, |
| 100904 | 104066 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, |
| 100905 | 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 | 104072 | frame: FrameIndex, |
| 100908 | 104073 | lazy_symbol: struct { kind: link.File.LazySymbol.Kind, ref: Select.Operand.Ref = .none }, |
| 100909 | 104074 | symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 }, |
| ... | ... | @@ -101115,10 +104280,13 @@ const Select = struct { |
| 101115 | 104280 | (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(), |
| 101116 | 104281 | } }, |
| 101117 | 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 | 104287 | var bytes: [16]u8 = @splat(1 << 7); |
| 101120 | | const from_bytes: u32 = @intCast(@divExact(const_spec.from.bitSize(cg.target), 8)); |
| 101121 | | const to_bytes: u32 = @intCast(@divExact(const_spec.to.bitSize(cg.target), 8)); |
| 104288 | const from_bytes: u32 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8)); |
| 104289 | const to_bytes: u32 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8)); |
| 101122 | 104290 | var from_index: u32 = 0; |
| 101123 | 104291 | var to_index: u32 = 0; |
| 101124 | 104292 | while (from_index < bytes.len) { |
| ... | ... | @@ -101126,10 +104294,43 @@ const Select = struct { |
| 101126 | 104294 | from_index += from_bytes; |
| 101127 | 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 | 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 | 104331 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| 101131 | | .ty = (try pt.vectorType(.{ .len = bytes.len, .child = .u8_type })).toIntern(), |
| 101132 | | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, &bytes, .maybe_embedded_nulls) }, |
| 104332 | .ty = spec.type.toIntern(), |
| 104333 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| 101133 | 104334 | } }))), true }; |
| 101134 | 104335 | }, |
| 101135 | 104336 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, |
| ... | ... | @@ -102013,9 +105214,10 @@ const Select = struct { |
| 102013 | 105214 | .div_8_down => lhs >> 3 & @as(SignedImm, -1) << rhs, |
| 102014 | 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 | 105218 | return switch (op.flags.adjust.sign) { |
| 102017 | | .neg => op.imm - op_res, |
| 102018 | | .pos => op.imm + op_res, |
| 105219 | .neg => disp - 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