| ... | @@ -148,8 +148,11 @@ const Owner = union(enum) { | ... | @@ -148,8 +148,11 @@ const Owner = union(enum) { |
| 148 | } | 148 | } |
| 149 | }; | 149 | }; |
| 150 | | 150 | |
| 151 | const MaskKind = enum(u1) { sign, all }; | 151 | const MaskInfo = packed struct { |
| 152 | const MaskInfo = packed struct { kind: MaskKind, inverted: bool = false, scalar: Memory.Size }; | 152 | kind: enum(u1) { sign, all }, |
| | 153 | inverted: bool = false, |
| | 154 | scalar: Memory.Size, |
| | 155 | }; |
| 153 | | 156 | |
| 154 | pub const MCValue = union(enum) { | 157 | pub const MCValue = union(enum) { |
| 155 | /// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc. | 158 | /// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc. |
| ... | @@ -2386,7 +2389,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2386,7 +2389,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2386 | } | 2389 | } |
| 2387 | | 2390 | |
| 2388 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2391 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2389 | @setEvalBranchQuota(20_200); | 2392 | @setEvalBranchQuota(22_000); |
| 2390 | const pt = cg.pt; | 2393 | const pt = cg.pt; |
| 2391 | const zcu = pt.zcu; | 2394 | const zcu = pt.zcu; |
| 2392 | const ip = &zcu.intern_pool; | 2395 | const ip = &zcu.intern_pool; |
| ... | @@ -2424,7 +2427,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2424,7 +2427,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2424 | // zig fmt: off | 2427 | // zig fmt: off |
| 2425 | .select => try cg.airSelect(inst), | 2428 | .select => try cg.airSelect(inst), |
| 2426 | .shuffle => try cg.airShuffle(inst), | 2429 | .shuffle => try cg.airShuffle(inst), |
| 2427 | .reduce => try cg.airReduce(inst), | | |
| 2428 | .reduce_optimized => try cg.airReduce(inst), | 2430 | .reduce_optimized => try cg.airReduce(inst), |
| 2429 | // zig fmt: on | 2431 | // zig fmt: on |
| 2430 | | 2432 | |
| ... | @@ -63335,20 +63337,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -63335,20 +63337,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 63335 | .bitcast => try cg.airBitCast(inst), | 63337 | .bitcast => try cg.airBitCast(inst), |
| 63336 | .block => { | 63338 | .block => { |
| 63337 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 63339 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 63338 | const extra = cg.air.extraData(Air.Block, ty_pl.payload); | 63340 | const block = cg.air.extraData(Air.Block, ty_pl.payload); |
| 63339 | if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_enter_block_none); | 63341 | if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_enter_block_none); |
| 63340 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); | 63342 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[block.end..][0..block.data.body_len])); |
| 63341 | if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_leave_block_none); | 63343 | if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_leave_block_none); |
| 63342 | }, | 63344 | }, |
| 63343 | .loop => if (use_old) try cg.airLoop(inst) else { | 63345 | .loop => if (use_old) try cg.airLoop(inst) else { |
| 63344 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 63346 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 63345 | const extra = cg.air.extraData(Air.Block, ty_pl.payload); | 63347 | const block = cg.air.extraData(Air.Block, ty_pl.payload); |
| 63346 | try cg.loops.putNoClobber(cg.gpa, inst, .{ | 63348 | try cg.loops.putNoClobber(cg.gpa, inst, .{ |
| 63347 | .state = try cg.saveState(), | 63349 | .state = try cg.saveState(), |
| 63348 | .target = @intCast(cg.mir_instructions.len), | 63350 | .target = @intCast(cg.mir_instructions.len), |
| 63349 | }); | 63351 | }); |
| 63350 | defer assert(cg.loops.remove(inst)); | 63352 | defer assert(cg.loops.remove(inst)); |
| 63351 | try cg.genBodyBlock(@ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); | 63353 | try cg.genBodyBlock(@ptrCast(cg.air.extra[block.end..][0..block.data.body_len])); |
| 63352 | }, | 63354 | }, |
| 63353 | .repeat => if (use_old) try cg.airRepeat(inst) else { | 63355 | .repeat => if (use_old) try cg.airRepeat(inst) else { |
| 63354 | const repeat = air_datas[@intFromEnum(inst)].repeat; | 63356 | const repeat = air_datas[@intFromEnum(inst)].repeat; |
| ... | @@ -77295,15 +77297,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -77295,15 +77297,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 77295 | }, | 77297 | }, |
| 77296 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { | 77298 | .cmp_vector, .cmp_vector_optimized => |air_tag| if (use_old) try cg.airCmpVector(inst) else fallback: { |
| 77297 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 77299 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 77298 | const extra = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; | 77300 | const vector_cmp = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; |
| 77299 | switch (extra.compareOperator()) { | 77301 | switch (vector_cmp.compareOperator()) { |
| 77300 | .eq, .neq => {}, | 77302 | .eq, .neq => {}, |
| 77301 | .lt, .lte, .gte, .gt => if (cg.floatBits(cg.typeOf(extra.lhs).childType(zcu)) == null) | 77303 | .lt, .lte, .gte, .gt => if (cg.floatBits(cg.typeOf(vector_cmp.lhs).childType(zcu)) == null) |
| 77302 | break :fallback try cg.airCmpVector(inst), | 77304 | break :fallback try cg.airCmpVector(inst), |
| 77303 | } | 77305 | } |
| 77304 | var ops = try cg.tempsFromOperands(inst, .{ extra.lhs, extra.rhs }); | 77306 | var ops = try cg.tempsFromOperands(inst, .{ vector_cmp.lhs, vector_cmp.rhs }); |
| 77305 | var res: [1]Temp = undefined; | 77307 | var res: [1]Temp = undefined; |
| 77306 | (err: switch (extra.compareOperator()) { | 77308 | (err: switch (vector_cmp.compareOperator()) { |
| 77307 | .lt, .lte, .gte, .gt => |cmp_op| { | 77309 | .lt, .lte, .gte, .gt => |cmp_op| { |
| 77308 | switch (cmp_op) { | 77310 | switch (cmp_op) { |
| 77309 | else => unreachable, | 77311 | else => unreachable, |
| ... | @@ -84350,14 +84352,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -84350,14 +84352,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 84350 | }) catch |err| switch (err) { | 84352 | }) catch |err| switch (err) { |
| 84351 | error.SelectFailed => return cg.fail("failed to select {s} {s} {} {} {}", .{ | 84353 | error.SelectFailed => return cg.fail("failed to select {s} {s} {} {} {}", .{ |
| 84352 | @tagName(air_tag), | 84354 | @tagName(air_tag), |
| 84353 | @tagName(extra.compareOperator()), | 84355 | @tagName(vector_cmp.compareOperator()), |
| 84354 | cg.typeOf(extra.lhs).fmt(pt), | 84356 | cg.typeOf(vector_cmp.lhs).fmt(pt), |
| 84355 | ops[0].tracking(cg), | 84357 | ops[0].tracking(cg), |
| 84356 | ops[1].tracking(cg), | 84358 | ops[1].tracking(cg), |
| 84357 | }), | 84359 | }), |
| 84358 | else => |e| return e, | 84360 | else => |e| return e, |
| 84359 | }; | 84361 | }; |
| 84360 | try res[0].finish(inst, &.{ extra.lhs, extra.rhs }, &ops, cg); | 84362 | try res[0].finish(inst, &.{ vector_cmp.lhs, vector_cmp.rhs }, &ops, cg); |
| 84361 | }, | 84363 | }, |
| 84362 | .cond_br => try cg.airCondBr(inst), | 84364 | .cond_br => try cg.airCondBr(inst), |
| 84363 | .switch_br => try cg.airSwitchBr(inst), | 84365 | .switch_br => try cg.airSwitchBr(inst), |
| ... | @@ -84386,16 +84388,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -84386,16 +84388,16 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 84386 | }, | 84388 | }, |
| 84387 | .dbg_inline_block => { | 84389 | .dbg_inline_block => { |
| 84388 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 84390 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 84389 | const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); | 84391 | const dbg_inline_block = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); |
| 84390 | const old_inline_func = cg.inline_func; | 84392 | const old_inline_func = cg.inline_func; |
| 84391 | defer cg.inline_func = old_inline_func; | 84393 | defer cg.inline_func = old_inline_func; |
| 84392 | cg.inline_func = extra.data.func; | 84394 | cg.inline_func = dbg_inline_block.data.func; |
| 84393 | if (cg.debug_output != .none) _ = try cg.addInst(.{ | 84395 | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 84394 | .tag = .pseudo, | 84396 | .tag = .pseudo, |
| 84395 | .ops = .pseudo_dbg_enter_inline_func, | 84397 | .ops = .pseudo_dbg_enter_inline_func, |
| 84396 | .data = .{ .func = extra.data.func }, | 84398 | .data = .{ .func = dbg_inline_block.data.func }, |
| 84397 | }); | 84399 | }); |
| 84398 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); | 84400 | try cg.lowerBlock(inst, @ptrCast(cg.air.extra[dbg_inline_block.end..][0..dbg_inline_block.data.body_len])); |
| 84399 | if (cg.debug_output != .none) _ = try cg.addInst(.{ | 84401 | if (cg.debug_output != .none) _ = try cg.addInst(.{ |
| 84400 | .tag = .pseudo, | 84402 | .tag = .pseudo, |
| 84401 | .ops = .pseudo_dbg_leave_inline_func, | 84403 | .ops = .pseudo_dbg_leave_inline_func, |
| ... | @@ -97931,14 +97933,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -97931,14 +97933,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 97931 | }, | 97933 | }, |
| 97932 | .struct_field_ptr => if (use_old) try cg.airStructFieldPtr(inst) else { | 97934 | .struct_field_ptr => if (use_old) try cg.airStructFieldPtr(inst) else { |
| 97933 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 97935 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 97934 | const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; | 97936 | const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; |
| 97935 | var ops = try cg.tempsFromOperands(inst, .{extra.struct_operand}); | 97937 | var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand}); |
| 97936 | try ops[0].toOffset(cg.fieldOffset( | 97938 | try ops[0].toOffset(cg.fieldOffset( |
| 97937 | cg.typeOf(extra.struct_operand), | 97939 | cg.typeOf(struct_field.struct_operand), |
| 97938 | ty_pl.ty.toType(), | 97940 | ty_pl.ty.toType(), |
| 97939 | extra.field_index, | 97941 | struct_field.field_index, |
| 97940 | ), cg); | 97942 | ), cg); |
| 97941 | try ops[0].finish(inst, &.{extra.struct_operand}, &ops, cg); | 97943 | try ops[0].finish(inst, &.{struct_field.struct_operand}, &ops, cg); |
| 97942 | }, | 97944 | }, |
| 97943 | .struct_field_ptr_index_0, | 97945 | .struct_field_ptr_index_0, |
| 97944 | .struct_field_ptr_index_1, | 97946 | .struct_field_ptr_index_1, |
| ... | @@ -97968,19 +97970,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -97968,19 +97970,19 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 97968 | }, | 97970 | }, |
| 97969 | .struct_field_val => if (use_old) try cg.airStructFieldVal(inst) else fallback: { | 97971 | .struct_field_val => if (use_old) try cg.airStructFieldVal(inst) else fallback: { |
| 97970 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 97972 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 97971 | const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; | 97973 | const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; |
| 97972 | const agg_ty = cg.typeOf(extra.struct_operand); | 97974 | const agg_ty = cg.typeOf(struct_field.struct_operand); |
| 97973 | const field_ty = ty_pl.ty.toType(); | 97975 | const field_ty = ty_pl.ty.toType(); |
| 97974 | const field_off: u31 = switch (agg_ty.containerLayout(zcu)) { | 97976 | const field_off: u31 = switch (agg_ty.containerLayout(zcu)) { |
| 97975 | .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(extra.field_index, zcu)), | 97977 | .auto, .@"extern" => @intCast(agg_ty.structFieldOffset(struct_field.field_index, zcu)), |
| 97976 | .@"packed" => break :fallback try cg.airStructFieldVal(inst), | 97978 | .@"packed" => break :fallback try cg.airStructFieldVal(inst), |
| 97977 | }; | 97979 | }; |
| 97978 | var ops = try cg.tempsFromOperands(inst, .{extra.struct_operand}); | 97980 | var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand}); |
| 97979 | var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBitsIgnoreComptime(zcu)) | 97981 | var res = if (!hack_around_sema_opv_bugs or field_ty.hasRuntimeBitsIgnoreComptime(zcu)) |
| 97980 | try ops[0].read(field_ty, .{ .disp = field_off }, cg) | 97982 | try ops[0].read(field_ty, .{ .disp = field_off }, cg) |
| 97981 | else | 97983 | else |
| 97982 | try cg.tempInit(field_ty, .none); | 97984 | try cg.tempInit(field_ty, .none); |
| 97983 | try res.finish(inst, &.{extra.struct_operand}, &ops, cg); | 97985 | try res.finish(inst, &.{struct_field.struct_operand}, &ops, cg); |
| 97984 | }, | 97986 | }, |
| 97985 | .set_union_tag => if (use_old) try cg.airSetUnionTag(inst) else { | 97987 | .set_union_tag => if (use_old) try cg.airSetUnionTag(inst) else { |
| 97986 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 97988 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| ... | @@ -116829,1028 +116831,6485 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -116829,1028 +116831,6485 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 116829 | }; | 116831 | }; |
| 116830 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 116832 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 116831 | }, | 116833 | }, |
| 116832 | | 116834 | .reduce => |air_tag| if (use_old) try cg.airReduce(inst) else fallback: { |
| 116833 | .splat => |air_tag| if (use_old) try cg.airSplat(inst) else fallback: { | 116835 | const reduce = air_datas[@intFromEnum(inst)].reduce; |
| 116834 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; | 116836 | const ty = cg.typeOfIndex(inst); |
| 116835 | if (cg.typeOf(ty_op.operand).toIntern() == .bool_type) break :fallback try cg.airSplat(inst); | 116837 | switch (reduce.operation) { |
| 116836 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); | 116838 | .And, .Or, .Xor => {}, |
| | 116839 | .Min, .Max, .Add, .Mul => break :fallback try cg.airReduce(inst), |
| | 116840 | } |
| | 116841 | var ops = try cg.tempsFromOperands(inst, .{reduce.operand}); |
| 116837 | var res: [1]Temp = undefined; | 116842 | var res: [1]Temp = undefined; |
| 116838 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 116843 | cg.select(&res, &.{ty}, &ops, switch (reduce.operation) { |
| 116839 | .required_features = .{ .avx2, null, null, null }, | 116844 | .And, .Or, .Xor => switch (@as(Mir.Inst.Tag, switch (reduce.operation) { |
| 116840 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 116845 | else => unreachable, |
| 116841 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116846 | .And => .@"and", |
| 116842 | .patterns = &.{ | 116847 | .Or => .@"or", |
| 116843 | .{ .src = .{ .mem, .none, .none } }, | 116848 | .Xor => .xor, |
| 116844 | .{ .src = .{ .to_sse, .none, .none } }, | 116849 | })) { |
| 116845 | }, | 116850 | else => unreachable, |
| 116846 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 116851 | inline .@"and", .@"or", .xor => |mir_tag| comptime &switch (mir_tag) { |
| 116847 | .each = .{ .once = &.{ | 116852 | else => unreachable, |
| 116848 | .{ ._, .vp_b, .broadcast, .dst0x, .src0b, ._, ._ }, | 116853 | .@"and" => [_]Select.Case{ .{ |
| 116849 | } }, | 116854 | .required_features = .{ .avx, null, null, null }, |
| 116850 | }, .{ | 116855 | .dst_constraints = .{ .bool, .any }, |
| 116851 | .required_features = .{ .avx, null, null, null }, | 116856 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116852 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 116857 | .patterns = &.{ |
| 116853 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116858 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .inverted } }, .none, .none } }, |
| 116854 | .patterns = &.{ | 116859 | }, |
| 116855 | .{ .src = .{ .to_sse, .none, .none } }, | 116860 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 116856 | }, | 116861 | .clobbers = .{ .eflags = true }, |
| 116857 | .extra_temps = .{ | 116862 | .each = .{ .once = &.{ |
| 116858 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 116863 | .{ ._, .vp_, .@"test", .src0x, .src0x, ._, ._ }, |
| 116859 | .unused, | 116864 | } }, |
| 116860 | .unused, | 116865 | }, .{ |
| 116861 | .unused, | 116866 | .required_features = .{ .sse4_1, null, null, null }, |
| 116862 | .unused, | 116867 | .dst_constraints = .{ .bool, .any }, |
| 116863 | .unused, | 116868 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116864 | .unused, | 116869 | .patterns = &.{ |
| 116865 | .unused, | 116870 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .inverted } }, .none, .none } }, |
| 116866 | .unused, | 116871 | }, |
| 116867 | .unused, | 116872 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 116868 | .unused, | 116873 | .clobbers = .{ .eflags = true }, |
| 116869 | }, | 116874 | .each = .{ .once = &.{ |
| 116870 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 116875 | .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ }, |
| 116871 | .each = .{ .once = &.{ | 116876 | } }, |
| 116872 | .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ }, | 116877 | }, .{ |
| 116873 | .{ ._, .vp_b, .shuf, .dst0x, .src0x, .tmp0x, ._ }, | 116878 | .required_features = .{ .avx, null, null, null }, |
| 116874 | } }, | 116879 | .dst_constraints = .{ .bool, .any }, |
| 116875 | }, .{ | 116880 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116876 | .required_features = .{ .ssse3, null, null, null }, | 116881 | .patterns = &.{ |
| 116877 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 116882 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 116878 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116883 | }, |
| 116879 | .patterns = &.{ | 116884 | .extra_temps = .{ |
| 116880 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 116885 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 116881 | }, | 116886 | .unused, |
| 116882 | .extra_temps = .{ | 116887 | .unused, |
| 116883 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 116888 | .unused, |
| 116884 | .unused, | 116889 | .unused, |
| 116885 | .unused, | 116890 | .unused, |
| 116886 | .unused, | 116891 | .unused, |
| 116887 | .unused, | 116892 | .unused, |
| 116888 | .unused, | 116893 | .unused, |
| 116889 | .unused, | 116894 | .unused, |
| 116890 | .unused, | 116895 | .unused, |
| 116891 | .unused, | 116896 | }, |
| 116892 | .unused, | 116897 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 116893 | .unused, | 116898 | .clobbers = .{ .eflags = true }, |
| 116894 | }, | 116899 | .each = .{ .once = &.{ |
| 116895 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 116900 | .{ ._, .vp_b, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ }, |
| 116896 | .each = .{ .once = &.{ | 116901 | .{ ._, .vp_, .@"test", .src0x, .tmp0x, ._, ._ }, |
| 116897 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 116902 | } }, |
| 116898 | .{ ._, .p_b, .shuf, .dst0x, .tmp0x, ._, ._ }, | 116903 | }, .{ |
| 116899 | } }, | 116904 | .required_features = .{ .sse4_1, null, null, null }, |
| 116900 | }, .{ | 116905 | .dst_constraints = .{ .bool, .any }, |
| 116901 | .required_features = .{ .sse2, null, null, null }, | 116906 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116902 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 116907 | .patterns = &.{ |
| 116903 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116908 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 116904 | .patterns = &.{ | 116909 | }, |
| 116905 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 116910 | .extra_temps = .{ |
| 116906 | }, | 116911 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 116907 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 116912 | .unused, |
| 116908 | .each = .{ .once = &.{ | 116913 | .unused, |
| 116909 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, | 116914 | .unused, |
| 116910 | .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 116915 | .unused, |
| 116911 | .{ ._, .p_d, .shuf, .dst0x, .dst0x, .ui(0b00_00_00_00), ._ }, | 116916 | .unused, |
| 116912 | } }, | 116917 | .unused, |
| 116913 | }, .{ | 116918 | .unused, |
| 116914 | .required_features = .{ .avx2, null, null, null }, | 116919 | .unused, |
| 116915 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any }, | 116920 | .unused, |
| 116916 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116921 | .unused, |
| 116917 | .patterns = &.{ | 116922 | }, |
| 116918 | .{ .src = .{ .mem, .none, .none } }, | 116923 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 116919 | .{ .src = .{ .to_sse, .none, .none } }, | 116924 | .clobbers = .{ .eflags = true }, |
| 116920 | }, | 116925 | .each = .{ .once = &.{ |
| 116921 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 116926 | .{ ._, .p_b, .cmpeq, .tmp0x, .tmp0x, ._, ._ }, |
| 116922 | .each = .{ .once = &.{ | 116927 | .{ ._, .p_, .@"test", .src0x, .tmp0x, ._, ._ }, |
| 116923 | .{ ._, .vp_b, .broadcast, .dst0y, .src0b, ._, ._ }, | 116928 | } }, |
| 116924 | } }, | 116929 | }, .{ |
| 116925 | }, .{ | 116930 | .required_features = .{ .avx, null, null, null }, |
| 116926 | .required_features = .{ .avx2, null, null, null }, | 116931 | .dst_constraints = .{ .bool, .any }, |
| 116927 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any }, | 116932 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116928 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116933 | .patterns = &.{ |
| 116929 | .patterns = &.{ | 116934 | .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 116930 | .{ .src = .{ .mem, .none, .none } }, | 116935 | }, |
| 116931 | .{ .src = .{ .to_sse, .none, .none } }, | 116936 | .extra_temps = .{ |
| 116932 | }, | 116937 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 116933 | .extra_temps = .{ | 116938 | .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } }, |
| 116934 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 116939 | .unused, |
| 116935 | .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 116940 | .unused, |
| 116936 | .unused, | 116941 | .unused, |
| 116937 | .unused, | 116942 | .unused, |
| 116938 | .unused, | 116943 | .unused, |
| 116939 | .unused, | 116944 | .unused, |
| 116940 | .unused, | 116945 | .unused, |
| 116941 | .unused, | 116946 | .unused, |
| 116942 | .unused, | 116947 | .unused, |
| 116943 | .unused, | 116948 | }, |
| 116944 | .unused, | 116949 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 116945 | }, | 116950 | .clobbers = .{ .eflags = true }, |
| 116946 | .dst_temps = .{ .mem, .unused }, | 116951 | .each = .{ .once = &.{ |
| 116947 | .each = .{ .once = &.{ | 116952 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 116948 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, | 116953 | .{ ._, .vp_, .@"test", .src0x, .lea(.tmp0x), ._, ._ }, |
| 116949 | .{ ._, .vp_b, .broadcast, .tmp1y, .src0b, ._, ._ }, | 116954 | } }, |
| 116950 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, | 116955 | }, .{ |
| 116951 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, | 116956 | .required_features = .{ .sse4_1, null, null, null }, |
| 116952 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 116957 | .dst_constraints = .{ .bool, .any }, |
| 116953 | } }, | 116958 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116954 | }, .{ | 116959 | .patterns = &.{ |
| 116955 | .required_features = .{ .avx, null, null, null }, | 116960 | .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 116956 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 116961 | }, |
| 116957 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116962 | .extra_temps = .{ |
| 116958 | .patterns = &.{ | 116963 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 116959 | .{ .src = .{ .to_sse, .none, .none } }, | 116964 | .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } }, |
| 116960 | }, | 116965 | .unused, |
| 116961 | .extra_temps = .{ | 116966 | .unused, |
| 116962 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 116967 | .unused, |
| 116963 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 116968 | .unused, |
| 116964 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 116969 | .unused, |
| 116965 | .unused, | 116970 | .unused, |
| 116966 | .unused, | 116971 | .unused, |
| 116967 | .unused, | 116972 | .unused, |
| 116968 | .unused, | 116973 | .unused, |
| 116969 | .unused, | 116974 | }, |
| 116970 | .unused, | 116975 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 116971 | .unused, | 116976 | .clobbers = .{ .eflags = true }, |
| 116972 | .unused, | 116977 | .each = .{ .once = &.{ |
| 116973 | }, | 116978 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 116974 | .dst_temps = .{ .mem, .unused }, | 116979 | .{ ._, .p_, .@"test", .src0x, .lea(.tmp0x), ._, ._ }, |
| 116975 | .each = .{ .once = &.{ | 116980 | } }, |
| 116976 | .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ }, | 116981 | }, .{ |
| 116977 | .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_size), ._, ._ }, | 116982 | .required_features = .{ .avx2, null, null, null }, |
| 116978 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .tmp0x, ._ }, | 116983 | .dst_constraints = .{ .bool, .any }, |
| 116979 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp2x, ._, ._ }, | 116984 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116980 | .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, | 116985 | .patterns = &.{ |
| 116981 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 116986 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .inverted } }, .none, .none } }, |
| 116982 | } }, | 116987 | }, |
| 116983 | }, .{ | 116988 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 116984 | .required_features = .{ .ssse3, null, null, null }, | 116989 | .clobbers = .{ .eflags = true }, |
| 116985 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 116990 | .each = .{ .once = &.{ |
| 116986 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 116991 | .{ ._, .vp_, .@"test", .src0y, .src0y, ._, ._ }, |
| 116987 | .patterns = &.{ | 116992 | } }, |
| 116988 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 116993 | }, .{ |
| 116989 | }, | 116994 | .required_features = .{ .avx, null, null, null }, |
| 116990 | .extra_temps = .{ | 116995 | .dst_constraints = .{ .bool, .any }, |
| 116991 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, | 116996 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 116992 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 116997 | .patterns = &.{ |
| 116993 | .unused, | 116998 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .inverted } }, .none, .none } }, |
| 116994 | .unused, | 116999 | }, |
| 116995 | .unused, | 117000 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 116996 | .unused, | 117001 | .clobbers = .{ .eflags = true }, |
| 116997 | .unused, | 117002 | .each = .{ .once = &.{ |
| 116998 | .unused, | 117003 | .{ ._, .v_ps, .@"test", .src0y, .src0y, ._, ._ }, |
| 116999 | .unused, | 117004 | } }, |
| 117000 | .unused, | 117005 | }, .{ |
| 117001 | .unused, | 117006 | .required_features = .{ .avx2, null, null, null }, |
| 117002 | }, | 117007 | .dst_constraints = .{ .bool, .any }, |
| 117003 | .dst_temps = .{ .mem, .unused }, | 117008 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117004 | .each = .{ .once = &.{ | 117009 | .patterns = &.{ |
| 117005 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, | 117010 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, |
| 117006 | .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117011 | }, |
| 117007 | .{ ._, .p_b, .shuf, .src0x, .tmp0x, ._, ._ }, | 117012 | .extra_temps = .{ |
| 117008 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp1), .src0x, ._, ._ }, | 117013 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 117009 | .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, | 117014 | .unused, |
| 117010 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117015 | .unused, |
| 117011 | } }, | 117016 | .unused, |
| 117012 | }, .{ | 117017 | .unused, |
| 117013 | .required_features = .{ .sse2, null, null, null }, | 117018 | .unused, |
| 117014 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, | 117019 | .unused, |
| 117015 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 117020 | .unused, |
| 117016 | .patterns = &.{ | 117021 | .unused, |
| 117017 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117022 | .unused, |
| 117018 | }, | 117023 | .unused, |
| 117019 | .extra_temps = .{ | 117024 | }, |
| 117020 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117025 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 117021 | .unused, | 117026 | .clobbers = .{ .eflags = true }, |
| 117022 | .unused, | 117027 | .each = .{ .once = &.{ |
| 117023 | .unused, | 117028 | .{ ._, .vp_b, .cmpeq, .tmp0y, .tmp0y, .tmp0y, ._ }, |
| 117024 | .unused, | 117029 | .{ ._, .vp_, .@"test", .src0y, .tmp0y, ._, ._ }, |
| 117025 | .unused, | 117030 | } }, |
| 117026 | .unused, | 117031 | }, .{ |
| 117027 | .unused, | 117032 | .required_features = .{ .avx, null, null, null }, |
| 117028 | .unused, | 117033 | .dst_constraints = .{ .bool, .any }, |
| 117029 | .unused, | 117034 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117030 | .unused, | 117035 | .patterns = &.{ |
| 117031 | }, | 117036 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, |
| 117032 | .dst_temps = .{ .mem, .unused }, | 117037 | }, |
| 117033 | .each = .{ .once = &.{ | 117038 | .extra_temps = .{ |
| 117034 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, | 117039 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 117035 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117040 | .unused, |
| 117036 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117041 | .unused, |
| 117037 | .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117042 | .unused, |
| 117038 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, | 117043 | .unused, |
| 117039 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117044 | .unused, |
| 117040 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117045 | .unused, |
| 117041 | } }, | 117046 | .unused, |
| 117042 | }, .{ | 117047 | .unused, |
| 117043 | .required_features = .{ .slow_incdec, null, null, null }, | 117048 | .unused, |
| 117044 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 117049 | .unused, |
| 117045 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 117050 | }, |
| 117046 | .patterns = &.{ | 117051 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 117047 | .{ .src = .{ .to_gpr, .none, .none } }, | 117052 | .clobbers = .{ .eflags = true }, |
| 117048 | }, | 117053 | .each = .{ .once = &.{ |
| 117049 | .extra_temps = .{ | 117054 | .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.true) }, |
| 117050 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117055 | .{ ._, .v_ps, .@"test", .src0y, .tmp0y, ._, ._ }, |
| 117051 | .unused, | 117056 | } }, |
| 117052 | .unused, | 117057 | }, .{ |
| 117053 | .unused, | 117058 | .required_features = .{ .avx, null, null, null }, |
| 117054 | .unused, | 117059 | .dst_constraints = .{ .bool, .any }, |
| 117055 | .unused, | 117060 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117056 | .unused, | 117061 | .patterns = &.{ |
| 117057 | .unused, | 117062 | .{ .src = .{ .{ .reg_mask = .{ .size = .yword } }, .none, .none } }, |
| 117058 | .unused, | 117063 | }, |
| 117059 | .unused, | 117064 | .extra_temps = .{ |
| 117060 | .unused, | 117065 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 117061 | }, | 117066 | .{ .type = .vector_32_u8, .kind = .{ .ptest_mask_mem = .src0 } }, |
| 117062 | .dst_temps = .{ .mem, .unused }, | 117067 | .unused, |
| 117063 | .each = .{ .once = &.{ | 117068 | .unused, |
| 117064 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_size), ._, ._ }, | 117069 | .unused, |
| 117065 | .{ .@"0:", ._, .mov, .memi(.dst0b, .tmp0), .src0b, ._, ._ }, | 117070 | .unused, |
| 117066 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, | 117071 | .unused, |
| 117067 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117072 | .unused, |
| 117068 | } }, | 117073 | .unused, |
| 117069 | }, .{ | 117074 | .unused, |
| 117070 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, | 117075 | .unused, |
| 117071 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, | 117076 | }, |
| 117072 | .patterns = &.{ | 117077 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .all = 1 } }, .unused }, |
| 117073 | .{ .src = .{ .to_gpr, .none, .none } }, | 117078 | .clobbers = .{ .eflags = true }, |
| 117074 | }, | 117079 | .each = .{ .once = &.{ |
| 117075 | .extra_temps = .{ | 117080 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 117076 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117081 | .{ ._, .vp_, .@"test", .src0y, .lea(.tmp0y), ._, ._ }, |
| 117077 | .unused, | 117082 | } }, |
| 117078 | .unused, | 117083 | }, .{ |
| 117079 | .unused, | 117084 | .dst_constraints = .{ .bool, .any }, |
| 117080 | .unused, | 117085 | .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any }, |
| 117081 | .unused, | 117086 | .patterns = &.{ |
| 117082 | .unused, | 117087 | .{ .src = .{ .mem, .none, .none } }, |
| 117083 | .unused, | 117088 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117084 | .unused, | 117089 | }, |
| 117085 | .unused, | 117090 | .dst_temps = .{ .{ .cc = .e }, .unused }, |
| 117086 | .unused, | 117091 | .clobbers = .{ .eflags = true }, |
| 117087 | }, | 117092 | .each = .{ .once = &.{ |
| 117088 | .dst_temps = .{ .mem, .unused }, | 117093 | .{ ._, ._, .cmp, .src0b, .si(-1), ._, ._ }, |
| 117089 | .each = .{ .once = &.{ | 117094 | } }, |
| 117090 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_size), ._, ._ }, | 117095 | }, .{ |
| 117091 | .{ .@"0:", ._, .mov, .memi(.dst0b, .tmp0), .src0b, ._, ._ }, | 117096 | .dst_constraints = .{ .bool, .any }, |
| 117092 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, | 117097 | .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any }, |
| 117093 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, | 117098 | .patterns = &.{ |
| 117094 | } }, | 117099 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117095 | }, .{ | 117100 | }, |
| 117096 | .required_features = .{ .avx2, null, null, null }, | 117101 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 117097 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, | 117102 | .clobbers = .{ .eflags = true }, |
| 117098 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117103 | .each = .{ .once = &.{ |
| 117099 | .patterns = &.{ | 117104 | .{ ._, ._, .not, .src0b, ._, ._, ._ }, |
| 117100 | .{ .src = .{ .mem, .none, .none } }, | 117105 | .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ }, |
| 117101 | .{ .src = .{ .to_sse, .none, .none } }, | 117106 | } }, |
| 117102 | }, | 117107 | }, .{ |
| 117103 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117108 | .dst_constraints = .{ .bool, .any }, |
| 117104 | .each = .{ .once = &.{ | 117109 | .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any }, |
| 117105 | .{ ._, .vp_w, .broadcast, .dst0x, .src0w, ._, ._ }, | 117110 | .patterns = &.{ |
| 117106 | } }, | 117111 | .{ .src = .{ .mem, .none, .none } }, |
| 117107 | }, .{ | 117112 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117108 | .required_features = .{ .avx, null, null, null }, | 117113 | }, |
| 117109 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, | 117114 | .dst_temps = .{ .{ .cc = .e }, .unused }, |
| 117110 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117115 | .clobbers = .{ .eflags = true }, |
| 117111 | .patterns = &.{ | 117116 | .each = .{ .once = &.{ |
| 117112 | .{ .src = .{ .to_sse, .none, .none } }, | 117117 | .{ ._, ._, .cmp, .src0w, .si(-1), ._, ._ }, |
| 117113 | }, | 117118 | } }, |
| 117114 | .extra_temps = .{ | 117119 | }, .{ |
| 117115 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 117120 | .dst_constraints = .{ .bool, .any }, |
| 117116 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, | 117121 | .src_constraints = .{ .{ .bool_vec = .word }, .any, .any }, |
| 117117 | .unused, | 117122 | .patterns = &.{ |
| 117118 | .unused, | 117123 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117119 | .unused, | 117124 | }, |
| 117120 | .unused, | 117125 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 117121 | .unused, | 117126 | .clobbers = .{ .eflags = true }, |
| 117122 | .unused, | 117127 | .each = .{ .once = &.{ |
| 117123 | .unused, | 117128 | .{ ._, ._, .not, .src0d, ._, ._, ._ }, |
| 117124 | .unused, | 117129 | .{ ._, ._, .@"test", .src0d, .ua(.src0, .add_umax), ._, ._ }, |
| 117125 | .unused, | 117130 | } }, |
| 117126 | }, | 117131 | }, .{ |
| 117127 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117132 | .dst_constraints = .{ .bool, .any }, |
| 117128 | .each = .{ .once = &.{ | 117133 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| 117129 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 117134 | .patterns = &.{ |
| 117130 | .{ ._, .vp_b, .shuf, .dst0x, .src0x, .lea(.tmp0x), ._ }, | 117135 | .{ .src = .{ .mem, .none, .none } }, |
| 117131 | } }, | 117136 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117132 | }, .{ | 117137 | }, |
| 117133 | .required_features = .{ .ssse3, null, null, null }, | 117138 | .dst_temps = .{ .{ .cc = .e }, .unused }, |
| 117134 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, | 117139 | .clobbers = .{ .eflags = true }, |
| 117135 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117140 | .each = .{ .once = &.{ |
| 117136 | .patterns = &.{ | 117141 | .{ ._, ._, .cmp, .src0d, .si(-1), ._, ._ }, |
| 117137 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117142 | } }, |
| 117138 | }, | 117143 | }, .{ |
| 117139 | .extra_temps = .{ | 117144 | .dst_constraints = .{ .bool, .any }, |
| 117140 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 117145 | .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any }, |
| 117141 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, | 117146 | .patterns = &.{ |
| 117142 | .unused, | 117147 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117143 | .unused, | 117148 | }, |
| 117144 | .unused, | 117149 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 117145 | .unused, | 117150 | .clobbers = .{ .eflags = true }, |
| 117146 | .unused, | 117151 | .each = .{ .once = &.{ |
| 117147 | .unused, | 117152 | .{ ._, ._, .not, .src0d, ._, ._, ._ }, |
| 117148 | .unused, | 117153 | .{ ._, ._, .@"test", .src0d, .ua(.src0, .add_umax), ._, ._ }, |
| 117149 | .unused, | 117154 | } }, |
| 117150 | .unused, | 117155 | }, .{ |
| 117151 | }, | 117156 | .required_features = .{ .@"64bit", null, null, null }, |
| 117152 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 117157 | .dst_constraints = .{ .bool, .any }, |
| 117153 | .each = .{ .once = &.{ | 117158 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| 117154 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 117159 | .patterns = &.{ |
| 117155 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ }, | 117160 | .{ .src = .{ .mem, .none, .none } }, |
| 117156 | } }, | 117161 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117157 | }, .{ | 117162 | }, |
| 117158 | .required_features = .{ .sse2, null, null, null }, | 117163 | .dst_temps = .{ .{ .cc = .e }, .unused }, |
| 117159 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, | 117164 | .clobbers = .{ .eflags = true }, |
| 117160 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117165 | .each = .{ .once = &.{ |
| 117161 | .patterns = &.{ | 117166 | .{ ._, ._, .cmp, .src0q, .si(-1), ._, ._ }, |
| 117162 | .{ .src = .{ .to_sse, .none, .none } }, | 117167 | } }, |
| 117163 | }, | 117168 | }, .{ |
| 117164 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117169 | .required_features = .{ .@"64bit", null, null, null }, |
| 117165 | .each = .{ .once = &.{ | 117170 | .dst_constraints = .{ .bool, .any }, |
| 117166 | .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117171 | .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any }, |
| 117167 | .{ ._, .p_d, .shuf, .dst0x, .dst0x, .ui(0b00_00_00_00), ._ }, | 117172 | .patterns = &.{ |
| 117168 | } }, | 117173 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117169 | }, .{ | 117174 | }, |
| 117170 | .required_features = .{ .avx2, null, null, null }, | 117175 | .extra_temps = .{ |
| 117171 | .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .word } }, .any }, | 117176 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 117172 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117177 | .unused, |
| 117173 | .patterns = &.{ | 117178 | .unused, |
| 117174 | .{ .src = .{ .mem, .none, .none } }, | 117179 | .unused, |
| 117175 | .{ .src = .{ .to_sse, .none, .none } }, | 117180 | .unused, |
| 117176 | }, | 117181 | .unused, |
| 117177 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117182 | .unused, |
| 117178 | .each = .{ .once = &.{ | 117183 | .unused, |
| 117179 | .{ ._, .vp_w, .broadcast, .dst0y, .src0w, ._, ._ }, | 117184 | .unused, |
| 117180 | } }, | 117185 | .unused, |
| 117181 | }, .{ | 117186 | .unused, |
| 117182 | .required_features = .{ .avx2, null, null, null }, | 117187 | }, |
| 117183 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .word } }, .any }, | 117188 | .dst_temps = .{ .{ .cc = .z }, .unused }, |
| 117184 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117189 | .clobbers = .{ .eflags = true }, |
| 117185 | .patterns = &.{ | 117190 | .each = .{ .once = &.{ |
| 117186 | .{ .src = .{ .mem, .none, .none } }, | 117191 | .{ ._, ._, .not, .src0q, ._, ._, ._ }, |
| 117187 | .{ .src = .{ .to_sse, .none, .none } }, | 117192 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| 117188 | }, | 117193 | .{ ._, ._, .@"test", .src0q, .tmp0q, ._, ._ }, |
| 117189 | .extra_temps = .{ | 117194 | } }, |
| 117190 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117195 | }, .{ |
| 117191 | .{ .type = .vector_16_u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117196 | .required_features = .{ .@"64bit", null, null, null }, |
| 117192 | .unused, | 117197 | .dst_constraints = .{ .bool, .any }, |
| 117193 | .unused, | 117198 | .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any }, |
| 117194 | .unused, | 117199 | .patterns = &.{ |
| 117195 | .unused, | 117200 | .{ .src = .{ .to_mem, .none, .none } }, |
| 117196 | .unused, | 117201 | }, |
| 117197 | .unused, | 117202 | .extra_temps = .{ |
| 117198 | .unused, | 117203 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 117199 | .unused, | 117204 | .unused, |
| 117200 | .unused, | 117205 | .unused, |
| 117201 | }, | 117206 | .unused, |
| 117202 | .dst_temps = .{ .mem, .unused }, | 117207 | .unused, |
| 117203 | .each = .{ .once = &.{ | 117208 | .unused, |
| 117204 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, | 117209 | .unused, |
| 117205 | .{ ._, .vp_w, .broadcast, .tmp1y, .src0w, ._, ._ }, | 117210 | .unused, |
| 117206 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, | 117211 | .unused, |
| 117207 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, | 117212 | .unused, |
| 117208 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117213 | .unused, |
| 117209 | } }, | 117214 | }, |
| 117210 | }, .{ | 117215 | .dst_temps = .{ .{ .cc = .nc }, .unused }, |
| 117211 | .required_features = .{ .avx, null, null, null }, | 117216 | .clobbers = .{ .eflags = true }, |
| 117212 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any }, | 117217 | .each = .{ .once = &.{ |
| 117213 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117218 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ }, |
| 117214 | .patterns = &.{ | 117219 | .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(-1), ._, ._ }, |
| 117215 | .{ .src = .{ .to_sse, .none, .none } }, | 117220 | .{ ._, ._ne, .j, .@"0f", ._, ._, ._ }, |
| 117216 | }, | 117221 | .{ ._, ._, .add, .tmp0d, .si(-8), ._, ._ }, |
| 117217 | .extra_temps = .{ | 117222 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 117218 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117223 | } }, |
| 117219 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, | 117224 | }, .{ |
| 117220 | .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117225 | .required_features = .{ .@"64bit", null, null, null }, |
| 117221 | .unused, | 117226 | .dst_constraints = .{ .bool, .any }, |
| 117222 | .unused, | 117227 | .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 117223 | .unused, | 117228 | .patterns = &.{ |
| 117224 | .unused, | 117229 | .{ .src = .{ .to_mem, .none, .none } }, |
| 117225 | .unused, | 117230 | }, |
| 117226 | .unused, | 117231 | .extra_temps = .{ |
| 117227 | .unused, | 117232 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 117228 | .unused, | 117233 | .unused, |
| 117229 | }, | 117234 | .unused, |
| 117230 | .dst_temps = .{ .mem, .unused }, | 117235 | .unused, |
| 117231 | .each = .{ .once = &.{ | 117236 | .unused, |
| 117232 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 117237 | .unused, |
| 117233 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.tmp0x), ._ }, | 117238 | .unused, |
| 117234 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117239 | .unused, |
| 117235 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp2x, ._, ._ }, | 117240 | .unused, |
| 117236 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117241 | .unused, |
| 117237 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117242 | .unused, |
| 117238 | } }, | 117243 | }, |
| 117239 | }, .{ | 117244 | .dst_temps = .{ .{ .cc = .nc }, .unused }, |
| 117240 | .required_features = .{ .ssse3, null, null, null }, | 117245 | .clobbers = .{ .eflags = true }, |
| 117241 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any }, | 117246 | .each = .{ .once = &.{ |
| 117242 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117247 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_2_smin), ._, ._ }, |
| 117243 | .patterns = &.{ | 117248 | .{ ._, ._, .@"or", .tmp0q, .mema(.src0q, .add_bit_size_div_8_down_8), ._, ._ }, |
| 117244 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117249 | .{ ._, ._, .cmp, .tmp0q, .si(-1), ._, ._ }, |
| 117245 | }, | 117250 | .{ ._, ._ne, .j, .@"0f", ._, ._, ._ }, |
| 117246 | .extra_temps = .{ | 117251 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ }, |
| 117247 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117252 | .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(-1), ._, ._ }, |
| 117248 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, | 117253 | .{ ._, ._ne, .j, .@"0f", ._, ._, ._ }, |
| 117249 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, | 117254 | .{ ._, ._, .add, .tmp0d, .si(-8), ._, ._ }, |
| 117250 | .unused, | 117255 | .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, |
| 117251 | .unused, | 117256 | } }, |
| 117252 | .unused, | 117257 | } }, |
| 117253 | .unused, | 117258 | .@"or" => [_]Select.Case{ .{ |
| 117254 | .unused, | 117259 | .required_features = .{ .avx, null, null, null }, |
| 117255 | .unused, | 117260 | .dst_constraints = .{ .bool, .any }, |
| 117256 | .unused, | 117261 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117257 | .unused, | 117262 | .patterns = &.{ |
| 117258 | }, | 117263 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .uninverted } }, .none, .none } }, |
| 117259 | .dst_temps = .{ .mem, .unused }, | 117264 | }, |
| 117260 | .each = .{ .once = &.{ | 117265 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117261 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 117266 | .clobbers = .{ .eflags = true }, |
| 117262 | .{ ._, .p_b, .shuf, .src0x, .lea(.tmp0x), ._, ._ }, | 117267 | .each = .{ .once = &.{ |
| 117263 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117268 | .{ ._, .vp_, .@"test", .src0x, .src0x, ._, ._ }, |
| 117264 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, | 117269 | } }, |
| 117265 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117270 | }, .{ |
| 117266 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117271 | .required_features = .{ .sse4_1, null, null, null }, |
| 117267 | } }, | 117272 | .dst_constraints = .{ .bool, .any }, |
| 117268 | }, .{ | 117273 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117269 | .required_features = .{ .sse2, null, null, null }, | 117274 | .patterns = &.{ |
| 117270 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any }, | 117275 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword, .is = .uninverted } }, .none, .none } }, |
| 117271 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117276 | }, |
| 117272 | .patterns = &.{ | 117277 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117273 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117278 | .clobbers = .{ .eflags = true }, |
| 117274 | }, | 117279 | .each = .{ .once = &.{ |
| 117275 | .extra_temps = .{ | 117280 | .{ ._, .p_, .@"test", .src0x, .src0x, ._, ._ }, |
| 117276 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117281 | } }, |
| 117277 | .unused, | 117282 | }, .{ |
| 117278 | .unused, | 117283 | .required_features = .{ .avx, null, null, null }, |
| 117279 | .unused, | 117284 | .dst_constraints = .{ .bool, .any }, |
| 117280 | .unused, | 117285 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117281 | .unused, | 117286 | .patterns = &.{ |
| 117282 | .unused, | 117287 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 117283 | .unused, | 117288 | }, |
| 117284 | .unused, | 117289 | .extra_temps = .{ |
| 117285 | .unused, | 117290 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 117286 | .unused, | 117291 | .unused, |
| 117287 | }, | 117292 | .unused, |
| 117288 | .dst_temps = .{ .mem, .unused }, | 117293 | .unused, |
| 117289 | .each = .{ .once = &.{ | 117294 | .unused, |
| 117290 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117295 | .unused, |
| 117291 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117296 | .unused, |
| 117292 | .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117297 | .unused, |
| 117293 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, | 117298 | .unused, |
| 117294 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117299 | .unused, |
| 117295 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117300 | .unused, |
| 117296 | } }, | 117301 | }, |
| 117297 | }, .{ | 117302 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117298 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .word, .is = .word } }, .any }, | 117303 | .clobbers = .{ .eflags = true }, |
| 117299 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, | 117304 | .each = .{ .once = &.{ |
| 117300 | .patterns = &.{ | 117305 | .{ ._, .vp_b, .cmpeq, .tmp0x, .tmp0x, .tmp0x, ._ }, |
| 117301 | .{ .src = .{ .to_gpr, .none, .none } }, | 117306 | .{ ._, .vp_, .@"test", .src0x, .tmp0x, ._, ._ }, |
| 117302 | }, | 117307 | } }, |
| 117303 | .extra_temps = .{ | 117308 | }, .{ |
| 117304 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117309 | .required_features = .{ .sse4_1, null, null, null }, |
| 117305 | .unused, | 117310 | .dst_constraints = .{ .bool, .any }, |
| 117306 | .unused, | 117311 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117307 | .unused, | 117312 | .patterns = &.{ |
| 117308 | .unused, | 117313 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 117309 | .unused, | 117314 | }, |
| 117310 | .unused, | 117315 | .extra_temps = .{ |
| 117311 | .unused, | 117316 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 117312 | .unused, | 117317 | .unused, |
| 117313 | .unused, | 117318 | .unused, |
| 117314 | .unused, | 117319 | .unused, |
| 117315 | }, | 117320 | .unused, |
| 117316 | .dst_temps = .{ .mem, .unused }, | 117321 | .unused, |
| 117317 | .each = .{ .once = &.{ | 117322 | .unused, |
| 117318 | .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ }, | 117323 | .unused, |
| 117319 | .{ .@"0:", ._, .mov, .memi(.dst0w, .tmp0), .src0w, ._, ._ }, | 117324 | .unused, |
| 117320 | .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, | 117325 | .unused, |
| 117321 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117326 | .unused, |
| 117322 | } }, | 117327 | }, |
| 117323 | }, .{ | 117328 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117324 | .required_features = .{ .avx2, null, null, null }, | 117329 | .clobbers = .{ .eflags = true }, |
| 117325 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 117330 | .each = .{ .once = &.{ |
| 117326 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117331 | .{ ._, .p_b, .cmpeq, .tmp0x, .tmp0x, ._, ._ }, |
| 117327 | .patterns = &.{ | 117332 | .{ ._, .p_, .@"test", .src0x, .tmp0x, ._, ._ }, |
| 117328 | .{ .src = .{ .mem, .none, .none } }, | 117333 | } }, |
| 117329 | .{ .src = .{ .to_sse, .none, .none } }, | 117334 | }, .{ |
| 117330 | }, | 117335 | .required_features = .{ .avx, null, null, null }, |
| 117331 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117336 | .dst_constraints = .{ .bool, .any }, |
| 117332 | .each = .{ .once = &.{ | 117337 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117333 | .{ ._, .vp_d, .broadcast, .dst0x, .src0d, ._, ._ }, | 117338 | .patterns = &.{ |
| 117334 | } }, | 117339 | .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 117335 | }, .{ | 117340 | }, |
| 117336 | .required_features = .{ .avx2, null, null, null }, | 117341 | .extra_temps = .{ |
| 117337 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117342 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 117338 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117343 | .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } }, |
| 117339 | .patterns = &.{ | 117344 | .unused, |
| 117340 | .{ .src = .{ .mem, .none, .none } }, | 117345 | .unused, |
| 117341 | .{ .src = .{ .to_sse, .none, .none } }, | 117346 | .unused, |
| 117342 | }, | 117347 | .unused, |
| 117343 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117348 | .unused, |
| 117344 | .each = .{ .once = &.{ | 117349 | .unused, |
| 117345 | .{ ._, .v_ss, .broadcast, .dst0x, .src0d, ._, ._ }, | 117350 | .unused, |
| 117346 | } }, | 117351 | .unused, |
| 117347 | }, .{ | 117352 | .unused, |
| 117348 | .required_features = .{ .avx, null, null, null }, | 117353 | }, |
| 117349 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .dword } }, .any }, | 117354 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117350 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, | 117355 | .clobbers = .{ .eflags = true }, |
| 117351 | .patterns = &.{ | 117356 | .each = .{ .once = &.{ |
| 117352 | .{ .src = .{ .mem, .none, .none } }, | 117357 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 117353 | }, | 117358 | .{ ._, .vp_, .@"test", .src0x, .lea(.tmp0x), ._, ._ }, |
| 117354 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117359 | } }, |
| 117355 | .each = .{ .once = &.{ | 117360 | }, .{ |
| 117356 | .{ ._, .v_ss, .broadcast, .dst0x, .src0d, ._, ._ }, | 117361 | .required_features = .{ .sse4_1, null, null, null }, |
| 117357 | } }, | 117362 | .dst_constraints = .{ .bool, .any }, |
| 117358 | }, .{ | 117363 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117359 | .required_features = .{ .avx, null, null, null }, | 117364 | .patterns = &.{ |
| 117360 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 117365 | .{ .src = .{ .{ .reg_mask = .{ .size = .xword } }, .none, .none } }, |
| 117361 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117366 | }, |
| 117362 | .patterns = &.{ | 117367 | .extra_temps = .{ |
| 117363 | .{ .src = .{ .to_sse, .none, .none } }, | 117368 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 117364 | }, | 117369 | .{ .type = .vector_16_u8, .kind = .{ .ptest_mask_mem = .src0 } }, |
| 117365 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117370 | .unused, |
| 117366 | .each = .{ .once = &.{ | 117371 | .unused, |
| 117367 | .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117372 | .unused, |
| 117368 | } }, | 117373 | .unused, |
| 117369 | }, .{ | 117374 | .unused, |
| 117370 | .required_features = .{ .avx, null, null, null }, | 117375 | .unused, |
| 117371 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117376 | .unused, |
| 117372 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117377 | .unused, |
| 117373 | .patterns = &.{ | 117378 | .unused, |
| 117374 | .{ .src = .{ .to_sse, .none, .none } }, | 117379 | }, |
| 117375 | }, | 117380 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117376 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117381 | .clobbers = .{ .eflags = true }, |
| 117377 | .each = .{ .once = &.{ | 117382 | .each = .{ .once = &.{ |
| 117378 | .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b00_00_00_00) }, | 117383 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 117379 | } }, | 117384 | .{ ._, .p_, .@"test", .src0x, .lea(.tmp0x), ._, ._ }, |
| 117380 | }, .{ | 117385 | } }, |
| 117381 | .required_features = .{ .sse2, null, null, null }, | 117386 | }, .{ |
| 117382 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 117387 | .required_features = .{ .avx2, null, null, null }, |
| 117383 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117388 | .dst_constraints = .{ .bool, .any }, |
| 117384 | .patterns = &.{ | 117389 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117385 | .{ .src = .{ .to_sse, .none, .none } }, | 117390 | .patterns = &.{ |
| 117386 | }, | 117391 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .uninverted } }, .none, .none } }, |
| 117387 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117392 | }, |
| 117388 | .each = .{ .once = &.{ | 117393 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117389 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117394 | .clobbers = .{ .eflags = true }, |
| 117390 | } }, | 117395 | .each = .{ .once = &.{ |
| 117391 | }, .{ | 117396 | .{ ._, .vp_, .@"test", .src0y, .src0y, ._, ._ }, |
| 117392 | .required_features = .{ .sse, null, null, null }, | 117397 | } }, |
| 117393 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117398 | }, .{ |
| 117394 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117399 | .required_features = .{ .avx, null, null, null }, |
| 117395 | .patterns = &.{ | 117400 | .dst_constraints = .{ .bool, .any }, |
| 117396 | .{ .src = .{ .mut_sse, .none, .none } }, | 117401 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117397 | }, | 117402 | .patterns = &.{ |
| 117398 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 117403 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword, .is = .uninverted } }, .none, .none } }, |
| 117399 | .each = .{ .once = &.{ | 117404 | }, |
| 117400 | .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117405 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117401 | } }, | 117406 | .clobbers = .{ .eflags = true }, |
| 117402 | }, .{ | 117407 | .each = .{ .once = &.{ |
| 117403 | .required_features = .{ .sse2, null, null, null }, | 117408 | .{ ._, .v_ps, .@"test", .src0y, .src0y, ._, ._ }, |
| 117404 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117409 | } }, |
| 117405 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117410 | }, .{ |
| 117406 | .patterns = &.{ | 117411 | .required_features = .{ .avx2, null, null, null }, |
| 117407 | .{ .src = .{ .sse, .none, .none } }, | 117412 | .dst_constraints = .{ .bool, .any }, |
| 117408 | }, | 117413 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117409 | .dst_temps = .{ .{ .rc = .sse }, .unused }, | 117414 | .patterns = &.{ |
| 117410 | .each = .{ .once = &.{ | 117415 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, |
| 117411 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117416 | }, |
| 117412 | } }, | 117417 | .extra_temps = .{ |
| 117413 | }, .{ | 117418 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| 117414 | .required_features = .{ .sse, null, null, null }, | 117419 | .unused, |
| 117415 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .dword } }, .any }, | 117420 | .unused, |
| 117416 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, | 117421 | .unused, |
| 117417 | .patterns = &.{ | 117422 | .unused, |
| 117418 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117423 | .unused, |
| 117419 | }, | 117424 | .unused, |
| 117420 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 117425 | .unused, |
| 117421 | .each = .{ .once = &.{ | 117426 | .unused, |
| 117422 | .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117427 | .unused, |
| 117423 | } }, | 117428 | .unused, |
| 117424 | }, .{ | 117429 | }, |
| 117425 | .required_features = .{ .avx2, null, null, null }, | 117430 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117426 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, | 117431 | .clobbers = .{ .eflags = true }, |
| 117427 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117432 | .each = .{ .once = &.{ |
| 117428 | .patterns = &.{ | 117433 | .{ ._, .vp_b, .cmpeq, .tmp0y, .tmp0y, .tmp0y, ._ }, |
| 117429 | .{ .src = .{ .mem, .none, .none } }, | 117434 | .{ ._, .vp_, .@"test", .src0y, .tmp0y, ._, ._ }, |
| 117430 | .{ .src = .{ .to_sse, .none, .none } }, | 117435 | } }, |
| 117431 | }, | 117436 | }, .{ |
| 117432 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117437 | .required_features = .{ .avx, null, null, null }, |
| 117433 | .each = .{ .once = &.{ | 117438 | .dst_constraints = .{ .bool, .any }, |
| 117434 | .{ ._, .vp_d, .broadcast, .dst0y, .src0d, ._, ._ }, | 117439 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117435 | } }, | 117440 | .patterns = &.{ |
| 117436 | }, .{ | 117441 | .{ .src = .{ .{ .all_reg_mask = .{ .size = .yword } }, .none, .none } }, |
| 117437 | .required_features = .{ .avx2, null, null, null }, | 117442 | }, |
| 117438 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any }, | 117443 | .extra_temps = .{ |
| 117439 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117444 | .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } }, |
| 117440 | .patterns = &.{ | 117445 | .unused, |
| 117441 | .{ .src = .{ .mem, .none, .none } }, | 117446 | .unused, |
| 117442 | .{ .src = .{ .to_sse, .none, .none } }, | 117447 | .unused, |
| 117443 | }, | 117448 | .unused, |
| 117444 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117449 | .unused, |
| 117445 | .each = .{ .once = &.{ | 117450 | .unused, |
| 117446 | .{ ._, .v_ss, .broadcast, .dst0y, .src0d, ._, ._ }, | 117451 | .unused, |
| 117447 | } }, | 117452 | .unused, |
| 117448 | }, .{ | 117453 | .unused, |
| 117449 | .required_features = .{ .avx2, null, null, null }, | 117454 | .unused, |
| 117450 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any }, | 117455 | }, |
| 117451 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117456 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117452 | .patterns = &.{ | 117457 | .clobbers = .{ .eflags = true }, |
| 117453 | .{ .src = .{ .mem, .none, .none } }, | 117458 | .each = .{ .once = &.{ |
| 117454 | .{ .src = .{ .to_sse, .none, .none } }, | 117459 | .{ ._, .v_ps, .cmp, .tmp0y, .tmp0y, .tmp0y, .vp(.true) }, |
| 117455 | }, | 117460 | .{ ._, .v_ps, .@"test", .src0y, .tmp0y, ._, ._ }, |
| 117456 | .extra_temps = .{ | 117461 | } }, |
| 117457 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117462 | }, .{ |
| 117458 | .{ .type = .vector_8_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117463 | .required_features = .{ .avx, null, null, null }, |
| 117459 | .unused, | 117464 | .dst_constraints = .{ .bool, .any }, |
| 117460 | .unused, | 117465 | .src_constraints = .{ .any_bool_vec, .any, .any }, |
| 117461 | .unused, | 117466 | .patterns = &.{ |
| 117462 | .unused, | 117467 | .{ .src = .{ .{ .reg_mask = .{ .size = .yword } }, .none, .none } }, |
| 117463 | .unused, | 117468 | }, |
| 117464 | .unused, | 117469 | .extra_temps = .{ |
| 117465 | .unused, | 117470 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 117466 | .unused, | 117471 | .{ .type = .vector_32_u8, .kind = .{ .ptest_mask_mem = .src0 } }, |
| 117467 | .unused, | 117472 | .unused, |
| 117468 | }, | 117473 | .unused, |
| 117469 | .dst_temps = .{ .mem, .unused }, | 117474 | .unused, |
| 117470 | .each = .{ .once = &.{ | 117475 | .unused, |
| 117471 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, | 117476 | .unused, |
| 117472 | .{ ._, .vp_d, .broadcast, .tmp1y, .src0d, ._, ._ }, | 117477 | .unused, |
| 117473 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, | 117478 | .unused, |
| 117474 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, | 117479 | .unused, |
| 117475 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117480 | .unused, |
| 117476 | } }, | 117481 | }, |
| 117477 | }, .{ | 117482 | .dst_temps = .{ .{ .ptest_cc = .{ .ref = .src0, .not = true, .all = 0 } }, .unused }, |
| 117478 | .required_features = .{ .avx2, null, null, null }, | 117483 | .clobbers = .{ .eflags = true }, |
| 117479 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any }, | 117484 | .each = .{ .once = &.{ |
| 117480 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117485 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 117481 | .patterns = &.{ | 117486 | .{ ._, .vp_, .@"test", .src0y, .lea(.tmp0y), ._, ._ }, |
| 117482 | .{ .src = .{ .mem, .none, .none } }, | 117487 | } }, |
| 117483 | .{ .src = .{ .to_sse, .none, .none } }, | 117488 | }, .{ |
| 117484 | }, | 117489 | .dst_constraints = .{ .bool, .any }, |
| 117485 | .extra_temps = .{ | 117490 | .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any }, |
| 117486 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117491 | .patterns = &.{ |
| 117487 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117492 | .{ .src = .{ .mem, .none, .none } }, |
| 117488 | .unused, | 117493 | }, |
| 117489 | .unused, | 117494 | .dst_temps = .{ .{ .cc = .ne }, .unused }, |
| 117490 | .unused, | 117495 | .clobbers = .{ .eflags = true }, |
| 117491 | .unused, | 117496 | .each = .{ .once = &.{ |
| 117492 | .unused, | 117497 | .{ ._, ._, .cmp, .src0b, .si(0), ._, ._ }, |
| 117493 | .unused, | 117498 | } }, |
| 117494 | .unused, | 117499 | }, .{ |
| 117495 | .unused, | 117500 | .dst_constraints = .{ .bool, .any }, |
| 117496 | .unused, | 117501 | .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any }, |
| 117497 | }, | 117502 | .patterns = &.{ |
| 117498 | .dst_temps = .{ .mem, .unused }, | 117503 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117499 | .each = .{ .once = &.{ | 117504 | }, |
| 117500 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, | 117505 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117501 | .{ ._, .v_ss, .broadcast, .tmp1y, .src0d, ._, ._ }, | 117506 | .clobbers = .{ .eflags = true }, |
| 117502 | .{ .@"0:", .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, | 117507 | .each = .{ .once = &.{ |
| 117503 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, | 117508 | .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ }, |
| 117504 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117509 | } }, |
| 117505 | } }, | 117510 | }, .{ |
| 117506 | }, .{ | 117511 | .dst_constraints = .{ .bool, .any }, |
| 117507 | .required_features = .{ .avx, null, null, null }, | 117512 | .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any }, |
| 117508 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .dword } }, .any }, | 117513 | .patterns = &.{ |
| 117509 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, | 117514 | .{ .src = .{ .mem, .none, .none } }, |
| 117510 | .patterns = &.{ | 117515 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117511 | .{ .src = .{ .mem, .none, .none } }, | 117516 | }, |
| 117512 | }, | 117517 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117513 | .extra_temps = .{ | 117518 | .clobbers = .{ .eflags = true }, |
| 117514 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117519 | .each = .{ .once = &.{ |
| 117515 | .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117520 | .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ }, |
| 117516 | .unused, | 117521 | } }, |
| 117517 | .unused, | 117522 | }, .{ |
| 117518 | .unused, | 117523 | .dst_constraints = .{ .bool, .any }, |
| 117519 | .unused, | 117524 | .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any }, |
| 117520 | .unused, | 117525 | .patterns = &.{ |
| 117521 | .unused, | 117526 | .{ .src = .{ .mem, .none, .none } }, |
| 117522 | .unused, | 117527 | }, |
| 117523 | .unused, | 117528 | .dst_temps = .{ .{ .cc = .ne }, .unused }, |
| 117524 | .unused, | 117529 | .clobbers = .{ .eflags = true }, |
| 117525 | }, | 117530 | .each = .{ .once = &.{ |
| 117526 | .dst_temps = .{ .mem, .unused }, | 117531 | .{ ._, ._, .cmp, .src0w, .si(0), ._, ._ }, |
| 117527 | .each = .{ .once = &.{ | 117532 | } }, |
| 117528 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117533 | }, .{ |
| 117529 | .{ ._, .v_ss, .broadcast, .tmp1x, .src0d, ._, ._ }, | 117534 | .dst_constraints = .{ .bool, .any }, |
| 117530 | .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, | 117535 | .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any }, |
| 117531 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117536 | .patterns = &.{ |
| 117532 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117537 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117533 | } }, | 117538 | }, |
| 117534 | }, .{ | 117539 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117535 | .required_features = .{ .avx, null, null, null }, | 117540 | .clobbers = .{ .eflags = true }, |
| 117536 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 117541 | .each = .{ .once = &.{ |
| 117537 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117542 | .{ ._, ._, .@"test", .src0w, .src0w, ._, ._ }, |
| 117538 | .patterns = &.{ | 117543 | } }, |
| 117539 | .{ .src = .{ .to_sse, .none, .none } }, | 117544 | }, .{ |
| 117540 | }, | 117545 | .dst_constraints = .{ .bool, .any }, |
| 117541 | .extra_temps = .{ | 117546 | .src_constraints = .{ .{ .bool_vec = .word }, .any, .any }, |
| 117542 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117547 | .patterns = &.{ |
| 117543 | .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117548 | .{ .src = .{ .mem, .none, .none } }, |
| 117544 | .unused, | 117549 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117545 | .unused, | 117550 | }, |
| 117546 | .unused, | 117551 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117547 | .unused, | 117552 | .clobbers = .{ .eflags = true }, |
| 117548 | .unused, | 117553 | .each = .{ .once = &.{ |
| 117549 | .unused, | 117554 | .{ ._, ._, .@"test", .src0w, .ua(.src0, .add_umax), ._, ._ }, |
| 117550 | .unused, | 117555 | } }, |
| 117551 | .unused, | 117556 | }, .{ |
| 117552 | .unused, | 117557 | .dst_constraints = .{ .bool, .any }, |
| 117553 | }, | 117558 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| 117554 | .dst_temps = .{ .mem, .unused }, | 117559 | .patterns = &.{ |
| 117555 | .each = .{ .once = &.{ | 117560 | .{ .src = .{ .mem, .none, .none } }, |
| 117556 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117561 | }, |
| 117557 | .{ ._, .vp_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ }, | 117562 | .dst_temps = .{ .{ .cc = .ne }, .unused }, |
| 117558 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, | 117563 | .clobbers = .{ .eflags = true }, |
| 117559 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117564 | .each = .{ .once = &.{ |
| 117560 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117565 | .{ ._, ._, .cmp, .src0d, .si(0), ._, ._ }, |
| 117561 | } }, | 117566 | } }, |
| 117562 | }, .{ | 117567 | }, .{ |
| 117563 | .required_features = .{ .avx, null, null, null }, | 117568 | .dst_constraints = .{ .bool, .any }, |
| 117564 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117569 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| 117565 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117570 | .patterns = &.{ |
| 117566 | .patterns = &.{ | 117571 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117567 | .{ .src = .{ .to_sse, .none, .none } }, | 117572 | }, |
| 117568 | }, | 117573 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117569 | .extra_temps = .{ | 117574 | .clobbers = .{ .eflags = true }, |
| 117570 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117575 | .each = .{ .once = &.{ |
| 117571 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117576 | .{ ._, ._, .@"test", .src0d, .src0d, ._, ._ }, |
| 117572 | .unused, | 117577 | } }, |
| 117573 | .unused, | 117578 | }, .{ |
| 117574 | .unused, | 117579 | .dst_constraints = .{ .bool, .any }, |
| 117575 | .unused, | 117580 | .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any }, |
| 117576 | .unused, | 117581 | .patterns = &.{ |
| 117577 | .unused, | 117582 | .{ .src = .{ .mem, .none, .none } }, |
| 117578 | .unused, | 117583 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117579 | .unused, | 117584 | }, |
| 117580 | .unused, | 117585 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117581 | }, | 117586 | .clobbers = .{ .eflags = true }, |
| 117582 | .dst_temps = .{ .mem, .unused }, | 117587 | .each = .{ .once = &.{ |
| 117583 | .each = .{ .once = &.{ | 117588 | .{ ._, ._, .@"test", .src0d, .ua(.src0, .add_umax), ._, ._ }, |
| 117584 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117589 | } }, |
| 117585 | .{ ._, .v_ps, .shuf, .tmp1x, .tmp1x, .src0x, .ui(0b00_00_00_00) }, | 117590 | }, .{ |
| 117586 | .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, | 117591 | .required_features = .{ .@"64bit", null, null, null }, |
| 117587 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117592 | .dst_constraints = .{ .bool, .any }, |
| 117588 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117593 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| 117589 | } }, | 117594 | .patterns = &.{ |
| 117590 | }, .{ | 117595 | .{ .src = .{ .mem, .none, .none } }, |
| 117591 | .required_features = .{ .sse2, null, null, null }, | 117596 | }, |
| 117592 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, | 117597 | .dst_temps = .{ .{ .cc = .ne }, .unused }, |
| 117593 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, | 117598 | .clobbers = .{ .eflags = true }, |
| 117594 | .patterns = &.{ | 117599 | .each = .{ .once = &.{ |
| 117595 | .{ .src = .{ .to_sse, .none, .none } }, | 117600 | .{ ._, ._, .cmp, .src0q, .si(0), ._, ._ }, |
| 117596 | }, | 117601 | } }, |
| 117597 | .extra_temps = .{ | 117602 | }, .{ |
| 117598 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117603 | .required_features = .{ .@"64bit", null, null, null }, |
| 117599 | .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 117604 | .dst_constraints = .{ .bool, .any }, |
| 117600 | .unused, | 117605 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| 117601 | .unused, | 117606 | .patterns = &.{ |
| 117602 | .unused, | 117607 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117603 | .unused, | 117608 | }, |
| 117604 | .unused, | 117609 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117605 | .unused, | 117610 | .clobbers = .{ .eflags = true }, |
| 117606 | .unused, | 117611 | .each = .{ .once = &.{ |
| 117607 | .unused, | 117612 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 117608 | .unused, | 117613 | } }, |
| 117609 | }, | 117614 | }, .{ |
| 117610 | .dst_temps = .{ .mem, .unused }, | 117615 | .required_features = .{ .@"64bit", null, null, null }, |
| 117611 | .each = .{ .once = &.{ | 117616 | .dst_constraints = .{ .bool, .any }, |
| 117612 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117617 | .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any }, |
| 117613 | .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ }, | 117618 | .patterns = &.{ |
| 117614 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, | 117619 | .{ .src = .{ .mem, .none, .none } }, |
| 117615 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117620 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117616 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117621 | }, |
| 117617 | } }, | 117622 | .extra_temps = .{ |
| 117618 | }, .{ | 117623 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 117619 | .required_features = .{ .sse, null, null, null }, | 117624 | .unused, |
| 117620 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117625 | .unused, |
| 117621 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117626 | .unused, |
| 117622 | .patterns = &.{ | 117627 | .unused, |
| 117623 | .{ .src = .{ .mut_sse, .none, .none } }, | 117628 | .unused, |
| 117624 | }, | 117629 | .unused, |
| 117625 | .extra_temps = .{ | 117630 | .unused, |
| 117626 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117631 | .unused, |
| 117627 | .unused, | 117632 | .unused, |
| 117628 | .unused, | 117633 | .unused, |
| 117629 | .unused, | 117634 | }, |
| 117630 | .unused, | 117635 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117631 | .unused, | 117636 | .clobbers = .{ .eflags = true }, |
| 117632 | .unused, | 117637 | .each = .{ .once = &.{ |
| 117633 | .unused, | 117638 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| 117634 | .unused, | 117639 | .{ ._, ._, .@"test", .src0q, .tmp0q, ._, ._ }, |
| 117635 | .unused, | 117640 | } }, |
| 117636 | .unused, | 117641 | }, .{ |
| 117637 | }, | 117642 | .required_features = .{ .@"64bit", null, null, null }, |
| 117638 | .dst_temps = .{ .mem, .unused }, | 117643 | .dst_constraints = .{ .bool, .any }, |
| 117639 | .each = .{ .once = &.{ | 117644 | .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any }, |
| 117640 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117645 | .patterns = &.{ |
| 117641 | .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117646 | .{ .src = .{ .to_mem, .none, .none } }, |
| 117642 | .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, | 117647 | }, |
| 117643 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117648 | .extra_temps = .{ |
| 117644 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117649 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 117645 | } }, | 117650 | .unused, |
| 117646 | }, .{ | 117651 | .unused, |
| 117647 | .required_features = .{ .sse2, null, null, null }, | 117652 | .unused, |
| 117648 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, | 117653 | .unused, |
| 117649 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 117654 | .unused, |
| 117650 | .patterns = &.{ | 117655 | .unused, |
| 117651 | .{ .src = .{ .sse, .none, .none } }, | 117656 | .unused, |
| 117652 | }, | 117657 | .unused, |
| 117653 | .extra_temps = .{ | 117658 | .unused, |
| 117654 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117659 | .unused, |
| 117655 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, | 117660 | }, |
| 117656 | .unused, | 117661 | .dst_temps = .{ .{ .cc = .nc }, .unused }, |
| 117657 | .unused, | 117662 | .clobbers = .{ .eflags = true }, |
| 117658 | .unused, | 117663 | .each = .{ .once = &.{ |
| 117659 | .unused, | 117664 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ }, |
| 117660 | .unused, | 117665 | .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ }, |
| 117661 | .unused, | 117666 | .{ ._, ._ne, .j, .@"0f", ._, ._, ._ }, |
| 117662 | .unused, | 117667 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| 117663 | .unused, | 117668 | .{ ._, ._nb, .j, .@"1b", ._, ._, ._ }, |
| 117664 | .unused, | 117669 | } }, |
| 117665 | }, | 117670 | }, .{ |
| 117666 | .dst_temps = .{ .mem, .unused }, | 117671 | .required_features = .{ .@"64bit", null, null, null }, |
| 117667 | .each = .{ .once = &.{ | 117672 | .dst_constraints = .{ .bool, .any }, |
| 117668 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117673 | .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 117669 | .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ }, | 117674 | .patterns = &.{ |
| 117670 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, | 117675 | .{ .src = .{ .to_mem, .none, .none } }, |
| 117671 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117676 | }, |
| 117672 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117677 | .extra_temps = .{ |
| 117673 | } }, | 117678 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 117674 | }, .{ | 117679 | .unused, |
| 117675 | .required_features = .{ .sse, null, null, null }, | 117680 | .unused, |
| 117676 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .dword } }, .any }, | 117681 | .unused, |
| 117677 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, | 117682 | .unused, |
| 117678 | .patterns = &.{ | 117683 | .unused, |
| 117679 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117684 | .unused, |
| 117680 | }, | 117685 | .unused, |
| 117681 | .extra_temps = .{ | 117686 | .unused, |
| 117682 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117687 | .unused, |
| 117683 | .unused, | 117688 | .unused, |
| 117684 | .unused, | 117689 | }, |
| 117685 | .unused, | 117690 | .dst_temps = .{ .{ .cc = .nc }, .unused }, |
| 117686 | .unused, | 117691 | .clobbers = .{ .eflags = true }, |
| 117687 | .unused, | 117692 | .each = .{ .once = &.{ |
| 117688 | .unused, | 117693 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| 117689 | .unused, | 117694 | .{ ._, ._, .@"test", .mema(.src0q, .add_bit_size_div_8_down_8), .tmp0q, ._, ._ }, |
| 117690 | .unused, | 117695 | .{ ._, ._nz, .j, .@"0f", ._, ._, ._ }, |
| 117691 | .unused, | 117696 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ }, |
| 117692 | .unused, | 117697 | .{ .@"1:", ._, .cmp, .memi(.src0q, .tmp0), .si(0), ._, ._ }, |
| 117693 | }, | 117698 | .{ ._, ._ne, .j, .@"0f", ._, ._, ._ }, |
| 117694 | .dst_temps = .{ .mem, .unused }, | 117699 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| 117695 | .each = .{ .once = &.{ | 117700 | .{ ._, ._nb, .j, .@"1b", ._, ._, ._ }, |
| 117696 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, | 117701 | } }, |
| 117697 | .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, | 117702 | } }, |
| 117698 | .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, | 117703 | .xor => [_]Select.Case{ .{ |
| 117699 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, | 117704 | .dst_constraints = .{ .bool, .any }, |
| 117700 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117705 | .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any }, |
| 117701 | } }, | 117706 | .patterns = &.{ |
| 117702 | }, .{ | 117707 | .{ .src = .{ .mem, .none, .none } }, |
| 117703 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .dword, .is = .dword } }, .any }, | 117708 | }, |
| 117704 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, | 117709 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| 117705 | .patterns = &.{ | 117710 | .clobbers = .{ .eflags = true }, |
| 117706 | .{ .src = .{ .to_gpr, .none, .none } }, | 117711 | .each = .{ .once = &.{ |
| 117707 | }, | 117712 | .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ }, |
| 117708 | .extra_temps = .{ | 117713 | } }, |
| 117709 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, | 117714 | }, .{ |
| 117710 | .unused, | 117715 | .dst_constraints = .{ .bool, .any }, |
| 117711 | .unused, | 117716 | .src_constraints = .{ .{ .exact_bool_vec = 8 }, .any, .any }, |
| 117712 | .unused, | 117717 | .patterns = &.{ |
| 117713 | .unused, | 117718 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117714 | .unused, | 117719 | }, |
| 117715 | .unused, | 117720 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| 117716 | .unused, | 117721 | .clobbers = .{ .eflags = true }, |
| 117717 | .unused, | 117722 | .each = .{ .once = &.{ |
| 117718 | .unused, | 117723 | .{ ._, ._, .@"test", .src0b, .src0b, ._, ._ }, |
| 117719 | .unused, | 117724 | } }, |
| 117720 | }, | 117725 | }, .{ |
| 117721 | .dst_temps = .{ .mem, .unused }, | 117726 | .dst_constraints = .{ .bool, .any }, |
| 117722 | .each = .{ .once = &.{ | 117727 | .src_constraints = .{ .{ .bool_vec = .byte }, .any, .any }, |
| 117723 | .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, | 117728 | .patterns = &.{ |
| 117724 | .{ .@"0:", ._, .mov, .memi(.dst0d, .tmp0), .src0d, ._, ._ }, | 117729 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117725 | .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, | 117730 | }, |
| 117726 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, | 117731 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| 117727 | } }, | 117732 | .clobbers = .{ .eflags = true }, |
| 117728 | }, .{ | 117733 | .each = .{ .once = &.{ |
| 117729 | .required_features = .{ .avx2, null, null, null }, | 117734 | .{ ._, ._, .@"test", .src0b, .ua(.src0, .add_umax), ._, ._ }, |
| 117730 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, | 117735 | } }, |
| 117731 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, | 117736 | }, .{ |
| 117732 | .patterns = &.{ | 117737 | .required_features = .{ .popcnt, null, null, null }, |
| 117733 | .{ .src = .{ .mem, .none, .none } }, | 117738 | .dst_constraints = .{ .bool, .any }, |
| 117734 | .{ .src = .{ .to_sse, .none, .none } }, | 117739 | .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any }, |
| 117735 | }, | 117740 | .patterns = &.{ |
| 117736 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117741 | .{ .src = .{ .mem, .none, .none } }, |
| 117737 | .each = .{ .once = &.{ | 117742 | }, |
| 117738 | .{ ._, .vp_q, .broadcast, .dst0x, .src0q, ._, ._ }, | 117743 | .extra_temps = .{ |
| 117739 | } }, | 117744 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 117740 | }, .{ | 117745 | .unused, |
| 117741 | .required_features = .{ .avx2, null, null, null }, | 117746 | .unused, |
| 117742 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, | 117747 | .unused, |
| 117743 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 117748 | .unused, |
| 117744 | .patterns = &.{ | 117749 | .unused, |
| 117745 | .{ .src = .{ .mem, .none, .none } }, | 117750 | .unused, |
| 117746 | .{ .src = .{ .to_sse, .none, .none } }, | 117751 | .unused, |
| 117747 | }, | 117752 | .unused, |
| 117748 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117753 | .unused, |
| 117749 | .each = .{ .once = &.{ | 117754 | .unused, |
| 117750 | .{ ._, .v_, .movddup, .dst0x, .src0q, ._, ._ }, | 117755 | }, |
| 117751 | } }, | 117756 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117752 | }, .{ | 117757 | .clobbers = .{ .eflags = true }, |
| 117753 | .required_features = .{ .avx, null, null, null }, | 117758 | .each = .{ .once = &.{ |
| 117754 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any }, | 117759 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| 117755 | .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any }, | 117760 | .{ ._, ._, .popcnt, .tmp0w, .src0w, ._, ._ }, |
| 117756 | .patterns = &.{ | 117761 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| 117757 | .{ .src = .{ .mem, .none, .none } }, | 117762 | } }, |
| 117758 | .{ .src = .{ .to_sse, .none, .none } }, | 117763 | }, .{ |
| 117759 | }, | 117764 | .required_features = .{ .popcnt, null, null, null }, |
| 117760 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117765 | .dst_constraints = .{ .bool, .any }, |
| 117761 | .each = .{ .once = &.{ | 117766 | .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any }, |
| 117762 | .{ ._, .v_, .movddup, .dst0x, .src0q, ._, ._ }, | 117767 | .patterns = &.{ |
| 117763 | } }, | 117768 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117764 | }, .{ | 117769 | }, |
| 117765 | .required_features = .{ .sse3, null, null, null }, | 117770 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117766 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any }, | 117771 | .clobbers = .{ .eflags = true }, |
| 117767 | .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any }, | 117772 | .each = .{ .once = &.{ |
| 117768 | .patterns = &.{ | 117773 | .{ ._, ._, .popcnt, .src0w, .src0w, ._, ._ }, |
| 117769 | .{ .src = .{ .mem, .none, .none } }, | 117774 | .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ }, |
| 117770 | .{ .src = .{ .to_sse, .none, .none } }, | 117775 | } }, |
| 117771 | }, | 117776 | }, .{ |
| 117772 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117777 | .dst_constraints = .{ .bool, .any }, |
| 117773 | .each = .{ .once = &.{ | 117778 | .src_constraints = .{ .{ .exact_bool_vec = 16 }, .any, .any }, |
| 117774 | .{ ._, ._, .movddup, .dst0x, .src0q, ._, ._ }, | 117779 | .patterns = &.{ |
| 117775 | } }, | 117780 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117776 | }, .{ | 117781 | }, |
| 117777 | .required_features = .{ .sse2, null, null, null }, | 117782 | .extra_temps = .{ |
| 117778 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, | 117783 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 117779 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, | 117784 | .unused, |
| 117780 | .patterns = &.{ | 117785 | .unused, |
| 117781 | .{ .src = .{ .to_sse, .none, .none } }, | 117786 | .unused, |
| 117782 | }, | 117787 | .unused, |
| 117783 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117788 | .unused, |
| 117784 | .each = .{ .once = &.{ | 117789 | .unused, |
| 117785 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ }, | 117790 | .unused, |
| 117786 | } }, | 117791 | .unused, |
| 117787 | }, .{ | 117792 | .unused, |
| 117788 | .required_features = .{ .sse2, null, null, null }, | 117793 | .unused, |
| 117789 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, | 117794 | }, |
| 117790 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 117795 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| 117791 | .patterns = &.{ | 117796 | .clobbers = .{ .eflags = true }, |
| 117792 | .{ .src = .{ .mut_sse, .none, .none } }, | 117797 | .each = .{ .once = &.{ |
| 117793 | }, | 117798 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 117794 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 117799 | .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ }, |
| 117795 | .each = .{ .once = &.{ | 117800 | .{ ._, ._, .xor, .tmp0b, .src0b, ._, ._ }, |
| 117796 | .{ ._, ._pd, .shuf, .dst0x, .src0x, .ui(0b0_0), ._ }, | 117801 | } }, |
| 117797 | } }, | 117802 | }, .{ |
| 117798 | }, .{ | 117803 | .required_features = .{ .popcnt, .fast_imm16, null, null }, |
| 117799 | .required_features = .{ .sse2, null, null, null }, | 117804 | .dst_constraints = .{ .bool, .any }, |
| 117800 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, | 117805 | .src_constraints = .{ .{ .bool_vec = .word }, .any, .any }, |
| 117801 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 117806 | .patterns = &.{ |
| 117802 | .patterns = &.{ | 117807 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117803 | .{ .src = .{ .sse, .none, .none } }, | 117808 | }, |
| 117804 | }, | 117809 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117805 | .dst_temps = .{ .{ .rc = .sse }, .unused }, | 117810 | .clobbers = .{ .eflags = true }, |
| 117806 | .each = .{ .once = &.{ | 117811 | .each = .{ .once = &.{ |
| 117807 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ }, | 117812 | .{ ._, ._, .@"and", .src0w, .ua(.src0, .add_umax), ._, ._ }, |
| 117808 | } }, | 117813 | .{ ._, ._, .popcnt, .src0w, .src0w, ._, ._ }, |
| 117809 | }, .{ | 117814 | .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ }, |
| 117810 | .required_features = .{ .sse2, null, null, null }, | 117815 | } }, |
| 117811 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, | 117816 | }, .{ |
| 117812 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 117817 | .required_features = .{ .popcnt, null, null, null }, |
| 117813 | .patterns = &.{ | 117818 | .dst_constraints = .{ .bool, .any }, |
| 117814 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117819 | .src_constraints = .{ .{ .bool_vec = .word }, .any, .any }, |
| 117815 | }, | 117820 | .patterns = &.{ |
| 117816 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 117821 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 117817 | .each = .{ .once = &.{ | 117822 | }, |
| 117818 | .{ ._, ._pd, .shuf, .dst0x, .src0x, .ui(0b0_0), ._ }, | 117823 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| 117819 | } }, | 117824 | .clobbers = .{ .eflags = true }, |
| 117820 | }, .{ | 117825 | .each = .{ .once = &.{ |
| 117821 | .required_features = .{ .sse, null, null, null }, | 117826 | .{ ._, ._, .@"and", .src0d, .ua(.src0, .add_umax), ._, ._ }, |
| 117822 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any }, | 117827 | .{ ._, ._, .popcnt, .src0d, .src0d, ._, ._ }, |
| 117823 | .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any }, | 117828 | .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ }, |
| 117824 | .patterns = &.{ | 117829 | } }, |
| 117825 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 117830 | }, .{ |
| 117826 | }, | 117831 | .dst_constraints = .{ .bool, .any }, |
| 117827 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 117832 | .src_constraints = .{ .{ .bool_vec = .word }, .any, .any }, |
| 117828 | .each = .{ .once = &.{ | 117833 | .patterns = &.{ |
| 117829 | .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ }, | 117834 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 117830 | } }, | 117835 | }, |
| 117831 | }, .{ | 117836 | .extra_temps = .{ |
| 117832 | .required_features = .{ .avx2, null, null, null }, | 117837 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 117833 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any }, | 117838 | .unused, |
| 117834 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, | 117839 | .unused, |
| 117835 | .patterns = &.{ | 117840 | .unused, |
| 117836 | .{ .src = .{ .mem, .none, .none } }, | 117841 | .unused, |
| 117837 | .{ .src = .{ .to_sse, .none, .none } }, | 117842 | .unused, |
| 117838 | }, | 117843 | .unused, |
| 117839 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117844 | .unused, |
| 117840 | .each = .{ .once = &.{ | 117845 | .unused, |
| 117841 | .{ ._, .vp_q, .broadcast, .dst0y, .src0q, ._, ._ }, | 117846 | .unused, |
| 117842 | } }, | 117847 | .unused, |
| 117843 | }, .{ | 117848 | }, |
| 117844 | .required_features = .{ .avx2, null, null, null }, | 117849 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| 117845 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any }, | 117850 | .clobbers = .{ .eflags = true }, |
| 117846 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 117851 | .each = .{ .once = &.{ |
| 117847 | .patterns = &.{ | 117852 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 117848 | .{ .src = .{ .mem, .none, .none } }, | 117853 | .{ ._, ._r, .sh, .tmp0d, .ui(8), ._, ._ }, |
| 117849 | .{ .src = .{ .to_sse, .none, .none } }, | 117854 | .{ ._, ._, .@"and", .tmp0b, .ua(.src0b, .add_umax), ._, ._ }, |
| 117850 | }, | 117855 | .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ }, |
| 117851 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, | 117856 | } }, |
| 117852 | .each = .{ .once = &.{ | 117857 | }, .{ |
| 117853 | .{ ._, .v_sd, .broadcast, .dst0y, .src0q, ._, ._ }, | 117858 | .required_features = .{ .popcnt, .false_deps_popcnt, null, null }, |
| | 117859 | .dst_constraints = .{ .bool, .any }, |
| | 117860 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| | 117861 | .patterns = &.{ |
| | 117862 | .{ .src = .{ .mem, .none, .none } }, |
| | 117863 | }, |
| | 117864 | .extra_temps = .{ |
| | 117865 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 117866 | .unused, |
| | 117867 | .unused, |
| | 117868 | .unused, |
| | 117869 | .unused, |
| | 117870 | .unused, |
| | 117871 | .unused, |
| | 117872 | .unused, |
| | 117873 | .unused, |
| | 117874 | .unused, |
| | 117875 | .unused, |
| | 117876 | }, |
| | 117877 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 117878 | .clobbers = .{ .eflags = true }, |
| | 117879 | .each = .{ .once = &.{ |
| | 117880 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 117881 | .{ ._, ._, .popcnt, .tmp0d, .src0d, ._, ._ }, |
| | 117882 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| | 117883 | } }, |
| | 117884 | }, .{ |
| | 117885 | .required_features = .{ .popcnt, .false_deps_popcnt, null, null }, |
| | 117886 | .dst_constraints = .{ .bool, .any }, |
| | 117887 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| | 117888 | .patterns = &.{ |
| | 117889 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 117890 | }, |
| | 117891 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 117892 | .clobbers = .{ .eflags = true }, |
| | 117893 | .each = .{ .once = &.{ |
| | 117894 | .{ ._, ._, .popcnt, .src0d, .src0d, ._, ._ }, |
| | 117895 | .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ }, |
| | 117896 | } }, |
| | 117897 | }, .{ |
| | 117898 | .required_features = .{ .popcnt, null, null, null }, |
| | 117899 | .dst_constraints = .{ .bool, .any }, |
| | 117900 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| | 117901 | .patterns = &.{ |
| | 117902 | .{ .src = .{ .mem, .none, .none } }, |
| | 117903 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 117904 | }, |
| | 117905 | .extra_temps = .{ |
| | 117906 | .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 117907 | .unused, |
| | 117908 | .unused, |
| | 117909 | .unused, |
| | 117910 | .unused, |
| | 117911 | .unused, |
| | 117912 | .unused, |
| | 117913 | .unused, |
| | 117914 | .unused, |
| | 117915 | .unused, |
| | 117916 | .unused, |
| | 117917 | }, |
| | 117918 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 117919 | .clobbers = .{ .eflags = true }, |
| | 117920 | .each = .{ .once = &.{ |
| | 117921 | .{ ._, ._, .popcnt, .tmp0d, .src0d, ._, ._ }, |
| | 117922 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| | 117923 | } }, |
| | 117924 | }, .{ |
| | 117925 | .dst_constraints = .{ .bool, .any }, |
| | 117926 | .src_constraints = .{ .{ .exact_bool_vec = 32 }, .any, .any }, |
| | 117927 | .patterns = &.{ |
| | 117928 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 117929 | }, |
| | 117930 | .extra_temps = .{ |
| | 117931 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 117932 | .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 117933 | .unused, |
| | 117934 | .unused, |
| | 117935 | .unused, |
| | 117936 | .unused, |
| | 117937 | .unused, |
| | 117938 | .unused, |
| | 117939 | .unused, |
| | 117940 | .unused, |
| | 117941 | .unused, |
| | 117942 | }, |
| | 117943 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 117944 | .clobbers = .{ .eflags = true }, |
| | 117945 | .each = .{ .once = &.{ |
| | 117946 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 117947 | .{ ._, ._r, .sh, .tmp0d, .ui(16), ._, ._ }, |
| | 117948 | .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ }, |
| | 117949 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 117950 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 117951 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 117952 | } }, |
| | 117953 | }, .{ |
| | 117954 | .required_features = .{ .popcnt, null, null, null }, |
| | 117955 | .dst_constraints = .{ .bool, .any }, |
| | 117956 | .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any }, |
| | 117957 | .patterns = &.{ |
| | 117958 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 117959 | }, |
| | 117960 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 117961 | .clobbers = .{ .eflags = true }, |
| | 117962 | .each = .{ .once = &.{ |
| | 117963 | .{ ._, ._, .@"and", .src0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 117964 | .{ ._, ._, .popcnt, .src0d, .src0d, ._, ._ }, |
| | 117965 | .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ }, |
| | 117966 | } }, |
| | 117967 | }, .{ |
| | 117968 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 117969 | .dst_constraints = .{ .bool, .any }, |
| | 117970 | .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any }, |
| | 117971 | .patterns = &.{ |
| | 117972 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 117973 | }, |
| | 117974 | .extra_temps = .{ |
| | 117975 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 117976 | .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 117977 | .unused, |
| | 117978 | .unused, |
| | 117979 | .unused, |
| | 117980 | .unused, |
| | 117981 | .unused, |
| | 117982 | .unused, |
| | 117983 | .unused, |
| | 117984 | .unused, |
| | 117985 | .unused, |
| | 117986 | }, |
| | 117987 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 117988 | .clobbers = .{ .eflags = true }, |
| | 117989 | .each = .{ .once = &.{ |
| | 117990 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 117991 | .{ ._, ._r, .sh, .tmp0d, .ui(16), ._, ._ }, |
| | 117992 | .{ ._, ._, .@"and", .tmp0d, .ua(.src0w, .add_umax), ._, ._ }, |
| | 117993 | .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ }, |
| | 117994 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 117995 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 117996 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 117997 | } }, |
| | 117998 | }, .{ |
| | 117999 | .dst_constraints = .{ .bool, .any }, |
| | 118000 | .src_constraints = .{ .{ .bool_vec = .dword }, .any, .any }, |
| | 118001 | .patterns = &.{ |
| | 118002 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 118003 | }, |
| | 118004 | .extra_temps = .{ |
| | 118005 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 118006 | .{ .type = .u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 118007 | .unused, |
| | 118008 | .unused, |
| | 118009 | .unused, |
| | 118010 | .unused, |
| | 118011 | .unused, |
| | 118012 | .unused, |
| | 118013 | .unused, |
| | 118014 | .unused, |
| | 118015 | .unused, |
| | 118016 | }, |
| | 118017 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 118018 | .clobbers = .{ .eflags = true }, |
| | 118019 | .each = .{ .once = &.{ |
| | 118020 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| | 118021 | .{ ._, ._r, .sh, .tmp0d, .ui(16), ._, ._ }, |
| | 118022 | .{ ._, ._, .@"and", .tmp0d, .ua(.src0w, .add_umax), ._, ._ }, |
| | 118023 | .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ }, |
| | 118024 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118025 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 118026 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 118027 | } }, |
| | 118028 | }, .{ |
| | 118029 | .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null }, |
| | 118030 | .dst_constraints = .{ .bool, .any }, |
| | 118031 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| | 118032 | .patterns = &.{ |
| | 118033 | .{ .src = .{ .mem, .none, .none } }, |
| | 118034 | }, |
| | 118035 | .extra_temps = .{ |
| | 118036 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118037 | .unused, |
| | 118038 | .unused, |
| | 118039 | .unused, |
| | 118040 | .unused, |
| | 118041 | .unused, |
| | 118042 | .unused, |
| | 118043 | .unused, |
| | 118044 | .unused, |
| | 118045 | .unused, |
| | 118046 | .unused, |
| | 118047 | }, |
| | 118048 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 118049 | .clobbers = .{ .eflags = true }, |
| | 118050 | .each = .{ .once = &.{ |
| | 118051 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 118052 | .{ ._, ._, .popcnt, .tmp0q, .src0q, ._, ._ }, |
| | 118053 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| | 118054 | } }, |
| | 118055 | }, .{ |
| | 118056 | .required_features = .{ .@"64bit", .popcnt, .false_deps_popcnt, null }, |
| | 118057 | .dst_constraints = .{ .bool, .any }, |
| | 118058 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| | 118059 | .patterns = &.{ |
| | 118060 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 118061 | }, |
| | 118062 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 118063 | .clobbers = .{ .eflags = true }, |
| | 118064 | .each = .{ .once = &.{ |
| | 118065 | .{ ._, ._, .popcnt, .src0q, .src0q, ._, ._ }, |
| | 118066 | .{ ._, ._, .@"and", .src0b, .ui(1), ._, ._ }, |
| | 118067 | } }, |
| | 118068 | }, .{ |
| | 118069 | .required_features = .{ .@"64bit", .popcnt, null, null }, |
| | 118070 | .dst_constraints = .{ .bool, .any }, |
| | 118071 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| | 118072 | .patterns = &.{ |
| | 118073 | .{ .src = .{ .mem, .none, .none } }, |
| | 118074 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 118075 | }, |
| | 118076 | .extra_temps = .{ |
| | 118077 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 118078 | .unused, |
| | 118079 | .unused, |
| | 118080 | .unused, |
| | 118081 | .unused, |
| | 118082 | .unused, |
| | 118083 | .unused, |
| | 118084 | .unused, |
| | 118085 | .unused, |
| | 118086 | .unused, |
| | 118087 | .unused, |
| | 118088 | }, |
| | 118089 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 118090 | .clobbers = .{ .eflags = true }, |
| | 118091 | .each = .{ .once = &.{ |
| | 118092 | .{ ._, ._, .popcnt, .tmp0q, .src0q, ._, ._ }, |
| | 118093 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| | 118094 | } }, |
| | 118095 | }, .{ |
| | 118096 | .dst_constraints = .{ .bool, .any }, |
| | 118097 | .src_constraints = .{ .{ .exact_bool_vec = 64 }, .any, .any }, |
| | 118098 | .patterns = &.{ |
| | 118099 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 118100 | }, |
| | 118101 | .extra_temps = .{ |
| | 118102 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118103 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 118104 | .unused, |
| | 118105 | .unused, |
| | 118106 | .unused, |
| | 118107 | .unused, |
| | 118108 | .unused, |
| | 118109 | .unused, |
| | 118110 | .unused, |
| | 118111 | .unused, |
| | 118112 | .unused, |
| | 118113 | }, |
| | 118114 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 118115 | .clobbers = .{ .eflags = true }, |
| | 118116 | .each = .{ .once = &.{ |
| | 118117 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| | 118118 | .{ ._, ._r, .sh, .tmp0q, .ui(32), ._, ._ }, |
| | 118119 | .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ }, |
| | 118120 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118121 | .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ }, |
| | 118122 | .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ }, |
| | 118123 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118124 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 118125 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 118126 | } }, |
| | 118127 | }, .{ |
| | 118128 | .required_features = .{ .@"64bit", .popcnt, null, null }, |
| | 118129 | .dst_constraints = .{ .bool, .any }, |
| | 118130 | .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any }, |
| | 118131 | .patterns = &.{ |
| | 118132 | .{ .src = .{ .mem, .none, .none } }, |
| | 118133 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 118134 | }, |
| | 118135 | .extra_temps = .{ |
| | 118136 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118137 | .unused, |
| | 118138 | .unused, |
| | 118139 | .unused, |
| | 118140 | .unused, |
| | 118141 | .unused, |
| | 118142 | .unused, |
| | 118143 | .unused, |
| | 118144 | .unused, |
| | 118145 | .unused, |
| | 118146 | .unused, |
| | 118147 | }, |
| | 118148 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 118149 | .clobbers = .{ .eflags = true }, |
| | 118150 | .each = .{ .once = &.{ |
| | 118151 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 118152 | .{ ._, ._, .@"and", .tmp0q, .src0q, ._, ._ }, |
| | 118153 | .{ ._, ._, .popcnt, .tmp0q, .tmp0q, ._, ._ }, |
| | 118154 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| | 118155 | } }, |
| | 118156 | }, .{ |
| | 118157 | .dst_constraints = .{ .bool, .any }, |
| | 118158 | .src_constraints = .{ .{ .bool_vec = .qword }, .any, .any }, |
| | 118159 | .patterns = &.{ |
| | 118160 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 118161 | }, |
| | 118162 | .extra_temps = .{ |
| | 118163 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118164 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| | 118165 | .unused, |
| | 118166 | .unused, |
| | 118167 | .unused, |
| | 118168 | .unused, |
| | 118169 | .unused, |
| | 118170 | .unused, |
| | 118171 | .unused, |
| | 118172 | .unused, |
| | 118173 | .unused, |
| | 118174 | }, |
| | 118175 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 118176 | .clobbers = .{ .eflags = true }, |
| | 118177 | .each = .{ .once = &.{ |
| | 118178 | .{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ }, |
| | 118179 | .{ ._, ._r, .sh, .tmp0q, .ui(32), ._, ._ }, |
| | 118180 | .{ ._, ._, .@"and", .tmp0d, .ua(.src0d, .add_umax), ._, ._ }, |
| | 118181 | .{ ._, ._, .xor, .tmp0d, .src0d, ._, ._ }, |
| | 118182 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118183 | .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ }, |
| | 118184 | .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ }, |
| | 118185 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118186 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 118187 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 118188 | } }, |
| | 118189 | }, .{ |
| | 118190 | .required_features = .{ .@"64bit", .popcnt, null, null }, |
| | 118191 | .dst_constraints = .{ .bool, .any }, |
| | 118192 | .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any }, |
| | 118193 | .patterns = &.{ |
| | 118194 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 118195 | }, |
| | 118196 | .extra_temps = .{ |
| | 118197 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 118198 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118199 | .unused, |
| | 118200 | .unused, |
| | 118201 | .unused, |
| | 118202 | .unused, |
| | 118203 | .unused, |
| | 118204 | .unused, |
| | 118205 | .unused, |
| | 118206 | .unused, |
| | 118207 | .unused, |
| | 118208 | }, |
| | 118209 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 118210 | .clobbers = .{ .eflags = true }, |
| | 118211 | .each = .{ .once = &.{ |
| | 118212 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ }, |
| | 118213 | .{ ._, ._, .xor, .tmp1q, .tmp1q, ._, ._ }, |
| | 118214 | .{ .@"0:", ._, .xor, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 118215 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 118216 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 118217 | .{ ._, ._, .popcnt, .tmp1q, .tmp1q, ._, ._ }, |
| | 118218 | .{ ._, ._, .@"and", .tmp1b, .ui(1), ._, ._ }, |
| | 118219 | } }, |
| | 118220 | }, .{ |
| | 118221 | .required_features = .{ .@"64bit", null, null, null }, |
| | 118222 | .dst_constraints = .{ .bool, .any }, |
| | 118223 | .src_constraints = .{ .{ .exact_remainder_bool_vec = .{ .of = .qword, .is = 64 } }, .any, .any }, |
| | 118224 | .patterns = &.{ |
| | 118225 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 118226 | }, |
| | 118227 | .extra_temps = .{ |
| | 118228 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 118229 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118230 | .unused, |
| | 118231 | .unused, |
| | 118232 | .unused, |
| | 118233 | .unused, |
| | 118234 | .unused, |
| | 118235 | .unused, |
| | 118236 | .unused, |
| | 118237 | .unused, |
| | 118238 | .unused, |
| | 118239 | }, |
| | 118240 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 118241 | .clobbers = .{ .eflags = true }, |
| | 118242 | .each = .{ .once = &.{ |
| | 118243 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_bit_size_div_8), ._, ._ }, |
| | 118244 | .{ ._, ._, .xor, .tmp1q, .tmp1q, ._, ._ }, |
| | 118245 | .{ .@"0:", ._, .xor, .tmp1q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 118246 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 118247 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 118248 | .{ ._, ._, .mov, .tmp0d, .tmp1d, ._, ._ }, |
| | 118249 | .{ ._, ._r, .sh, .tmp1q, .ui(32), ._, ._ }, |
| | 118250 | .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ }, |
| | 118251 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118252 | .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ }, |
| | 118253 | .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ }, |
| | 118254 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118255 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 118256 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 118257 | } }, |
| | 118258 | }, .{ |
| | 118259 | .required_features = .{ .@"64bit", .popcnt, null, null }, |
| | 118260 | .dst_constraints = .{ .bool, .any }, |
| | 118261 | .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| | 118262 | .patterns = &.{ |
| | 118263 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 118264 | }, |
| | 118265 | .extra_temps = .{ |
| | 118266 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118267 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 118268 | .unused, |
| | 118269 | .unused, |
| | 118270 | .unused, |
| | 118271 | .unused, |
| | 118272 | .unused, |
| | 118273 | .unused, |
| | 118274 | .unused, |
| | 118275 | .unused, |
| | 118276 | .unused, |
| | 118277 | }, |
| | 118278 | .dst_temps = .{ .{ .cc = .nz }, .unused }, |
| | 118279 | .clobbers = .{ .eflags = true }, |
| | 118280 | .each = .{ .once = &.{ |
| | 118281 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 118282 | .{ ._, ._, .mov, .tmp1d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ }, |
| | 118283 | .{ ._, ._, .@"and", .tmp0q, .mema(.src0q, .add_bit_size_div_8_down_8), ._, ._ }, |
| | 118284 | .{ .@"0:", ._, .xor, .tmp0q, .memi(.src0q, .tmp1), ._, ._ }, |
| | 118285 | .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, |
| | 118286 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 118287 | .{ ._, ._, .popcnt, .tmp0q, .tmp0q, ._, ._ }, |
| | 118288 | .{ ._, ._, .@"and", .tmp0b, .ui(1), ._, ._ }, |
| | 118289 | } }, |
| | 118290 | }, .{ |
| | 118291 | .required_features = .{ .@"64bit", null, null, null }, |
| | 118292 | .dst_constraints = .{ .bool, .any }, |
| | 118293 | .src_constraints = .{ .{ .remainder_bool_vec = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| | 118294 | .patterns = &.{ |
| | 118295 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 118296 | }, |
| | 118297 | .extra_temps = .{ |
| | 118298 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 118299 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 118300 | .unused, |
| | 118301 | .unused, |
| | 118302 | .unused, |
| | 118303 | .unused, |
| | 118304 | .unused, |
| | 118305 | .unused, |
| | 118306 | .unused, |
| | 118307 | .unused, |
| | 118308 | .unused, |
| | 118309 | }, |
| | 118310 | .dst_temps = .{ .{ .cc = .po }, .unused }, |
| | 118311 | .clobbers = .{ .eflags = true }, |
| | 118312 | .each = .{ .once = &.{ |
| | 118313 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 118314 | .{ ._, ._, .mov, .tmp1d, .sia(-8, .src0, .add_bit_size_div_8_down_8), ._, ._ }, |
| | 118315 | .{ ._, ._, .@"and", .tmp0q, .mema(.src0q, .add_bit_size_div_8_down_8), ._, ._ }, |
| | 118316 | .{ .@"0:", ._, .xor, .tmp0q, .memi(.src0q, .tmp1), ._, ._ }, |
| | 118317 | .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, |
| | 118318 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 118319 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118320 | .{ ._, ._r, .sh, .tmp0q, .ui(32), ._, ._ }, |
| | 118321 | .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ }, |
| | 118322 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118323 | .{ ._, ._r, .sh, .tmp1d, .ui(16), ._, ._ }, |
| | 118324 | .{ ._, ._, .xor, .tmp0d, .tmp1d, ._, ._ }, |
| | 118325 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| | 118326 | .{ ._, ._r, .sh, .tmp1d, .ui(8), ._, ._ }, |
| | 118327 | .{ ._, ._, .xor, .tmp0b, .tmp1b, ._, ._ }, |
| | 118328 | } }, |
| | 118329 | } }, |
| | 118330 | } ++ [_]Select.Case{ .{ |
| | 118331 | .required_features = .{ .sse, null, null, null }, |
| | 118332 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118333 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 118334 | .patterns = &.{ |
| | 118335 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 118336 | .{ .src = .{ .mut_gpr, .none, .none } }, |
| | 118337 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118338 | }, |
| | 118339 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118340 | .each = .{ .once = &.{} }, |
| | 118341 | }, .{ |
| | 118342 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118343 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 118344 | .patterns = &.{ |
| | 118345 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 118346 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 118347 | }, |
| | 118348 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118349 | .each = .{ .once = &.{} }, |
| | 118350 | }, .{ |
| | 118351 | .required_features = .{ .avx, null, null, null }, |
| | 118352 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118353 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| | 118354 | .patterns = &.{ |
| | 118355 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118356 | }, |
| | 118357 | .extra_temps = .{ |
| | 118358 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118359 | .unused, |
| | 118360 | .unused, |
| | 118361 | .unused, |
| | 118362 | .unused, |
| | 118363 | .unused, |
| | 118364 | .unused, |
| | 118365 | .unused, |
| | 118366 | .unused, |
| | 118367 | .unused, |
| | 118368 | .unused, |
| | 118369 | }, |
| | 118370 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118371 | .each = .{ .once = &.{ |
| | 118372 | .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ }, |
| | 118373 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118374 | } }, |
| | 118375 | }, .{ |
| | 118376 | .required_features = .{ .sse2, null, null, null }, |
| | 118377 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118378 | .src_constraints = .{ .{ .scalar_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| | 118379 | .patterns = &.{ |
| | 118380 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118381 | }, |
| | 118382 | .extra_temps = .{ |
| | 118383 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118384 | .unused, |
| | 118385 | .unused, |
| | 118386 | .unused, |
| | 118387 | .unused, |
| | 118388 | .unused, |
| | 118389 | .unused, |
| | 118390 | .unused, |
| | 118391 | .unused, |
| | 118392 | .unused, |
| | 118393 | .unused, |
| | 118394 | }, |
| | 118395 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118396 | .each = .{ .once = &.{ |
| | 118397 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| | 118398 | .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ }, |
| | 118399 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118400 | } }, |
| | 118401 | }, .{ |
| | 118402 | .required_features = .{ .avx, null, null, null }, |
| | 118403 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118404 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 118405 | .patterns = &.{ |
| | 118406 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118407 | }, |
| | 118408 | .extra_temps = .{ |
| | 118409 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118410 | .unused, |
| | 118411 | .unused, |
| | 118412 | .unused, |
| | 118413 | .unused, |
| | 118414 | .unused, |
| | 118415 | .unused, |
| | 118416 | .unused, |
| | 118417 | .unused, |
| | 118418 | .unused, |
| | 118419 | .unused, |
| | 118420 | }, |
| | 118421 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118422 | .each = .{ .once = &.{ |
| | 118423 | .{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ }, |
| | 118424 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118425 | .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ }, |
| | 118426 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118427 | } }, |
| | 118428 | }, .{ |
| | 118429 | .required_features = .{ .sse2, null, null, null }, |
| | 118430 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118431 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 118432 | .patterns = &.{ |
| | 118433 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118434 | }, |
| | 118435 | .extra_temps = .{ |
| | 118436 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118437 | .unused, |
| | 118438 | .unused, |
| | 118439 | .unused, |
| | 118440 | .unused, |
| | 118441 | .unused, |
| | 118442 | .unused, |
| | 118443 | .unused, |
| | 118444 | .unused, |
| | 118445 | .unused, |
| | 118446 | .unused, |
| | 118447 | }, |
| | 118448 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118449 | .each = .{ .once = &.{ |
| | 118450 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| | 118451 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 118452 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118453 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 118454 | .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ }, |
| | 118455 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118456 | } }, |
| | 118457 | }, .{ |
| | 118458 | .required_features = .{ .avx, null, null, null }, |
| | 118459 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118460 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 118461 | .patterns = &.{ |
| | 118462 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118463 | }, |
| | 118464 | .extra_temps = .{ |
| | 118465 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118466 | .unused, |
| | 118467 | .unused, |
| | 118468 | .unused, |
| | 118469 | .unused, |
| | 118470 | .unused, |
| | 118471 | .unused, |
| | 118472 | .unused, |
| | 118473 | .unused, |
| | 118474 | .unused, |
| | 118475 | .unused, |
| | 118476 | }, |
| | 118477 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 118478 | .each = .{ .once = &.{ |
| | 118479 | .{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ }, |
| | 118480 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118481 | .{ ._, .vp_w, .srl, .tmp0x, .src0x, .ui(8), ._ }, |
| | 118482 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118483 | } }, |
| | 118484 | }, .{ |
| | 118485 | .required_features = .{ .sse2, null, null, null }, |
| | 118486 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118487 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| | 118488 | .patterns = &.{ |
| | 118489 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118490 | }, |
| | 118491 | .extra_temps = .{ |
| | 118492 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118493 | .unused, |
| | 118494 | .unused, |
| | 118495 | .unused, |
| | 118496 | .unused, |
| | 118497 | .unused, |
| | 118498 | .unused, |
| | 118499 | .unused, |
| | 118500 | .unused, |
| | 118501 | .unused, |
| | 118502 | .unused, |
| | 118503 | }, |
| | 118504 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118505 | .each = .{ .once = &.{ |
| | 118506 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| | 118507 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 118508 | .{ ._, .p_, mir_tag, .tmp0x, .src0x, ._, ._ }, |
| | 118509 | .{ ._, .p_w, .srl, .dst0x, .ui(8), ._, ._ }, |
| | 118510 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118511 | } }, |
| | 118512 | }, .{ |
| | 118513 | .required_features = .{ .avx, null, null, null }, |
| | 118514 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118515 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 118516 | .patterns = &.{ |
| | 118517 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118518 | }, |
| | 118519 | .extra_temps = .{ |
| | 118520 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118521 | .unused, |
| | 118522 | .unused, |
| | 118523 | .unused, |
| | 118524 | .unused, |
| | 118525 | .unused, |
| | 118526 | .unused, |
| | 118527 | .unused, |
| | 118528 | .unused, |
| | 118529 | .unused, |
| | 118530 | .unused, |
| | 118531 | }, |
| | 118532 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118533 | .each = .{ .once = &.{ |
| | 118534 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 118535 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118536 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 118537 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118538 | .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ }, |
| | 118539 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118540 | } }, |
| | 118541 | }, .{ |
| | 118542 | .required_features = .{ .sse2, null, null, null }, |
| | 118543 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118544 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 118545 | .patterns = &.{ |
| | 118546 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118547 | }, |
| | 118548 | .extra_temps = .{ |
| | 118549 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118550 | .unused, |
| | 118551 | .unused, |
| | 118552 | .unused, |
| | 118553 | .unused, |
| | 118554 | .unused, |
| | 118555 | .unused, |
| | 118556 | .unused, |
| | 118557 | .unused, |
| | 118558 | .unused, |
| | 118559 | .unused, |
| | 118560 | }, |
| | 118561 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118562 | .each = .{ .once = &.{ |
| | 118563 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 118564 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118565 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 118566 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 118567 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118568 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 118569 | .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ }, |
| | 118570 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118571 | } }, |
| | 118572 | }, .{ |
| | 118573 | .required_features = .{ .avx, null, null, null }, |
| | 118574 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118575 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 118576 | .patterns = &.{ |
| | 118577 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118578 | }, |
| | 118579 | .extra_temps = .{ |
| | 118580 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 118581 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 118582 | .ref = .src0, |
| | 118583 | .invert = switch (mir_tag) { |
| | 118584 | else => unreachable, |
| | 118585 | .@"and" => true, |
| | 118586 | .@"or", .xor => false, |
| | 118587 | }, |
| | 118588 | } } }, |
| | 118589 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118590 | .unused, |
| | 118591 | .unused, |
| | 118592 | .unused, |
| | 118593 | .unused, |
| | 118594 | .unused, |
| | 118595 | .unused, |
| | 118596 | .unused, |
| | 118597 | .unused, |
| | 118598 | }, |
| | 118599 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118600 | .each = .{ .once = &.{ |
| | 118601 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 118602 | .{ ._, .vp_, switch (mir_tag) { |
| | 118603 | else => unreachable, |
| | 118604 | .@"and" => .@"or", |
| | 118605 | .@"or", .xor => .@"and", |
| | 118606 | }, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| | 118607 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118608 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118609 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 118610 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118611 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 118612 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118613 | } }, |
| | 118614 | }, .{ |
| | 118615 | .required_features = .{ .sse2, null, null, null }, |
| | 118616 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118617 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| | 118618 | .patterns = &.{ |
| | 118619 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118620 | }, |
| | 118621 | .extra_temps = .{ |
| | 118622 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 118623 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 118624 | .ref = .src0, |
| | 118625 | .invert = switch (mir_tag) { |
| | 118626 | else => unreachable, |
| | 118627 | .@"and" => true, |
| | 118628 | .@"or", .xor => false, |
| | 118629 | }, |
| | 118630 | } } }, |
| | 118631 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118632 | .unused, |
| | 118633 | .unused, |
| | 118634 | .unused, |
| | 118635 | .unused, |
| | 118636 | .unused, |
| | 118637 | .unused, |
| | 118638 | .unused, |
| | 118639 | .unused, |
| | 118640 | }, |
| | 118641 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118642 | .each = .{ .once = &.{ |
| | 118643 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 118644 | .{ ._, .p_, switch (mir_tag) { |
| | 118645 | else => unreachable, |
| | 118646 | .@"and" => .@"or", |
| | 118647 | .@"or", .xor => .@"and", |
| | 118648 | }, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 118649 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118650 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118651 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 118652 | .{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ }, |
| | 118653 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118654 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 118655 | .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ }, |
| | 118656 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118657 | } }, |
| | 118658 | }, .{ |
| | 118659 | .required_features = .{ .avx, null, null, null }, |
| | 118660 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118661 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 118662 | .patterns = &.{ |
| | 118663 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118664 | }, |
| | 118665 | .extra_temps = .{ |
| | 118666 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118667 | .unused, |
| | 118668 | .unused, |
| | 118669 | .unused, |
| | 118670 | .unused, |
| | 118671 | .unused, |
| | 118672 | .unused, |
| | 118673 | .unused, |
| | 118674 | .unused, |
| | 118675 | .unused, |
| | 118676 | .unused, |
| | 118677 | }, |
| | 118678 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118679 | .each = .{ .once = &.{ |
| | 118680 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 118681 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118682 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118683 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118684 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 118685 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118686 | .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ }, |
| | 118687 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118688 | } }, |
| | 118689 | }, .{ |
| | 118690 | .required_features = .{ .sse2, null, null, null }, |
| | 118691 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118692 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 118693 | .patterns = &.{ |
| | 118694 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118695 | }, |
| | 118696 | .extra_temps = .{ |
| | 118697 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118698 | .unused, |
| | 118699 | .unused, |
| | 118700 | .unused, |
| | 118701 | .unused, |
| | 118702 | .unused, |
| | 118703 | .unused, |
| | 118704 | .unused, |
| | 118705 | .unused, |
| | 118706 | .unused, |
| | 118707 | .unused, |
| | 118708 | }, |
| | 118709 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118710 | .each = .{ .once = &.{ |
| | 118711 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 118712 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118713 | .{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118714 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118715 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 118716 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 118717 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118718 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 118719 | .{ ._, .p_w, .srl, .tmp0x, .ui(8), ._, ._ }, |
| | 118720 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 118721 | } }, |
| | 118722 | }, .{ |
| | 118723 | .required_features = .{ .avx, null, null, null }, |
| | 118724 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118725 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 118726 | .patterns = &.{ |
| | 118727 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118728 | }, |
| | 118729 | .extra_temps = .{ |
| | 118730 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 118731 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 118732 | .ref = .src0, |
| | 118733 | .invert = switch (mir_tag) { |
| | 118734 | else => unreachable, |
| | 118735 | .@"and" => true, |
| | 118736 | .@"or", .xor => false, |
| | 118737 | }, |
| | 118738 | } } }, |
| | 118739 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118740 | .unused, |
| | 118741 | .unused, |
| | 118742 | .unused, |
| | 118743 | .unused, |
| | 118744 | .unused, |
| | 118745 | .unused, |
| | 118746 | .unused, |
| | 118747 | .unused, |
| | 118748 | }, |
| | 118749 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118750 | .each = .{ .once = &.{ |
| | 118751 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 118752 | .{ ._, .vp_, switch (mir_tag) { |
| | 118753 | else => unreachable, |
| | 118754 | .@"and" => .@"or", |
| | 118755 | .@"or", .xor => .@"and", |
| | 118756 | }, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| | 118757 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 118758 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118759 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118760 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118761 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 118762 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118763 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 118764 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118765 | } }, |
| | 118766 | }, .{ |
| | 118767 | .required_features = .{ .sse2, null, null, null }, |
| | 118768 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118769 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 118770 | .patterns = &.{ |
| | 118771 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 118772 | }, |
| | 118773 | .extra_temps = .{ |
| | 118774 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 118775 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 118776 | .ref = .src0, |
| | 118777 | .invert = switch (mir_tag) { |
| | 118778 | else => unreachable, |
| | 118779 | .@"and" => true, |
| | 118780 | .@"or", .xor => false, |
| | 118781 | }, |
| | 118782 | } } }, |
| | 118783 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118784 | .unused, |
| | 118785 | .unused, |
| | 118786 | .unused, |
| | 118787 | .unused, |
| | 118788 | .unused, |
| | 118789 | .unused, |
| | 118790 | .unused, |
| | 118791 | .unused, |
| | 118792 | }, |
| | 118793 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 118794 | .each = .{ .once = &.{ |
| | 118795 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 118796 | .{ ._, .p_, switch (mir_tag) { |
| | 118797 | else => unreachable, |
| | 118798 | .@"and" => .@"or", |
| | 118799 | .@"or", .xor => .@"and", |
| | 118800 | }, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 118801 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 118802 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118803 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118804 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118805 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 118806 | .{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ }, |
| | 118807 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118808 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 118809 | .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ }, |
| | 118810 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 118811 | } }, |
| | 118812 | }, .{ |
| | 118813 | .required_features = .{ .avx2, null, null, null }, |
| | 118814 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118815 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 118816 | .patterns = &.{ |
| | 118817 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118818 | }, |
| | 118819 | .extra_temps = .{ |
| | 118820 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118821 | .unused, |
| | 118822 | .unused, |
| | 118823 | .unused, |
| | 118824 | .unused, |
| | 118825 | .unused, |
| | 118826 | .unused, |
| | 118827 | .unused, |
| | 118828 | .unused, |
| | 118829 | .unused, |
| | 118830 | .unused, |
| | 118831 | }, |
| | 118832 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118833 | .each = .{ .once = &.{ |
| | 118834 | .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 118835 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118836 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 118837 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118838 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118839 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118840 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 118841 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118842 | .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ }, |
| | 118843 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118844 | } }, |
| | 118845 | }, .{ |
| | 118846 | .required_features = .{ .avx, null, null, null }, |
| | 118847 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118848 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 118849 | .patterns = &.{ |
| | 118850 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118851 | }, |
| | 118852 | .extra_temps = .{ |
| | 118853 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118854 | .unused, |
| | 118855 | .unused, |
| | 118856 | .unused, |
| | 118857 | .unused, |
| | 118858 | .unused, |
| | 118859 | .unused, |
| | 118860 | .unused, |
| | 118861 | .unused, |
| | 118862 | .unused, |
| | 118863 | .unused, |
| | 118864 | }, |
| | 118865 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118866 | .each = .{ .once = &.{ |
| | 118867 | .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 118868 | .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 118869 | .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ }, |
| | 118870 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118871 | .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 118872 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118873 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 118874 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118875 | .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ }, |
| | 118876 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118877 | } }, |
| | 118878 | }, .{ |
| | 118879 | .required_features = .{ .avx2, null, null, null }, |
| | 118880 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118881 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 118882 | .patterns = &.{ |
| | 118883 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118884 | }, |
| | 118885 | .extra_temps = .{ |
| | 118886 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 118887 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 118888 | .ref = .src0, |
| | 118889 | .invert = switch (mir_tag) { |
| | 118890 | else => unreachable, |
| | 118891 | .@"and" => true, |
| | 118892 | .@"or", .xor => false, |
| | 118893 | }, |
| | 118894 | } } }, |
| | 118895 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118896 | .unused, |
| | 118897 | .unused, |
| | 118898 | .unused, |
| | 118899 | .unused, |
| | 118900 | .unused, |
| | 118901 | .unused, |
| | 118902 | .unused, |
| | 118903 | .unused, |
| | 118904 | }, |
| | 118905 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118906 | .each = .{ .once = &.{ |
| | 118907 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 118908 | .{ ._, .vp_, switch (mir_tag) { |
| | 118909 | else => unreachable, |
| | 118910 | .@"and" => .@"or", |
| | 118911 | .@"or", .xor => .@"and", |
| | 118912 | }, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| | 118913 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 118914 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118915 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 118916 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118917 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118918 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118919 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 118920 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118921 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 118922 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118923 | } }, |
| | 118924 | }, .{ |
| | 118925 | .required_features = .{ .avx, null, null, null }, |
| | 118926 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118927 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 118928 | .patterns = &.{ |
| | 118929 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 118930 | }, |
| | 118931 | .extra_temps = .{ |
| | 118932 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 118933 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 118934 | .ref = .src0, |
| | 118935 | .invert = switch (mir_tag) { |
| | 118936 | else => unreachable, |
| | 118937 | .@"and" => true, |
| | 118938 | .@"or", .xor => false, |
| | 118939 | }, |
| | 118940 | } } }, |
| | 118941 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118942 | .unused, |
| | 118943 | .unused, |
| | 118944 | .unused, |
| | 118945 | .unused, |
| | 118946 | .unused, |
| | 118947 | .unused, |
| | 118948 | .unused, |
| | 118949 | .unused, |
| | 118950 | }, |
| | 118951 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118952 | .each = .{ .once = &.{ |
| | 118953 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 118954 | .{ ._, .v_ps, switch (mir_tag) { |
| | 118955 | else => unreachable, |
| | 118956 | .@"and" => .@"or", |
| | 118957 | .@"or", .xor => .@"and", |
| | 118958 | }, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| | 118959 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 118960 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118961 | .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ }, |
| | 118962 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118963 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 118964 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118965 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 118966 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118967 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 118968 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 118969 | } }, |
| | 118970 | }, .{ |
| | 118971 | .required_features = .{ .avx512f, null, null, null }, |
| | 118972 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 118973 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any }, |
| | 118974 | .patterns = &.{ |
| | 118975 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 118976 | }, |
| | 118977 | .extra_temps = .{ |
| | 118978 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 118979 | .unused, |
| | 118980 | .unused, |
| | 118981 | .unused, |
| | 118982 | .unused, |
| | 118983 | .unused, |
| | 118984 | .unused, |
| | 118985 | .unused, |
| | 118986 | .unused, |
| | 118987 | .unused, |
| | 118988 | .unused, |
| | 118989 | }, |
| | 118990 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 118991 | .each = .{ .once = &.{ |
| | 118992 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 118993 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ }, |
| | 118994 | .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, |
| | 118995 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118996 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 118997 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 118998 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 118999 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119000 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 119001 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119002 | .{ ._, .vp_w, .srl, .tmp0x, .dst0x, .ui(8), ._ }, |
| | 119003 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119004 | } }, |
| | 119005 | }, .{ |
| | 119006 | .required_features = .{ .avx512f, null, null, null }, |
| | 119007 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119008 | .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any }, |
| | 119009 | .patterns = &.{ |
| | 119010 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119011 | }, |
| | 119012 | .extra_temps = .{ |
| | 119013 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 119014 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119015 | .ref = .src0, |
| | 119016 | .invert = switch (mir_tag) { |
| | 119017 | else => unreachable, |
| | 119018 | .@"and" => true, |
| | 119019 | .@"or", .xor => false, |
| | 119020 | }, |
| | 119021 | } } }, |
| | 119022 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 119023 | .unused, |
| | 119024 | .unused, |
| | 119025 | .unused, |
| | 119026 | .unused, |
| | 119027 | .unused, |
| | 119028 | .unused, |
| | 119029 | .unused, |
| | 119030 | .unused, |
| | 119031 | }, |
| | 119032 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119033 | .each = .{ .once = &.{ |
| | 119034 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119035 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 119036 | .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ }, |
| | 119037 | .{ ._, .vp_, switch (mir_tag) { |
| | 119038 | else => unreachable, |
| | 119039 | .@"and" => .@"or", |
| | 119040 | .@"or", .xor => .@"and", |
| | 119041 | }, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 119042 | .{ ._, .vp_, switch (mir_tag) { |
| | 119043 | else => unreachable, |
| | 119044 | .@"and" => .@"or", |
| | 119045 | .@"or", .xor => .@"and", |
| | 119046 | }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ }, |
| | 119047 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 119048 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119049 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119050 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119051 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119052 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119053 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119054 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119055 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119056 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 119057 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119058 | } }, |
| | 119059 | }, .{ |
| | 119060 | .required_features = .{ .avx2, null, null, null }, |
| | 119061 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119062 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 119063 | .patterns = &.{ |
| | 119064 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119065 | }, |
| | 119066 | .extra_temps = .{ |
| | 119067 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119068 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 119069 | .unused, |
| | 119070 | .unused, |
| | 119071 | .unused, |
| | 119072 | .unused, |
| | 119073 | .unused, |
| | 119074 | .unused, |
| | 119075 | .unused, |
| | 119076 | .unused, |
| | 119077 | .unused, |
| | 119078 | }, |
| | 119079 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119080 | .each = .{ .once = &.{ |
| | 119081 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 119082 | .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 119083 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 119084 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 119085 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119086 | .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 119087 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119088 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119089 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119090 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119091 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119092 | .{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ }, |
| | 119093 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119094 | .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ }, |
| | 119095 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119096 | } }, |
| | 119097 | }, .{ |
| | 119098 | .required_features = .{ .avx, null, null, null }, |
| | 119099 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119100 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 119101 | .patterns = &.{ |
| | 119102 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119103 | }, |
| | 119104 | .extra_temps = .{ |
| | 119105 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119106 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 119107 | .unused, |
| | 119108 | .unused, |
| | 119109 | .unused, |
| | 119110 | .unused, |
| | 119111 | .unused, |
| | 119112 | .unused, |
| | 119113 | .unused, |
| | 119114 | .unused, |
| | 119115 | .unused, |
| | 119116 | }, |
| | 119117 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119118 | .each = .{ .once = &.{ |
| | 119119 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 119120 | .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 119121 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 119122 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 119123 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119124 | .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 119125 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119126 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 119127 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119128 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 119129 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119130 | .{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ }, |
| | 119131 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119132 | .{ ._, .vp_w, .srl, .tmp1x, .dst0x, .ui(8), ._ }, |
| | 119133 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 119134 | } }, |
| | 119135 | }, .{ |
| | 119136 | .required_features = .{ .sse2, null, null, null }, |
| | 119137 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119138 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 119139 | .patterns = &.{ |
| | 119140 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119141 | }, |
| | 119142 | .extra_temps = .{ |
| | 119143 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119144 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 119145 | .unused, |
| | 119146 | .unused, |
| | 119147 | .unused, |
| | 119148 | .unused, |
| | 119149 | .unused, |
| | 119150 | .unused, |
| | 119151 | .unused, |
| | 119152 | .unused, |
| | 119153 | .unused, |
| | 119154 | }, |
| | 119155 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119156 | .each = .{ .once = &.{ |
| | 119157 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, |
| | 119158 | .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ }, |
| | 119159 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 119160 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 119161 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119162 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119163 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 119164 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119165 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 119166 | .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ }, |
| | 119167 | .{ ._, .p_d, .srl, .tmp1x, .ui(16), ._, ._ }, |
| | 119168 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 119169 | .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ }, |
| | 119170 | .{ ._, .p_w, .srl, .tmp1x, .ui(8), ._, ._ }, |
| | 119171 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 119172 | } }, |
| | 119173 | }, .{ |
| | 119174 | .required_features = .{ .avx512f, null, null, null }, |
| | 119175 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119176 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .byte } }, .any, .any }, |
| | 119177 | .patterns = &.{ |
| | 119178 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119179 | }, |
| | 119180 | .extra_temps = .{ |
| | 119181 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119182 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119183 | .ref = .src0, |
| | 119184 | .invert = switch (mir_tag) { |
| | 119185 | else => unreachable, |
| | 119186 | .@"and" => true, |
| | 119187 | .@"or", .xor => false, |
| | 119188 | }, |
| | 119189 | } } }, |
| | 119190 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 119191 | .unused, |
| | 119192 | .unused, |
| | 119193 | .unused, |
| | 119194 | .unused, |
| | 119195 | .unused, |
| | 119196 | .unused, |
| | 119197 | .unused, |
| | 119198 | .unused, |
| | 119199 | }, |
| | 119200 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119201 | .each = .{ .once = &.{ |
| | 119202 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119203 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 119204 | .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ }, |
| | 119205 | .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ }, |
| | 119206 | .{ ._, .vp_, switch (mir_tag) { |
| | 119207 | else => unreachable, |
| | 119208 | .@"and" => .@"or", |
| | 119209 | .@"or", .xor => .@"and", |
| | 119210 | }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ }, |
| | 119211 | .{ ._, .vp_, switch (mir_tag) { |
| | 119212 | else => unreachable, |
| | 119213 | .@"and" => .@"or", |
| | 119214 | .@"or", .xor => .@"and", |
| | 119215 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ }, |
| | 119216 | .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ }, |
| | 119217 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 119218 | .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ }, |
| | 119219 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119220 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 119221 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119222 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119223 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119224 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119225 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119226 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119227 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119228 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119229 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 119230 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119231 | } }, |
| | 119232 | }, .{ |
| | 119233 | .required_features = .{ .avx2, null, null, null }, |
| | 119234 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119235 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 119236 | .patterns = &.{ |
| | 119237 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119238 | }, |
| | 119239 | .extra_temps = .{ |
| | 119240 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119241 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119242 | .ref = .src0, |
| | 119243 | .invert = switch (mir_tag) { |
| | 119244 | else => unreachable, |
| | 119245 | .@"and" => true, |
| | 119246 | .@"or", .xor => false, |
| | 119247 | }, |
| | 119248 | } } }, |
| | 119249 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 119250 | .unused, |
| | 119251 | .unused, |
| | 119252 | .unused, |
| | 119253 | .unused, |
| | 119254 | .unused, |
| | 119255 | .unused, |
| | 119256 | .unused, |
| | 119257 | .unused, |
| | 119258 | }, |
| | 119259 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119260 | .each = .{ .once = &.{ |
| | 119261 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119262 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 119263 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 119264 | .{ ._, .vp_, switch (mir_tag) { |
| | 119265 | else => unreachable, |
| | 119266 | .@"and" => .@"or", |
| | 119267 | .@"or", .xor => .@"and", |
| | 119268 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 119269 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 119270 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 119271 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119272 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119273 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119274 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119275 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119276 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119277 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119278 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119279 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119280 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 119281 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119282 | } }, |
| | 119283 | }, .{ |
| | 119284 | .required_features = .{ .avx, null, null, null }, |
| | 119285 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119286 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any, .any }, |
| | 119287 | .patterns = &.{ |
| | 119288 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119289 | }, |
| | 119290 | .extra_temps = .{ |
| | 119291 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119292 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119293 | .ref = .src0, |
| | 119294 | .invert = switch (mir_tag) { |
| | 119295 | else => unreachable, |
| | 119296 | .@"and" => true, |
| | 119297 | .@"or", .xor => false, |
| | 119298 | }, |
| | 119299 | } } }, |
| | 119300 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 119301 | .unused, |
| | 119302 | .unused, |
| | 119303 | .unused, |
| | 119304 | .unused, |
| | 119305 | .unused, |
| | 119306 | .unused, |
| | 119307 | .unused, |
| | 119308 | .unused, |
| | 119309 | }, |
| | 119310 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119311 | .each = .{ .once = &.{ |
| | 119312 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119313 | .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 119314 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 119315 | .{ ._, .v_ps, switch (mir_tag) { |
| | 119316 | else => unreachable, |
| | 119317 | .@"and" => .@"or", |
| | 119318 | .@"or", .xor => .@"and", |
| | 119319 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 119320 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 119321 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 119322 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119323 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119324 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119325 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 119326 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119327 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 119328 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119329 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119330 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119331 | .{ ._, .vp_w, .srl, .tmp2x, .dst0x, .ui(8), ._ }, |
| | 119332 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119333 | } }, |
| | 119334 | }, .{ |
| | 119335 | .required_features = .{ .sse2, null, null, null }, |
| | 119336 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119337 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any, .any }, |
| | 119338 | .patterns = &.{ |
| | 119339 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119340 | }, |
| | 119341 | .extra_temps = .{ |
| | 119342 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119343 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119344 | .ref = .src0, |
| | 119345 | .invert = switch (mir_tag) { |
| | 119346 | else => unreachable, |
| | 119347 | .@"and" => true, |
| | 119348 | .@"or", .xor => false, |
| | 119349 | }, |
| | 119350 | } } }, |
| | 119351 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 119352 | .unused, |
| | 119353 | .unused, |
| | 119354 | .unused, |
| | 119355 | .unused, |
| | 119356 | .unused, |
| | 119357 | .unused, |
| | 119358 | .unused, |
| | 119359 | .unused, |
| | 119360 | }, |
| | 119361 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119362 | .each = .{ .once = &.{ |
| | 119363 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119364 | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 119365 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, |
| | 119366 | .{ ._, .p_, switch (mir_tag) { |
| | 119367 | else => unreachable, |
| | 119368 | .@"and" => .@"or", |
| | 119369 | .@"or", .xor => .@"and", |
| | 119370 | }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 119371 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 119372 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 119373 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119374 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119375 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119376 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119377 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119378 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 119379 | .{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ }, |
| | 119380 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119381 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 119382 | .{ ._, .p_w, .srl, .tmp2x, .ui(8), ._, ._ }, |
| | 119383 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119384 | } }, |
| | 119385 | }, .{ |
| | 119386 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 119387 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119388 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| | 119389 | .patterns = &.{ |
| | 119390 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119391 | }, |
| | 119392 | .extra_temps = .{ |
| | 119393 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119394 | .unused, |
| | 119395 | .unused, |
| | 119396 | .unused, |
| | 119397 | .unused, |
| | 119398 | .unused, |
| | 119399 | .unused, |
| | 119400 | .unused, |
| | 119401 | .unused, |
| | 119402 | .unused, |
| | 119403 | .unused, |
| | 119404 | }, |
| | 119405 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 119406 | .clobbers = .{ .eflags = true }, |
| | 119407 | .each = .{ .once = &.{ |
| | 119408 | .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, |
| | 119409 | .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ }, |
| | 119410 | .{ .@"0:", ._, mir_tag, .dst0b, .memi(.src0b, .tmp0), ._, ._ }, |
| | 119411 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 119412 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 119413 | } }, |
| | 119414 | }, .{ |
| | 119415 | .dst_constraints = .{ .{ .int = .byte }, .any }, |
| | 119416 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| | 119417 | .patterns = &.{ |
| | 119418 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119419 | }, |
| | 119420 | .extra_temps = .{ |
| | 119421 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 119422 | .unused, |
| | 119423 | .unused, |
| | 119424 | .unused, |
| | 119425 | .unused, |
| | 119426 | .unused, |
| | 119427 | .unused, |
| | 119428 | .unused, |
| | 119429 | .unused, |
| | 119430 | .unused, |
| | 119431 | .unused, |
| | 119432 | }, |
| | 119433 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 119434 | .clobbers = .{ .eflags = true }, |
| | 119435 | .each = .{ .once = &.{ |
| | 119436 | .{ ._, ._, .mov, .tmp0d, .sia(-2, .src0, .add_unaligned_size), ._, ._ }, |
| | 119437 | .{ ._, ._, .movzx, .dst0d, .memad(.src0b, .add_unaligned_size, -1), ._, ._ }, |
| | 119438 | .{ .@"0:", ._, mir_tag, .dst0b, .memi(.src0b, .tmp0), ._, ._ }, |
| | 119439 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 119440 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 119441 | } }, |
| | 119442 | }, .{ |
| | 119443 | .required_features = .{ .sse, null, null, null }, |
| | 119444 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119445 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 119446 | .patterns = &.{ |
| | 119447 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 119448 | .{ .src = .{ .mut_gpr, .none, .none } }, |
| | 119449 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 119450 | }, |
| | 119451 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119452 | .each = .{ .once = &.{} }, |
| | 119453 | }, .{ |
| | 119454 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119455 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 119456 | .patterns = &.{ |
| | 119457 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 119458 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 119459 | }, |
| | 119460 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119461 | .each = .{ .once = &.{} }, |
| | 119462 | }, .{ |
| | 119463 | .required_features = .{ .avx, null, null, null }, |
| | 119464 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119465 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| | 119466 | .patterns = &.{ |
| | 119467 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119468 | }, |
| | 119469 | .extra_temps = .{ |
| | 119470 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119471 | .unused, |
| | 119472 | .unused, |
| | 119473 | .unused, |
| | 119474 | .unused, |
| | 119475 | .unused, |
| | 119476 | .unused, |
| | 119477 | .unused, |
| | 119478 | .unused, |
| | 119479 | .unused, |
| | 119480 | .unused, |
| | 119481 | }, |
| | 119482 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119483 | .each = .{ .once = &.{ |
| | 119484 | .{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ }, |
| | 119485 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 119486 | } }, |
| | 119487 | }, .{ |
| | 119488 | .required_features = .{ .sse2, null, null, null }, |
| | 119489 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119490 | .src_constraints = .{ .{ .scalar_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| | 119491 | .patterns = &.{ |
| | 119492 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 119493 | }, |
| | 119494 | .extra_temps = .{ |
| | 119495 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119496 | .unused, |
| | 119497 | .unused, |
| | 119498 | .unused, |
| | 119499 | .unused, |
| | 119500 | .unused, |
| | 119501 | .unused, |
| | 119502 | .unused, |
| | 119503 | .unused, |
| | 119504 | .unused, |
| | 119505 | .unused, |
| | 119506 | }, |
| | 119507 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119508 | .each = .{ .once = &.{ |
| | 119509 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| | 119510 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 119511 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119512 | } }, |
| | 119513 | }, .{ |
| | 119514 | .required_features = .{ .avx, null, null, null }, |
| | 119515 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119516 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| | 119517 | .patterns = &.{ |
| | 119518 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119519 | }, |
| | 119520 | .extra_temps = .{ |
| | 119521 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119522 | .unused, |
| | 119523 | .unused, |
| | 119524 | .unused, |
| | 119525 | .unused, |
| | 119526 | .unused, |
| | 119527 | .unused, |
| | 119528 | .unused, |
| | 119529 | .unused, |
| | 119530 | .unused, |
| | 119531 | .unused, |
| | 119532 | }, |
| | 119533 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119534 | .each = .{ .once = &.{ |
| | 119535 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 119536 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 119537 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 119538 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119539 | } }, |
| | 119540 | }, .{ |
| | 119541 | .required_features = .{ .sse2, null, null, null }, |
| | 119542 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119543 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| | 119544 | .patterns = &.{ |
| | 119545 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 119546 | }, |
| | 119547 | .extra_temps = .{ |
| | 119548 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119549 | .unused, |
| | 119550 | .unused, |
| | 119551 | .unused, |
| | 119552 | .unused, |
| | 119553 | .unused, |
| | 119554 | .unused, |
| | 119555 | .unused, |
| | 119556 | .unused, |
| | 119557 | .unused, |
| | 119558 | .unused, |
| | 119559 | }, |
| | 119560 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119561 | .each = .{ .once = &.{ |
| | 119562 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 119563 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119564 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 119565 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 119566 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119567 | } }, |
| | 119568 | }, .{ |
| | 119569 | .required_features = .{ .avx, null, null, null }, |
| | 119570 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119571 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| | 119572 | .patterns = &.{ |
| | 119573 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119574 | }, |
| | 119575 | .extra_temps = .{ |
| | 119576 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119577 | .unused, |
| | 119578 | .unused, |
| | 119579 | .unused, |
| | 119580 | .unused, |
| | 119581 | .unused, |
| | 119582 | .unused, |
| | 119583 | .unused, |
| | 119584 | .unused, |
| | 119585 | .unused, |
| | 119586 | .unused, |
| | 119587 | }, |
| | 119588 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 119589 | .each = .{ .once = &.{ |
| | 119590 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 119591 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 119592 | .{ ._, .vp_d, .srl, .tmp0x, .src0x, .ui(16), ._ }, |
| | 119593 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119594 | } }, |
| | 119595 | }, .{ |
| | 119596 | .required_features = .{ .sse2, null, null, null }, |
| | 119597 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119598 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| | 119599 | .patterns = &.{ |
| | 119600 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 119601 | }, |
| | 119602 | .extra_temps = .{ |
| | 119603 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119604 | .unused, |
| | 119605 | .unused, |
| | 119606 | .unused, |
| | 119607 | .unused, |
| | 119608 | .unused, |
| | 119609 | .unused, |
| | 119610 | .unused, |
| | 119611 | .unused, |
| | 119612 | .unused, |
| | 119613 | .unused, |
| | 119614 | }, |
| | 119615 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119616 | .each = .{ .once = &.{ |
| | 119617 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 119618 | .{ ._, .p_, mir_tag, .tmp0x, .src0x, ._, ._ }, |
| | 119619 | .{ ._, .p_d, .srl, .dst0x, .ui(16), ._, ._ }, |
| | 119620 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119621 | } }, |
| | 119622 | }, .{ |
| | 119623 | .required_features = .{ .avx, null, null, null }, |
| | 119624 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119625 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| | 119626 | .patterns = &.{ |
| | 119627 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119628 | }, |
| | 119629 | .extra_temps = .{ |
| | 119630 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119631 | .unused, |
| | 119632 | .unused, |
| | 119633 | .unused, |
| | 119634 | .unused, |
| | 119635 | .unused, |
| | 119636 | .unused, |
| | 119637 | .unused, |
| | 119638 | .unused, |
| | 119639 | .unused, |
| | 119640 | .unused, |
| | 119641 | }, |
| | 119642 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119643 | .each = .{ .once = &.{ |
| | 119644 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 119645 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 119646 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119647 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119648 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 119649 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119650 | } }, |
| | 119651 | }, .{ |
| | 119652 | .required_features = .{ .sse2, null, null, null }, |
| | 119653 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119654 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| | 119655 | .patterns = &.{ |
| | 119656 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 119657 | }, |
| | 119658 | .extra_temps = .{ |
| | 119659 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119660 | .unused, |
| | 119661 | .unused, |
| | 119662 | .unused, |
| | 119663 | .unused, |
| | 119664 | .unused, |
| | 119665 | .unused, |
| | 119666 | .unused, |
| | 119667 | .unused, |
| | 119668 | .unused, |
| | 119669 | .unused, |
| | 119670 | }, |
| | 119671 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119672 | .each = .{ .once = &.{ |
| | 119673 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 119674 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119675 | .{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119676 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119677 | .{ ._, ._dqa, .mov, .tmp0x, .dst0x, ._, ._ }, |
| | 119678 | .{ ._, .p_d, .srl, .tmp0x, .ui(16), ._, ._ }, |
| | 119679 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 119680 | } }, |
| | 119681 | }, .{ |
| | 119682 | .required_features = .{ .avx, null, null, null }, |
| | 119683 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119684 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| | 119685 | .patterns = &.{ |
| | 119686 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119687 | }, |
| | 119688 | .extra_temps = .{ |
| | 119689 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 119690 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119691 | .ref = .src0, |
| | 119692 | .invert = switch (mir_tag) { |
| | 119693 | else => unreachable, |
| | 119694 | .@"and" => true, |
| | 119695 | .@"or", .xor => false, |
| | 119696 | }, |
| | 119697 | } } }, |
| | 119698 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119699 | .unused, |
| | 119700 | .unused, |
| | 119701 | .unused, |
| | 119702 | .unused, |
| | 119703 | .unused, |
| | 119704 | .unused, |
| | 119705 | .unused, |
| | 119706 | .unused, |
| | 119707 | }, |
| | 119708 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119709 | .each = .{ .once = &.{ |
| | 119710 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119711 | .{ ._, .vp_, switch (mir_tag) { |
| | 119712 | else => unreachable, |
| | 119713 | .@"and" => .@"or", |
| | 119714 | .@"or", .xor => .@"and", |
| | 119715 | }, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| | 119716 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119717 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119718 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119719 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119720 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119721 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119722 | } }, |
| | 119723 | }, .{ |
| | 119724 | .required_features = .{ .sse2, null, null, null }, |
| | 119725 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119726 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| | 119727 | .patterns = &.{ |
| | 119728 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 119729 | }, |
| | 119730 | .extra_temps = .{ |
| | 119731 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 119732 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119733 | .ref = .src0, |
| | 119734 | .invert = switch (mir_tag) { |
| | 119735 | else => unreachable, |
| | 119736 | .@"and" => true, |
| | 119737 | .@"or", .xor => false, |
| | 119738 | }, |
| | 119739 | } } }, |
| | 119740 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119741 | .unused, |
| | 119742 | .unused, |
| | 119743 | .unused, |
| | 119744 | .unused, |
| | 119745 | .unused, |
| | 119746 | .unused, |
| | 119747 | .unused, |
| | 119748 | .unused, |
| | 119749 | }, |
| | 119750 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 119751 | .each = .{ .once = &.{ |
| | 119752 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119753 | .{ ._, .p_, switch (mir_tag) { |
| | 119754 | else => unreachable, |
| | 119755 | .@"and" => .@"or", |
| | 119756 | .@"or", .xor => .@"and", |
| | 119757 | }, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 119758 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119759 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119760 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119761 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119762 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 119763 | .{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ }, |
| | 119764 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 119765 | } }, |
| | 119766 | }, .{ |
| | 119767 | .required_features = .{ .avx2, null, null, null }, |
| | 119768 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119769 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 119770 | .patterns = &.{ |
| | 119771 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119772 | }, |
| | 119773 | .extra_temps = .{ |
| | 119774 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119775 | .unused, |
| | 119776 | .unused, |
| | 119777 | .unused, |
| | 119778 | .unused, |
| | 119779 | .unused, |
| | 119780 | .unused, |
| | 119781 | .unused, |
| | 119782 | .unused, |
| | 119783 | .unused, |
| | 119784 | .unused, |
| | 119785 | }, |
| | 119786 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119787 | .each = .{ .once = &.{ |
| | 119788 | .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 119789 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 119790 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119791 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119792 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119793 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119794 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 119795 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119796 | } }, |
| | 119797 | }, .{ |
| | 119798 | .required_features = .{ .avx, null, null, null }, |
| | 119799 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119800 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 119801 | .patterns = &.{ |
| | 119802 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119803 | }, |
| | 119804 | .extra_temps = .{ |
| | 119805 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119806 | .unused, |
| | 119807 | .unused, |
| | 119808 | .unused, |
| | 119809 | .unused, |
| | 119810 | .unused, |
| | 119811 | .unused, |
| | 119812 | .unused, |
| | 119813 | .unused, |
| | 119814 | .unused, |
| | 119815 | .unused, |
| | 119816 | }, |
| | 119817 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119818 | .each = .{ .once = &.{ |
| | 119819 | .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 119820 | .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 119821 | .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ }, |
| | 119822 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119823 | .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 119824 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119825 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 119826 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119827 | } }, |
| | 119828 | }, .{ |
| | 119829 | .required_features = .{ .avx2, null, null, null }, |
| | 119830 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119831 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 119832 | .patterns = &.{ |
| | 119833 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119834 | }, |
| | 119835 | .extra_temps = .{ |
| | 119836 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 119837 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119838 | .ref = .src0, |
| | 119839 | .invert = switch (mir_tag) { |
| | 119840 | else => unreachable, |
| | 119841 | .@"and" => true, |
| | 119842 | .@"or", .xor => false, |
| | 119843 | }, |
| | 119844 | } } }, |
| | 119845 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119846 | .unused, |
| | 119847 | .unused, |
| | 119848 | .unused, |
| | 119849 | .unused, |
| | 119850 | .unused, |
| | 119851 | .unused, |
| | 119852 | .unused, |
| | 119853 | .unused, |
| | 119854 | }, |
| | 119855 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119856 | .each = .{ .once = &.{ |
| | 119857 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119858 | .{ ._, .vp_, switch (mir_tag) { |
| | 119859 | else => unreachable, |
| | 119860 | .@"and" => .@"or", |
| | 119861 | .@"or", .xor => .@"and", |
| | 119862 | }, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| | 119863 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119864 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119865 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119866 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119867 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119868 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119869 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119870 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119871 | } }, |
| | 119872 | }, .{ |
| | 119873 | .required_features = .{ .avx, null, null, null }, |
| | 119874 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119875 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 119876 | .patterns = &.{ |
| | 119877 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 119878 | }, |
| | 119879 | .extra_temps = .{ |
| | 119880 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 119881 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119882 | .ref = .src0, |
| | 119883 | .invert = switch (mir_tag) { |
| | 119884 | else => unreachable, |
| | 119885 | .@"and" => true, |
| | 119886 | .@"or", .xor => false, |
| | 119887 | }, |
| | 119888 | } } }, |
| | 119889 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119890 | .unused, |
| | 119891 | .unused, |
| | 119892 | .unused, |
| | 119893 | .unused, |
| | 119894 | .unused, |
| | 119895 | .unused, |
| | 119896 | .unused, |
| | 119897 | .unused, |
| | 119898 | }, |
| | 119899 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119900 | .each = .{ .once = &.{ |
| | 119901 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119902 | .{ ._, .v_ps, switch (mir_tag) { |
| | 119903 | else => unreachable, |
| | 119904 | .@"and" => .@"or", |
| | 119905 | .@"or", .xor => .@"and", |
| | 119906 | }, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| | 119907 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119908 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119909 | .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ }, |
| | 119910 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119911 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 119912 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119913 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119914 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119915 | } }, |
| | 119916 | }, .{ |
| | 119917 | .required_features = .{ .avx512f, null, null, null }, |
| | 119918 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119919 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any }, |
| | 119920 | .patterns = &.{ |
| | 119921 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119922 | }, |
| | 119923 | .extra_temps = .{ |
| | 119924 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 119925 | .unused, |
| | 119926 | .unused, |
| | 119927 | .unused, |
| | 119928 | .unused, |
| | 119929 | .unused, |
| | 119930 | .unused, |
| | 119931 | .unused, |
| | 119932 | .unused, |
| | 119933 | .unused, |
| | 119934 | .unused, |
| | 119935 | }, |
| | 119936 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119937 | .each = .{ .once = &.{ |
| | 119938 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 119939 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ }, |
| | 119940 | .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, |
| | 119941 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119942 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119943 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119944 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119945 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119946 | .{ ._, .vp_d, .srl, .tmp0x, .dst0x, .ui(16), ._ }, |
| | 119947 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 119948 | } }, |
| | 119949 | }, .{ |
| | 119950 | .required_features = .{ .avx512f, null, null, null }, |
| | 119951 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 119952 | .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .word } }, .any, .any }, |
| | 119953 | .patterns = &.{ |
| | 119954 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 119955 | }, |
| | 119956 | .extra_temps = .{ |
| | 119957 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 119958 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 119959 | .ref = .src0, |
| | 119960 | .invert = switch (mir_tag) { |
| | 119961 | else => unreachable, |
| | 119962 | .@"and" => true, |
| | 119963 | .@"or", .xor => false, |
| | 119964 | }, |
| | 119965 | } } }, |
| | 119966 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| | 119967 | .unused, |
| | 119968 | .unused, |
| | 119969 | .unused, |
| | 119970 | .unused, |
| | 119971 | .unused, |
| | 119972 | .unused, |
| | 119973 | .unused, |
| | 119974 | .unused, |
| | 119975 | }, |
| | 119976 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 119977 | .each = .{ .once = &.{ |
| | 119978 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 119979 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 119980 | .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ }, |
| | 119981 | .{ ._, .vp_, switch (mir_tag) { |
| | 119982 | else => unreachable, |
| | 119983 | .@"and" => .@"or", |
| | 119984 | .@"or", .xor => .@"and", |
| | 119985 | }, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 119986 | .{ ._, .vp_, switch (mir_tag) { |
| | 119987 | else => unreachable, |
| | 119988 | .@"and" => .@"or", |
| | 119989 | .@"or", .xor => .@"and", |
| | 119990 | }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ }, |
| | 119991 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 119992 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 119993 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119994 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 119995 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119996 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 119997 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 119998 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 119999 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120000 | } }, |
| | 120001 | }, .{ |
| | 120002 | .required_features = .{ .avx2, null, null, null }, |
| | 120003 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120004 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 120005 | .patterns = &.{ |
| | 120006 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120007 | }, |
| | 120008 | .extra_temps = .{ |
| | 120009 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120010 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 120011 | .unused, |
| | 120012 | .unused, |
| | 120013 | .unused, |
| | 120014 | .unused, |
| | 120015 | .unused, |
| | 120016 | .unused, |
| | 120017 | .unused, |
| | 120018 | .unused, |
| | 120019 | .unused, |
| | 120020 | }, |
| | 120021 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120022 | .each = .{ .once = &.{ |
| | 120023 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 120024 | .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 120025 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120026 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120027 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120028 | .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 120029 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120030 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120031 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120032 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120033 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120034 | .{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ }, |
| | 120035 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120036 | } }, |
| | 120037 | }, .{ |
| | 120038 | .required_features = .{ .avx, null, null, null }, |
| | 120039 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120040 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 120041 | .patterns = &.{ |
| | 120042 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120043 | }, |
| | 120044 | .extra_temps = .{ |
| | 120045 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120046 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 120047 | .unused, |
| | 120048 | .unused, |
| | 120049 | .unused, |
| | 120050 | .unused, |
| | 120051 | .unused, |
| | 120052 | .unused, |
| | 120053 | .unused, |
| | 120054 | .unused, |
| | 120055 | .unused, |
| | 120056 | }, |
| | 120057 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120058 | .each = .{ .once = &.{ |
| | 120059 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 120060 | .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 120061 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120062 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120063 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120064 | .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 120065 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120066 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 120067 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120068 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 120069 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120070 | .{ ._, .vp_d, .srl, .tmp1x, .dst0x, .ui(16), ._ }, |
| | 120071 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120072 | } }, |
| | 120073 | }, .{ |
| | 120074 | .required_features = .{ .sse2, null, null, null }, |
| | 120075 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120076 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| | 120077 | .patterns = &.{ |
| | 120078 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120079 | }, |
| | 120080 | .extra_temps = .{ |
| | 120081 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120082 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 120083 | .unused, |
| | 120084 | .unused, |
| | 120085 | .unused, |
| | 120086 | .unused, |
| | 120087 | .unused, |
| | 120088 | .unused, |
| | 120089 | .unused, |
| | 120090 | .unused, |
| | 120091 | .unused, |
| | 120092 | }, |
| | 120093 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120094 | .each = .{ .once = &.{ |
| | 120095 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, |
| | 120096 | .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ }, |
| | 120097 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 120098 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 120099 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120100 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120101 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 120102 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120103 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 120104 | .{ ._, ._dqa, .mov, .tmp1x, .dst0x, ._, ._ }, |
| | 120105 | .{ ._, .p_d, .srl, .tmp1x, .ui(16), ._, ._ }, |
| | 120106 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 120107 | } }, |
| | 120108 | }, .{ |
| | 120109 | .required_features = .{ .avx512f, null, null, null }, |
| | 120110 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120111 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .word } }, .any, .any }, |
| | 120112 | .patterns = &.{ |
| | 120113 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120114 | }, |
| | 120115 | .extra_temps = .{ |
| | 120116 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120117 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120118 | .ref = .src0, |
| | 120119 | .invert = switch (mir_tag) { |
| | 120120 | else => unreachable, |
| | 120121 | .@"and" => true, |
| | 120122 | .@"or", .xor => false, |
| | 120123 | }, |
| | 120124 | } } }, |
| | 120125 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| | 120126 | .unused, |
| | 120127 | .unused, |
| | 120128 | .unused, |
| | 120129 | .unused, |
| | 120130 | .unused, |
| | 120131 | .unused, |
| | 120132 | .unused, |
| | 120133 | .unused, |
| | 120134 | }, |
| | 120135 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120136 | .each = .{ .once = &.{ |
| | 120137 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120138 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 120139 | .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ }, |
| | 120140 | .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ }, |
| | 120141 | .{ ._, .vp_, switch (mir_tag) { |
| | 120142 | else => unreachable, |
| | 120143 | .@"and" => .@"or", |
| | 120144 | .@"or", .xor => .@"and", |
| | 120145 | }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ }, |
| | 120146 | .{ ._, .vp_, switch (mir_tag) { |
| | 120147 | else => unreachable, |
| | 120148 | .@"and" => .@"or", |
| | 120149 | .@"or", .xor => .@"and", |
| | 120150 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ }, |
| | 120151 | .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ }, |
| | 120152 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120153 | .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ }, |
| | 120154 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120155 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 120156 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120157 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120158 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120159 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120160 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120161 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120162 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 120163 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120164 | } }, |
| | 120165 | }, .{ |
| | 120166 | .required_features = .{ .avx2, null, null, null }, |
| | 120167 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120168 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 120169 | .patterns = &.{ |
| | 120170 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120171 | }, |
| | 120172 | .extra_temps = .{ |
| | 120173 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120174 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120175 | .ref = .src0, |
| | 120176 | .invert = switch (mir_tag) { |
| | 120177 | else => unreachable, |
| | 120178 | .@"and" => true, |
| | 120179 | .@"or", .xor => false, |
| | 120180 | }, |
| | 120181 | } } }, |
| | 120182 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 120183 | .unused, |
| | 120184 | .unused, |
| | 120185 | .unused, |
| | 120186 | .unused, |
| | 120187 | .unused, |
| | 120188 | .unused, |
| | 120189 | .unused, |
| | 120190 | .unused, |
| | 120191 | }, |
| | 120192 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120193 | .each = .{ .once = &.{ |
| | 120194 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120195 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 120196 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 120197 | .{ ._, .vp_, switch (mir_tag) { |
| | 120198 | else => unreachable, |
| | 120199 | .@"and" => .@"or", |
| | 120200 | .@"or", .xor => .@"and", |
| | 120201 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 120202 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120203 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120204 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120205 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120206 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120207 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120208 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120209 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120210 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120211 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 120212 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120213 | } }, |
| | 120214 | }, .{ |
| | 120215 | .required_features = .{ .avx, null, null, null }, |
| | 120216 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120217 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .word } }, .any, .any }, |
| | 120218 | .patterns = &.{ |
| | 120219 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120220 | }, |
| | 120221 | .extra_temps = .{ |
| | 120222 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120223 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120224 | .ref = .src0, |
| | 120225 | .invert = switch (mir_tag) { |
| | 120226 | else => unreachable, |
| | 120227 | .@"and" => true, |
| | 120228 | .@"or", .xor => false, |
| | 120229 | }, |
| | 120230 | } } }, |
| | 120231 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 120232 | .unused, |
| | 120233 | .unused, |
| | 120234 | .unused, |
| | 120235 | .unused, |
| | 120236 | .unused, |
| | 120237 | .unused, |
| | 120238 | .unused, |
| | 120239 | .unused, |
| | 120240 | }, |
| | 120241 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120242 | .each = .{ .once = &.{ |
| | 120243 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120244 | .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 120245 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 120246 | .{ ._, .v_ps, switch (mir_tag) { |
| | 120247 | else => unreachable, |
| | 120248 | .@"and" => .@"or", |
| | 120249 | .@"or", .xor => .@"and", |
| | 120250 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 120251 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120252 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120253 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120254 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120255 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120256 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 120257 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120258 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 120259 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120260 | .{ ._, .vp_d, .srl, .tmp2x, .dst0x, .ui(16), ._ }, |
| | 120261 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120262 | } }, |
| | 120263 | }, .{ |
| | 120264 | .required_features = .{ .sse2, null, null, null }, |
| | 120265 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120266 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| | 120267 | .patterns = &.{ |
| | 120268 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120269 | }, |
| | 120270 | .extra_temps = .{ |
| | 120271 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120272 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120273 | .ref = .src0, |
| | 120274 | .invert = switch (mir_tag) { |
| | 120275 | else => unreachable, |
| | 120276 | .@"and" => true, |
| | 120277 | .@"or", .xor => false, |
| | 120278 | }, |
| | 120279 | } } }, |
| | 120280 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 120281 | .unused, |
| | 120282 | .unused, |
| | 120283 | .unused, |
| | 120284 | .unused, |
| | 120285 | .unused, |
| | 120286 | .unused, |
| | 120287 | .unused, |
| | 120288 | .unused, |
| | 120289 | }, |
| | 120290 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120291 | .each = .{ .once = &.{ |
| | 120292 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120293 | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 120294 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, |
| | 120295 | .{ ._, .p_, switch (mir_tag) { |
| | 120296 | else => unreachable, |
| | 120297 | .@"and" => .@"or", |
| | 120298 | .@"or", .xor => .@"and", |
| | 120299 | }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 120300 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 120301 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 120302 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120303 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120304 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 120305 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120306 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 120307 | .{ ._, ._dqa, .mov, .tmp2x, .dst0x, ._, ._ }, |
| | 120308 | .{ ._, .p_d, .srl, .tmp2x, .ui(16), ._, ._ }, |
| | 120309 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 120310 | } }, |
| | 120311 | }, .{ |
| | 120312 | .dst_constraints = .{ .{ .int = .word }, .any }, |
| | 120313 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| | 120314 | .patterns = &.{ |
| | 120315 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120316 | }, |
| | 120317 | .extra_temps = .{ |
| | 120318 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120319 | .unused, |
| | 120320 | .unused, |
| | 120321 | .unused, |
| | 120322 | .unused, |
| | 120323 | .unused, |
| | 120324 | .unused, |
| | 120325 | .unused, |
| | 120326 | .unused, |
| | 120327 | .unused, |
| | 120328 | .unused, |
| | 120329 | }, |
| | 120330 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 120331 | .clobbers = .{ .eflags = true }, |
| | 120332 | .each = .{ .once = &.{ |
| | 120333 | .{ ._, ._, .mov, .tmp0d, .sia(-4, .src0, .add_unaligned_size), ._, ._ }, |
| | 120334 | .{ ._, ._, .movzx, .dst0d, .memad(.src0w, .add_unaligned_size, -2), ._, ._ }, |
| | 120335 | .{ .@"0:", ._, mir_tag, .dst0w, .memi(.src0w, .tmp0), ._, ._ }, |
| | 120336 | .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, |
| | 120337 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120338 | } }, |
| | 120339 | }, .{ |
| | 120340 | .required_features = .{ .sse, null, null, null }, |
| | 120341 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120342 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 120343 | .patterns = &.{ |
| | 120344 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 120345 | .{ .src = .{ .mut_gpr, .none, .none } }, |
| | 120346 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 120347 | }, |
| | 120348 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 120349 | .each = .{ .once = &.{} }, |
| | 120350 | }, .{ |
| | 120351 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120352 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 120353 | .patterns = &.{ |
| | 120354 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 120355 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 120356 | }, |
| | 120357 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 120358 | .each = .{ .once = &.{} }, |
| | 120359 | }, .{ |
| | 120360 | .required_features = .{ .avx, null, null, null }, |
| | 120361 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120362 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| | 120363 | .patterns = &.{ |
| | 120364 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120365 | }, |
| | 120366 | .extra_temps = .{ |
| | 120367 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120368 | .unused, |
| | 120369 | .unused, |
| | 120370 | .unused, |
| | 120371 | .unused, |
| | 120372 | .unused, |
| | 120373 | .unused, |
| | 120374 | .unused, |
| | 120375 | .unused, |
| | 120376 | .unused, |
| | 120377 | .unused, |
| | 120378 | }, |
| | 120379 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120380 | .each = .{ .once = &.{ |
| | 120381 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 120382 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 120383 | } }, |
| | 120384 | }, .{ |
| | 120385 | .required_features = .{ .sse2, null, null, null }, |
| | 120386 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120387 | .src_constraints = .{ .{ .scalar_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| | 120388 | .patterns = &.{ |
| | 120389 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 120390 | }, |
| | 120391 | .extra_temps = .{ |
| | 120392 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120393 | .unused, |
| | 120394 | .unused, |
| | 120395 | .unused, |
| | 120396 | .unused, |
| | 120397 | .unused, |
| | 120398 | .unused, |
| | 120399 | .unused, |
| | 120400 | .unused, |
| | 120401 | .unused, |
| | 120402 | .unused, |
| | 120403 | }, |
| | 120404 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 120405 | .each = .{ .once = &.{ |
| | 120406 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 120407 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 120408 | } }, |
| | 120409 | }, .{ |
| | 120410 | .required_features = .{ .avx, null, null, null }, |
| | 120411 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120412 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| | 120413 | .patterns = &.{ |
| | 120414 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120415 | }, |
| | 120416 | .extra_temps = .{ |
| | 120417 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120418 | .unused, |
| | 120419 | .unused, |
| | 120420 | .unused, |
| | 120421 | .unused, |
| | 120422 | .unused, |
| | 120423 | .unused, |
| | 120424 | .unused, |
| | 120425 | .unused, |
| | 120426 | .unused, |
| | 120427 | .unused, |
| | 120428 | }, |
| | 120429 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120430 | .each = .{ .once = &.{ |
| | 120431 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 120432 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 120433 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120434 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120435 | } }, |
| | 120436 | }, .{ |
| | 120437 | .required_features = .{ .sse2, null, null, null }, |
| | 120438 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120439 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| | 120440 | .patterns = &.{ |
| | 120441 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 120442 | }, |
| | 120443 | .extra_temps = .{ |
| | 120444 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120445 | .unused, |
| | 120446 | .unused, |
| | 120447 | .unused, |
| | 120448 | .unused, |
| | 120449 | .unused, |
| | 120450 | .unused, |
| | 120451 | .unused, |
| | 120452 | .unused, |
| | 120453 | .unused, |
| | 120454 | .unused, |
| | 120455 | }, |
| | 120456 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 120457 | .each = .{ .once = &.{ |
| | 120458 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 120459 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 120460 | .{ ._, .p_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120461 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 120462 | } }, |
| | 120463 | }, .{ |
| | 120464 | .required_features = .{ .avx, null, null, null }, |
| | 120465 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120466 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| | 120467 | .patterns = &.{ |
| | 120468 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120469 | }, |
| | 120470 | .extra_temps = .{ |
| | 120471 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120472 | .unused, |
| | 120473 | .unused, |
| | 120474 | .unused, |
| | 120475 | .unused, |
| | 120476 | .unused, |
| | 120477 | .unused, |
| | 120478 | .unused, |
| | 120479 | .unused, |
| | 120480 | .unused, |
| | 120481 | .unused, |
| | 120482 | }, |
| | 120483 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120484 | .each = .{ .once = &.{ |
| | 120485 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 120486 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 120487 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 120488 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120489 | } }, |
| | 120490 | }, .{ |
| | 120491 | .required_features = .{ .sse2, null, null, null }, |
| | 120492 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120493 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| | 120494 | .patterns = &.{ |
| | 120495 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 120496 | }, |
| | 120497 | .extra_temps = .{ |
| | 120498 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120499 | .unused, |
| | 120500 | .unused, |
| | 120501 | .unused, |
| | 120502 | .unused, |
| | 120503 | .unused, |
| | 120504 | .unused, |
| | 120505 | .unused, |
| | 120506 | .unused, |
| | 120507 | .unused, |
| | 120508 | .unused, |
| | 120509 | }, |
| | 120510 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 120511 | .each = .{ .once = &.{ |
| | 120512 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 120513 | .{ ._, .p_, mir_tag, .tmp0x, .src0x, ._, ._ }, |
| | 120514 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_01_01_01), ._ }, |
| | 120515 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 120516 | } }, |
| | 120517 | }, .{ |
| | 120518 | .required_features = .{ .avx2, null, null, null }, |
| | 120519 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120520 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120521 | .patterns = &.{ |
| | 120522 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120523 | }, |
| | 120524 | .extra_temps = .{ |
| | 120525 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120526 | .unused, |
| | 120527 | .unused, |
| | 120528 | .unused, |
| | 120529 | .unused, |
| | 120530 | .unused, |
| | 120531 | .unused, |
| | 120532 | .unused, |
| | 120533 | .unused, |
| | 120534 | .unused, |
| | 120535 | .unused, |
| | 120536 | }, |
| | 120537 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120538 | .each = .{ .once = &.{ |
| | 120539 | .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 120540 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 120541 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120542 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120543 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120544 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120545 | } }, |
| | 120546 | }, .{ |
| | 120547 | .required_features = .{ .avx, null, null, null }, |
| | 120548 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120549 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120550 | .patterns = &.{ |
| | 120551 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120552 | }, |
| | 120553 | .extra_temps = .{ |
| | 120554 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120555 | .unused, |
| | 120556 | .unused, |
| | 120557 | .unused, |
| | 120558 | .unused, |
| | 120559 | .unused, |
| | 120560 | .unused, |
| | 120561 | .unused, |
| | 120562 | .unused, |
| | 120563 | .unused, |
| | 120564 | .unused, |
| | 120565 | }, |
| | 120566 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120567 | .each = .{ .once = &.{ |
| | 120568 | .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 120569 | .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 120570 | .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ }, |
| | 120571 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120572 | .{ ._, .v_ps, .shuf, .tmp0x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 120573 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120574 | } }, |
| | 120575 | }, .{ |
| | 120576 | .required_features = .{ .avx2, null, null, null }, |
| | 120577 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120578 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120579 | .patterns = &.{ |
| | 120580 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120581 | }, |
| | 120582 | .extra_temps = .{ |
| | 120583 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 120584 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120585 | .ref = .src0, |
| | 120586 | .invert = switch (mir_tag) { |
| | 120587 | else => unreachable, |
| | 120588 | .@"and" => true, |
| | 120589 | .@"or", .xor => false, |
| | 120590 | }, |
| | 120591 | } } }, |
| | 120592 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120593 | .unused, |
| | 120594 | .unused, |
| | 120595 | .unused, |
| | 120596 | .unused, |
| | 120597 | .unused, |
| | 120598 | .unused, |
| | 120599 | .unused, |
| | 120600 | .unused, |
| | 120601 | }, |
| | 120602 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120603 | .each = .{ .once = &.{ |
| | 120604 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120605 | .{ ._, .vp_, switch (mir_tag) { |
| | 120606 | else => unreachable, |
| | 120607 | .@"and" => .@"or", |
| | 120608 | .@"or", .xor => .@"and", |
| | 120609 | }, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| | 120610 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120611 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120612 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120613 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120614 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120615 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120616 | } }, |
| | 120617 | }, .{ |
| | 120618 | .required_features = .{ .avx, null, null, null }, |
| | 120619 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120620 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120621 | .patterns = &.{ |
| | 120622 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 120623 | }, |
| | 120624 | .extra_temps = .{ |
| | 120625 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 120626 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120627 | .ref = .src0, |
| | 120628 | .invert = switch (mir_tag) { |
| | 120629 | else => unreachable, |
| | 120630 | .@"and" => true, |
| | 120631 | .@"or", .xor => false, |
| | 120632 | }, |
| | 120633 | } } }, |
| | 120634 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120635 | .unused, |
| | 120636 | .unused, |
| | 120637 | .unused, |
| | 120638 | .unused, |
| | 120639 | .unused, |
| | 120640 | .unused, |
| | 120641 | .unused, |
| | 120642 | .unused, |
| | 120643 | }, |
| | 120644 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120645 | .each = .{ .once = &.{ |
| | 120646 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120647 | .{ ._, .v_ps, switch (mir_tag) { |
| | 120648 | else => unreachable, |
| | 120649 | .@"and" => .@"or", |
| | 120650 | .@"or", .xor => .@"and", |
| | 120651 | }, .dst0y, .src0y, .lea(.tmp0y), ._ }, |
| | 120652 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120653 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120654 | .{ ._, .v_ps, .movhl, .tmp2x, .dst0x, .dst0x, ._ }, |
| | 120655 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120656 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 120657 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120658 | } }, |
| | 120659 | }, .{ |
| | 120660 | .required_features = .{ .avx512f, null, null, null }, |
| | 120661 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120662 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any }, |
| | 120663 | .patterns = &.{ |
| | 120664 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120665 | }, |
| | 120666 | .extra_temps = .{ |
| | 120667 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120668 | .unused, |
| | 120669 | .unused, |
| | 120670 | .unused, |
| | 120671 | .unused, |
| | 120672 | .unused, |
| | 120673 | .unused, |
| | 120674 | .unused, |
| | 120675 | .unused, |
| | 120676 | .unused, |
| | 120677 | .unused, |
| | 120678 | }, |
| | 120679 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120680 | .each = .{ .once = &.{ |
| | 120681 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 120682 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ }, |
| | 120683 | .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, |
| | 120684 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120685 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120686 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120687 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120688 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 120689 | } }, |
| | 120690 | }, .{ |
| | 120691 | .required_features = .{ .avx512f, null, null, null }, |
| | 120692 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120693 | .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any }, |
| | 120694 | .patterns = &.{ |
| | 120695 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120696 | }, |
| | 120697 | .extra_temps = .{ |
| | 120698 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 120699 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120700 | .ref = .src0, |
| | 120701 | .invert = switch (mir_tag) { |
| | 120702 | else => unreachable, |
| | 120703 | .@"and" => true, |
| | 120704 | .@"or", .xor => false, |
| | 120705 | }, |
| | 120706 | } } }, |
| | 120707 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 120708 | .unused, |
| | 120709 | .unused, |
| | 120710 | .unused, |
| | 120711 | .unused, |
| | 120712 | .unused, |
| | 120713 | .unused, |
| | 120714 | .unused, |
| | 120715 | .unused, |
| | 120716 | }, |
| | 120717 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 120718 | .each = .{ .once = &.{ |
| | 120719 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120720 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 120721 | .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ }, |
| | 120722 | .{ ._, .vp_, switch (mir_tag) { |
| | 120723 | else => unreachable, |
| | 120724 | .@"and" => .@"or", |
| | 120725 | .@"or", .xor => .@"and", |
| | 120726 | }, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 120727 | .{ ._, .vp_, switch (mir_tag) { |
| | 120728 | else => unreachable, |
| | 120729 | .@"and" => .@"or", |
| | 120730 | .@"or", .xor => .@"and", |
| | 120731 | }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ }, |
| | 120732 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 120733 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120734 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120735 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120736 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120737 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120738 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120739 | } }, |
| | 120740 | }, .{ |
| | 120741 | .required_features = .{ .avx2, null, null, null }, |
| | 120742 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120743 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120744 | .patterns = &.{ |
| | 120745 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120746 | }, |
| | 120747 | .extra_temps = .{ |
| | 120748 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120749 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120750 | .unused, |
| | 120751 | .unused, |
| | 120752 | .unused, |
| | 120753 | .unused, |
| | 120754 | .unused, |
| | 120755 | .unused, |
| | 120756 | .unused, |
| | 120757 | .unused, |
| | 120758 | .unused, |
| | 120759 | }, |
| | 120760 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120761 | .each = .{ .once = &.{ |
| | 120762 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 120763 | .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 120764 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120765 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120766 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120767 | .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 120768 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120769 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120770 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120771 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120772 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120773 | } }, |
| | 120774 | }, .{ |
| | 120775 | .required_features = .{ .avx, null, null, null }, |
| | 120776 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120777 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120778 | .patterns = &.{ |
| | 120779 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120780 | }, |
| | 120781 | .extra_temps = .{ |
| | 120782 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120783 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120784 | .unused, |
| | 120785 | .unused, |
| | 120786 | .unused, |
| | 120787 | .unused, |
| | 120788 | .unused, |
| | 120789 | .unused, |
| | 120790 | .unused, |
| | 120791 | .unused, |
| | 120792 | .unused, |
| | 120793 | }, |
| | 120794 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120795 | .each = .{ .once = &.{ |
| | 120796 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 120797 | .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 120798 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120799 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120800 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120801 | .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 120802 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120803 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 120804 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120805 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 120806 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 120807 | } }, |
| | 120808 | }, .{ |
| | 120809 | .required_features = .{ .sse2, null, null, null }, |
| | 120810 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120811 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| | 120812 | .patterns = &.{ |
| | 120813 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120814 | }, |
| | 120815 | .extra_temps = .{ |
| | 120816 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120817 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120818 | .unused, |
| | 120819 | .unused, |
| | 120820 | .unused, |
| | 120821 | .unused, |
| | 120822 | .unused, |
| | 120823 | .unused, |
| | 120824 | .unused, |
| | 120825 | .unused, |
| | 120826 | .unused, |
| | 120827 | }, |
| | 120828 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120829 | .each = .{ .once = &.{ |
| | 120830 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, |
| | 120831 | .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ }, |
| | 120832 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 120833 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 120834 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120835 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120836 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 120837 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120838 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 120839 | } }, |
| | 120840 | }, .{ |
| | 120841 | .required_features = .{ .avx512f, null, null, null }, |
| | 120842 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120843 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .dword } }, .any, .any }, |
| | 120844 | .patterns = &.{ |
| | 120845 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120846 | }, |
| | 120847 | .extra_temps = .{ |
| | 120848 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120849 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120850 | .ref = .src0, |
| | 120851 | .invert = switch (mir_tag) { |
| | 120852 | else => unreachable, |
| | 120853 | .@"and" => true, |
| | 120854 | .@"or", .xor => false, |
| | 120855 | }, |
| | 120856 | } } }, |
| | 120857 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 120858 | .unused, |
| | 120859 | .unused, |
| | 120860 | .unused, |
| | 120861 | .unused, |
| | 120862 | .unused, |
| | 120863 | .unused, |
| | 120864 | .unused, |
| | 120865 | .unused, |
| | 120866 | }, |
| | 120867 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120868 | .each = .{ .once = &.{ |
| | 120869 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120870 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 120871 | .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ }, |
| | 120872 | .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ }, |
| | 120873 | .{ ._, .vp_, switch (mir_tag) { |
| | 120874 | else => unreachable, |
| | 120875 | .@"and" => .@"or", |
| | 120876 | .@"or", .xor => .@"and", |
| | 120877 | }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ }, |
| | 120878 | .{ ._, .vp_, switch (mir_tag) { |
| | 120879 | else => unreachable, |
| | 120880 | .@"and" => .@"or", |
| | 120881 | .@"or", .xor => .@"and", |
| | 120882 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ }, |
| | 120883 | .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ }, |
| | 120884 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120885 | .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ }, |
| | 120886 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120887 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 120888 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120889 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120890 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120891 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120892 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120893 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120894 | } }, |
| | 120895 | }, .{ |
| | 120896 | .required_features = .{ .avx2, null, null, null }, |
| | 120897 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120898 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120899 | .patterns = &.{ |
| | 120900 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120901 | }, |
| | 120902 | .extra_temps = .{ |
| | 120903 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120904 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120905 | .ref = .src0, |
| | 120906 | .invert = switch (mir_tag) { |
| | 120907 | else => unreachable, |
| | 120908 | .@"and" => true, |
| | 120909 | .@"or", .xor => false, |
| | 120910 | }, |
| | 120911 | } } }, |
| | 120912 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120913 | .unused, |
| | 120914 | .unused, |
| | 120915 | .unused, |
| | 120916 | .unused, |
| | 120917 | .unused, |
| | 120918 | .unused, |
| | 120919 | .unused, |
| | 120920 | .unused, |
| | 120921 | }, |
| | 120922 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120923 | .each = .{ .once = &.{ |
| | 120924 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120925 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 120926 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 120927 | .{ ._, .vp_, switch (mir_tag) { |
| | 120928 | else => unreachable, |
| | 120929 | .@"and" => .@"or", |
| | 120930 | .@"or", .xor => .@"and", |
| | 120931 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 120932 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120933 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120934 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120935 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120936 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120937 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 120938 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120939 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 120940 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120941 | } }, |
| | 120942 | }, .{ |
| | 120943 | .required_features = .{ .avx, null, null, null }, |
| | 120944 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120945 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| | 120946 | .patterns = &.{ |
| | 120947 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120948 | }, |
| | 120949 | .extra_temps = .{ |
| | 120950 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120951 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120952 | .ref = .src0, |
| | 120953 | .invert = switch (mir_tag) { |
| | 120954 | else => unreachable, |
| | 120955 | .@"and" => true, |
| | 120956 | .@"or", .xor => false, |
| | 120957 | }, |
| | 120958 | } } }, |
| | 120959 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 120960 | .unused, |
| | 120961 | .unused, |
| | 120962 | .unused, |
| | 120963 | .unused, |
| | 120964 | .unused, |
| | 120965 | .unused, |
| | 120966 | .unused, |
| | 120967 | .unused, |
| | 120968 | }, |
| | 120969 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 120970 | .each = .{ .once = &.{ |
| | 120971 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 120972 | .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 120973 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 120974 | .{ ._, .v_ps, switch (mir_tag) { |
| | 120975 | else => unreachable, |
| | 120976 | .@"and" => .@"or", |
| | 120977 | .@"or", .xor => .@"and", |
| | 120978 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 120979 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 120980 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 120981 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 120982 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 120983 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120984 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 120985 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120986 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b01_01_01_01) }, |
| | 120987 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 120988 | } }, |
| | 120989 | }, .{ |
| | 120990 | .required_features = .{ .sse2, null, null, null }, |
| | 120991 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 120992 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| | 120993 | .patterns = &.{ |
| | 120994 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 120995 | }, |
| | 120996 | .extra_temps = .{ |
| | 120997 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 120998 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 120999 | .ref = .src0, |
| | 121000 | .invert = switch (mir_tag) { |
| | 121001 | else => unreachable, |
| | 121002 | .@"and" => true, |
| | 121003 | .@"or", .xor => false, |
| | 121004 | }, |
| | 121005 | } } }, |
| | 121006 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 121007 | .unused, |
| | 121008 | .unused, |
| | 121009 | .unused, |
| | 121010 | .unused, |
| | 121011 | .unused, |
| | 121012 | .unused, |
| | 121013 | .unused, |
| | 121014 | .unused, |
| | 121015 | }, |
| | 121016 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121017 | .each = .{ .once = &.{ |
| | 121018 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121019 | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 121020 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, |
| | 121021 | .{ ._, .p_, switch (mir_tag) { |
| | 121022 | else => unreachable, |
| | 121023 | .@"and" => .@"or", |
| | 121024 | .@"or", .xor => .@"and", |
| | 121025 | }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 121026 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 121027 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 121028 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121029 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121030 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 121031 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b01_01_01_01), ._ }, |
| | 121032 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 121033 | } }, |
| | 121034 | }, .{ |
| | 121035 | .dst_constraints = .{ .{ .int = .dword }, .any }, |
| | 121036 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| | 121037 | .patterns = &.{ |
| | 121038 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121039 | }, |
| | 121040 | .extra_temps = .{ |
| | 121041 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121042 | .unused, |
| | 121043 | .unused, |
| | 121044 | .unused, |
| | 121045 | .unused, |
| | 121046 | .unused, |
| | 121047 | .unused, |
| | 121048 | .unused, |
| | 121049 | .unused, |
| | 121050 | .unused, |
| | 121051 | .unused, |
| | 121052 | }, |
| | 121053 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 121054 | .clobbers = .{ .eflags = true }, |
| | 121055 | .each = .{ .once = &.{ |
| | 121056 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_unaligned_size), ._, ._ }, |
| | 121057 | .{ ._, ._, .mov, .dst0d, .memad(.src0d, .add_unaligned_size, -4), ._, ._ }, |
| | 121058 | .{ .@"0:", ._, mir_tag, .dst0d, .memi(.src0d, .tmp0), ._, ._ }, |
| | 121059 | .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, |
| | 121060 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121061 | } }, |
| | 121062 | }, .{ |
| | 121063 | .required_features = .{ .sse, null, null, null }, |
| | 121064 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121065 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 121066 | .patterns = &.{ |
| | 121067 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 121068 | .{ .src = .{ .mut_gpr, .none, .none } }, |
| | 121069 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 121070 | }, |
| | 121071 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 121072 | .each = .{ .once = &.{} }, |
| | 121073 | }, .{ |
| | 121074 | .required_features = .{ .@"64bit", null, null, null }, |
| | 121075 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121076 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 121077 | .patterns = &.{ |
| | 121078 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 121079 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| | 121080 | }, |
| | 121081 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 121082 | .each = .{ .once = &.{} }, |
| | 121083 | }, .{ |
| | 121084 | .required_features = .{ .avx, null, null, null }, |
| | 121085 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121086 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 121087 | .patterns = &.{ |
| | 121088 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121089 | }, |
| | 121090 | .extra_temps = .{ |
| | 121091 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121092 | .unused, |
| | 121093 | .unused, |
| | 121094 | .unused, |
| | 121095 | .unused, |
| | 121096 | .unused, |
| | 121097 | .unused, |
| | 121098 | .unused, |
| | 121099 | .unused, |
| | 121100 | .unused, |
| | 121101 | .unused, |
| | 121102 | }, |
| | 121103 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121104 | .each = .{ .once = &.{ |
| | 121105 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 121106 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121107 | } }, |
| | 121108 | }, .{ |
| | 121109 | .required_features = .{ .sse2, null, null, null }, |
| | 121110 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121111 | .src_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 121112 | .patterns = &.{ |
| | 121113 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 121114 | }, |
| | 121115 | .extra_temps = .{ |
| | 121116 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121117 | .unused, |
| | 121118 | .unused, |
| | 121119 | .unused, |
| | 121120 | .unused, |
| | 121121 | .unused, |
| | 121122 | .unused, |
| | 121123 | .unused, |
| | 121124 | .unused, |
| | 121125 | .unused, |
| | 121126 | .unused, |
| | 121127 | }, |
| | 121128 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 121129 | .each = .{ .once = &.{ |
| | 121130 | .{ ._, .p_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 121131 | .{ ._, .p_, mir_tag, .dst0x, .tmp0x, ._, ._ }, |
| | 121132 | } }, |
| | 121133 | }, .{ |
| | 121134 | .required_features = .{ .avx2, null, null, null }, |
| | 121135 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121136 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121137 | .patterns = &.{ |
| | 121138 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121139 | }, |
| | 121140 | .extra_temps = .{ |
| | 121141 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121142 | .unused, |
| | 121143 | .unused, |
| | 121144 | .unused, |
| | 121145 | .unused, |
| | 121146 | .unused, |
| | 121147 | .unused, |
| | 121148 | .unused, |
| | 121149 | .unused, |
| | 121150 | .unused, |
| | 121151 | .unused, |
| | 121152 | }, |
| | 121153 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121154 | .each = .{ .once = &.{ |
| | 121155 | .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 121156 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121157 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121158 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121159 | } }, |
| | 121160 | }, .{ |
| | 121161 | .required_features = .{ .avx, null, null, null }, |
| | 121162 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121163 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121164 | .patterns = &.{ |
| | 121165 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121166 | }, |
| | 121167 | .extra_temps = .{ |
| | 121168 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121169 | .unused, |
| | 121170 | .unused, |
| | 121171 | .unused, |
| | 121172 | .unused, |
| | 121173 | .unused, |
| | 121174 | .unused, |
| | 121175 | .unused, |
| | 121176 | .unused, |
| | 121177 | .unused, |
| | 121178 | .unused, |
| | 121179 | }, |
| | 121180 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121181 | .each = .{ .once = &.{ |
| | 121182 | .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 121183 | .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121184 | .{ ._, .v_ps, .movhl, .tmp0x, .dst0x, .dst0x, ._ }, |
| | 121185 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121186 | } }, |
| | 121187 | }, .{ |
| | 121188 | .required_features = .{ .avx2, null, null, null }, |
| | 121189 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121190 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121191 | .patterns = &.{ |
| | 121192 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121193 | }, |
| | 121194 | .extra_temps = .{ |
| | 121195 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121196 | .unused, |
| | 121197 | .unused, |
| | 121198 | .unused, |
| | 121199 | .unused, |
| | 121200 | .unused, |
| | 121201 | .unused, |
| | 121202 | .unused, |
| | 121203 | .unused, |
| | 121204 | .unused, |
| | 121205 | .unused, |
| | 121206 | }, |
| | 121207 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121208 | .each = .{ .once = &.{ |
| | 121209 | .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 121210 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121211 | .{ ._, .vp_d, .shuf, .tmp0x, .src0x, .ui(0b11_10_11_10), ._ }, |
| | 121212 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121213 | } }, |
| | 121214 | }, .{ |
| | 121215 | .required_features = .{ .avx, null, null, null }, |
| | 121216 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121217 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121218 | .patterns = &.{ |
| | 121219 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121220 | }, |
| | 121221 | .extra_temps = .{ |
| | 121222 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121223 | .unused, |
| | 121224 | .unused, |
| | 121225 | .unused, |
| | 121226 | .unused, |
| | 121227 | .unused, |
| | 121228 | .unused, |
| | 121229 | .unused, |
| | 121230 | .unused, |
| | 121231 | .unused, |
| | 121232 | .unused, |
| | 121233 | }, |
| | 121234 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121235 | .each = .{ .once = &.{ |
| | 121236 | .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 121237 | .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121238 | .{ ._, .v_ps, .movhl, .tmp0x, .src0x, .src0x, ._ }, |
| | 121239 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121240 | } }, |
| | 121241 | }, .{ |
| | 121242 | .required_features = .{ .avx512f, null, null, null }, |
| | 121243 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121244 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any }, |
| | 121245 | .patterns = &.{ |
| | 121246 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121247 | }, |
| | 121248 | .extra_temps = .{ |
| | 121249 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121250 | .unused, |
| | 121251 | .unused, |
| | 121252 | .unused, |
| | 121253 | .unused, |
| | 121254 | .unused, |
| | 121255 | .unused, |
| | 121256 | .unused, |
| | 121257 | .unused, |
| | 121258 | .unused, |
| | 121259 | .unused, |
| | 121260 | }, |
| | 121261 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121262 | .each = .{ .once = &.{ |
| | 121263 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 121264 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ }, |
| | 121265 | .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, |
| | 121266 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121267 | .{ ._, .vp_d, .shuf, .tmp0x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121268 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121269 | } }, |
| | 121270 | }, .{ |
| | 121271 | .required_features = .{ .avx512f, null, null, null }, |
| | 121272 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121273 | .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any }, |
| | 121274 | .patterns = &.{ |
| | 121275 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121276 | }, |
| | 121277 | .extra_temps = .{ |
| | 121278 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 121279 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121280 | .ref = .src0, |
| | 121281 | .invert = switch (mir_tag) { |
| | 121282 | else => unreachable, |
| | 121283 | .@"and" => true, |
| | 121284 | .@"or", .xor => false, |
| | 121285 | }, |
| | 121286 | } } }, |
| | 121287 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 121288 | .unused, |
| | 121289 | .unused, |
| | 121290 | .unused, |
| | 121291 | .unused, |
| | 121292 | .unused, |
| | 121293 | .unused, |
| | 121294 | .unused, |
| | 121295 | .unused, |
| | 121296 | }, |
| | 121297 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121298 | .each = .{ .once = &.{ |
| | 121299 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121300 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 121301 | .{ ._, .v_dqa, .mov, .tmp2y, .memd(.src0y, 32), ._, ._ }, |
| | 121302 | .{ ._, .vp_, switch (mir_tag) { |
| | 121303 | else => unreachable, |
| | 121304 | .@"and" => .@"or", |
| | 121305 | .@"or", .xor => .@"and", |
| | 121306 | }, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 121307 | .{ ._, .vp_, switch (mir_tag) { |
| | 121308 | else => unreachable, |
| | 121309 | .@"and" => .@"or", |
| | 121310 | .@"or", .xor => .@"and", |
| | 121311 | }, .tmp2y, .tmp2y, .lead(.tmp0y, 32), ._ }, |
| | 121312 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 121313 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121314 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121315 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121316 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121317 | } }, |
| | 121318 | }, .{ |
| | 121319 | .required_features = .{ .avx2, null, null, null }, |
| | 121320 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121321 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121322 | .patterns = &.{ |
| | 121323 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121324 | }, |
| | 121325 | .extra_temps = .{ |
| | 121326 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121327 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121328 | .unused, |
| | 121329 | .unused, |
| | 121330 | .unused, |
| | 121331 | .unused, |
| | 121332 | .unused, |
| | 121333 | .unused, |
| | 121334 | .unused, |
| | 121335 | .unused, |
| | 121336 | .unused, |
| | 121337 | }, |
| | 121338 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121339 | .each = .{ .once = &.{ |
| | 121340 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 121341 | .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 121342 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121343 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121344 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121345 | .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 121346 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 121347 | .{ ._, .vp_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121348 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 121349 | } }, |
| | 121350 | }, .{ |
| | 121351 | .required_features = .{ .avx, null, null, null }, |
| | 121352 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121353 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121354 | .patterns = &.{ |
| | 121355 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121356 | }, |
| | 121357 | .extra_temps = .{ |
| | 121358 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121359 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121360 | .unused, |
| | 121361 | .unused, |
| | 121362 | .unused, |
| | 121363 | .unused, |
| | 121364 | .unused, |
| | 121365 | .unused, |
| | 121366 | .unused, |
| | 121367 | .unused, |
| | 121368 | .unused, |
| | 121369 | }, |
| | 121370 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121371 | .each = .{ .once = &.{ |
| | 121372 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 121373 | .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 121374 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121375 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121376 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121377 | .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 121378 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 121379 | .{ ._, .v_ps, .shuf, .tmp1x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 121380 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 121381 | } }, |
| | 121382 | }, .{ |
| | 121383 | .required_features = .{ .sse2, null, null, null }, |
| | 121384 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121385 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 121386 | .patterns = &.{ |
| | 121387 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121388 | }, |
| | 121389 | .extra_temps = .{ |
| | 121390 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121391 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121392 | .unused, |
| | 121393 | .unused, |
| | 121394 | .unused, |
| | 121395 | .unused, |
| | 121396 | .unused, |
| | 121397 | .unused, |
| | 121398 | .unused, |
| | 121399 | .unused, |
| | 121400 | .unused, |
| | 121401 | }, |
| | 121402 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121403 | .each = .{ .once = &.{ |
| | 121404 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, |
| | 121405 | .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ }, |
| | 121406 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 121407 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 121408 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121409 | .{ ._, .p_d, .shuf, .tmp1x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121410 | .{ ._, .p_, mir_tag, .dst0x, .tmp1x, ._, ._ }, |
| | 121411 | } }, |
| | 121412 | }, .{ |
| | 121413 | .required_features = .{ .avx512f, null, null, null }, |
| | 121414 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121415 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .qword } }, .any, .any }, |
| | 121416 | .patterns = &.{ |
| | 121417 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121418 | }, |
| | 121419 | .extra_temps = .{ |
| | 121420 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121421 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121422 | .ref = .src0, |
| | 121423 | .invert = switch (mir_tag) { |
| | 121424 | else => unreachable, |
| | 121425 | .@"and" => true, |
| | 121426 | .@"or", .xor => false, |
| | 121427 | }, |
| | 121428 | } } }, |
| | 121429 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 121430 | .unused, |
| | 121431 | .unused, |
| | 121432 | .unused, |
| | 121433 | .unused, |
| | 121434 | .unused, |
| | 121435 | .unused, |
| | 121436 | .unused, |
| | 121437 | .unused, |
| | 121438 | }, |
| | 121439 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121440 | .each = .{ .once = &.{ |
| | 121441 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121442 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 121443 | .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ }, |
| | 121444 | .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ }, |
| | 121445 | .{ ._, .vp_, switch (mir_tag) { |
| | 121446 | else => unreachable, |
| | 121447 | .@"and" => .@"or", |
| | 121448 | .@"or", .xor => .@"and", |
| | 121449 | }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ }, |
| | 121450 | .{ ._, .vp_, switch (mir_tag) { |
| | 121451 | else => unreachable, |
| | 121452 | .@"and" => .@"or", |
| | 121453 | .@"or", .xor => .@"and", |
| | 121454 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ }, |
| | 121455 | .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ }, |
| | 121456 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121457 | .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ }, |
| | 121458 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121459 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 121460 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121461 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121462 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121463 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121464 | } }, |
| | 121465 | }, .{ |
| | 121466 | .required_features = .{ .avx2, null, null, null }, |
| | 121467 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121468 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121469 | .patterns = &.{ |
| | 121470 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121471 | }, |
| | 121472 | .extra_temps = .{ |
| | 121473 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121474 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121475 | .ref = .src0, |
| | 121476 | .invert = switch (mir_tag) { |
| | 121477 | else => unreachable, |
| | 121478 | .@"and" => true, |
| | 121479 | .@"or", .xor => false, |
| | 121480 | }, |
| | 121481 | } } }, |
| | 121482 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121483 | .unused, |
| | 121484 | .unused, |
| | 121485 | .unused, |
| | 121486 | .unused, |
| | 121487 | .unused, |
| | 121488 | .unused, |
| | 121489 | .unused, |
| | 121490 | .unused, |
| | 121491 | }, |
| | 121492 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121493 | .each = .{ .once = &.{ |
| | 121494 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121495 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 121496 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 121497 | .{ ._, .vp_, switch (mir_tag) { |
| | 121498 | else => unreachable, |
| | 121499 | .@"and" => .@"or", |
| | 121500 | .@"or", .xor => .@"and", |
| | 121501 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 121502 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121503 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121504 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121505 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121506 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121507 | .{ ._, .vp_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121508 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121509 | } }, |
| | 121510 | }, .{ |
| | 121511 | .required_features = .{ .avx, null, null, null }, |
| | 121512 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121513 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| | 121514 | .patterns = &.{ |
| | 121515 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121516 | }, |
| | 121517 | .extra_temps = .{ |
| | 121518 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121519 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121520 | .ref = .src0, |
| | 121521 | .invert = switch (mir_tag) { |
| | 121522 | else => unreachable, |
| | 121523 | .@"and" => true, |
| | 121524 | .@"or", .xor => false, |
| | 121525 | }, |
| | 121526 | } } }, |
| | 121527 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121528 | .unused, |
| | 121529 | .unused, |
| | 121530 | .unused, |
| | 121531 | .unused, |
| | 121532 | .unused, |
| | 121533 | .unused, |
| | 121534 | .unused, |
| | 121535 | .unused, |
| | 121536 | }, |
| | 121537 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121538 | .each = .{ .once = &.{ |
| | 121539 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121540 | .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 121541 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 121542 | .{ ._, .v_ps, switch (mir_tag) { |
| | 121543 | else => unreachable, |
| | 121544 | .@"and" => .@"or", |
| | 121545 | .@"or", .xor => .@"and", |
| | 121546 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 121547 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121548 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121549 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121550 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121551 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121552 | .{ ._, .v_ps, .shuf, .tmp2x, .dst0x, .dst0x, .ui(0b11_10_11_10) }, |
| | 121553 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121554 | } }, |
| | 121555 | }, .{ |
| | 121556 | .required_features = .{ .sse2, null, null, null }, |
| | 121557 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121558 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 121559 | .patterns = &.{ |
| | 121560 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121561 | }, |
| | 121562 | .extra_temps = .{ |
| | 121563 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121564 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121565 | .ref = .src0, |
| | 121566 | .invert = switch (mir_tag) { |
| | 121567 | else => unreachable, |
| | 121568 | .@"and" => true, |
| | 121569 | .@"or", .xor => false, |
| | 121570 | }, |
| | 121571 | } } }, |
| | 121572 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 121573 | .unused, |
| | 121574 | .unused, |
| | 121575 | .unused, |
| | 121576 | .unused, |
| | 121577 | .unused, |
| | 121578 | .unused, |
| | 121579 | .unused, |
| | 121580 | .unused, |
| | 121581 | }, |
| | 121582 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121583 | .each = .{ .once = &.{ |
| | 121584 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121585 | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 121586 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, |
| | 121587 | .{ ._, .p_, switch (mir_tag) { |
| | 121588 | else => unreachable, |
| | 121589 | .@"and" => .@"or", |
| | 121590 | .@"or", .xor => .@"and", |
| | 121591 | }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 121592 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 121593 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 121594 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121595 | .{ ._, .p_d, .shuf, .tmp2x, .dst0x, .ui(0b11_10_11_10), ._ }, |
| | 121596 | .{ ._, .p_, mir_tag, .dst0x, .tmp2x, ._, ._ }, |
| | 121597 | } }, |
| | 121598 | }, .{ |
| | 121599 | .required_features = .{ .@"64bit", null, null, null }, |
| | 121600 | .dst_constraints = .{ .{ .int = .qword }, .any }, |
| | 121601 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| | 121602 | .patterns = &.{ |
| | 121603 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121604 | }, |
| | 121605 | .extra_temps = .{ |
| | 121606 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121607 | .unused, |
| | 121608 | .unused, |
| | 121609 | .unused, |
| | 121610 | .unused, |
| | 121611 | .unused, |
| | 121612 | .unused, |
| | 121613 | .unused, |
| | 121614 | .unused, |
| | 121615 | .unused, |
| | 121616 | .unused, |
| | 121617 | }, |
| | 121618 | .dst_temps = .{ .{ .rc = .general_purpose }, .unused }, |
| | 121619 | .clobbers = .{ .eflags = true }, |
| | 121620 | .each = .{ .once = &.{ |
| | 121621 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .src0, .add_unaligned_size), ._, ._ }, |
| | 121622 | .{ ._, ._, .mov, .dst0q, .memad(.src0q, .add_unaligned_size, -8), ._, ._ }, |
| | 121623 | .{ .@"0:", ._, mir_tag, .dst0q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 121624 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 121625 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121626 | } }, |
| | 121627 | }, .{ |
| | 121628 | .required_features = .{ .sse, null, null, null }, |
| | 121629 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121630 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 121631 | .patterns = &.{ |
| | 121632 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 121633 | .{ .src = .{ .mut_gpr, .none, .none } }, |
| | 121634 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 121635 | }, |
| | 121636 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 121637 | .each = .{ .once = &.{} }, |
| | 121638 | }, .{ |
| | 121639 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121640 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 121641 | .patterns = &.{ |
| | 121642 | .{ .src = .{ .to_mut_mem, .none, .none } }, |
| | 121643 | }, |
| | 121644 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 121645 | .each = .{ .once = &.{} }, |
| | 121646 | }, .{ |
| | 121647 | .required_features = .{ .avx2, null, null, null }, |
| | 121648 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121649 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| | 121650 | .patterns = &.{ |
| | 121651 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121652 | }, |
| | 121653 | .extra_temps = .{ |
| | 121654 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121655 | .unused, |
| | 121656 | .unused, |
| | 121657 | .unused, |
| | 121658 | .unused, |
| | 121659 | .unused, |
| | 121660 | .unused, |
| | 121661 | .unused, |
| | 121662 | .unused, |
| | 121663 | .unused, |
| | 121664 | .unused, |
| | 121665 | }, |
| | 121666 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121667 | .each = .{ .once = &.{ |
| | 121668 | .{ ._, .v_i128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 121669 | .{ ._, .vp_, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121670 | } }, |
| | 121671 | }, .{ |
| | 121672 | .required_features = .{ .avx, null, null, null }, |
| | 121673 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121674 | .src_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| | 121675 | .patterns = &.{ |
| | 121676 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 121677 | }, |
| | 121678 | .extra_temps = .{ |
| | 121679 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121680 | .unused, |
| | 121681 | .unused, |
| | 121682 | .unused, |
| | 121683 | .unused, |
| | 121684 | .unused, |
| | 121685 | .unused, |
| | 121686 | .unused, |
| | 121687 | .unused, |
| | 121688 | .unused, |
| | 121689 | .unused, |
| | 121690 | }, |
| | 121691 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121692 | .each = .{ .once = &.{ |
| | 121693 | .{ ._, .v_f128, .extract, .tmp0x, .src0y, .ui(1), ._ }, |
| | 121694 | .{ ._, .v_ps, mir_tag, .dst0x, .src0x, .tmp0x, ._ }, |
| | 121695 | } }, |
| | 121696 | }, .{ |
| | 121697 | .required_features = .{ .avx512f, null, null, null }, |
| | 121698 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121699 | .src_constraints = .{ .{ .exact_scalar_int = .{ .of = .zword, .is = .xword } }, .any, .any }, |
| | 121700 | .patterns = &.{ |
| | 121701 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121702 | }, |
| | 121703 | .extra_temps = .{ |
| | 121704 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121705 | .unused, |
| | 121706 | .unused, |
| | 121707 | .unused, |
| | 121708 | .unused, |
| | 121709 | .unused, |
| | 121710 | .unused, |
| | 121711 | .unused, |
| | 121712 | .unused, |
| | 121713 | .unused, |
| | 121714 | .unused, |
| | 121715 | }, |
| | 121716 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 121717 | .each = .{ .once = &.{ |
| | 121718 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 121719 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ }, |
| | 121720 | .{ ._, .v_i128, .extract, .tmp0x, .dst0y, .ui(1), ._ }, |
| | 121721 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121722 | } }, |
| | 121723 | }, .{ |
| | 121724 | .required_features = .{ .avx512f, null, null, null }, |
| | 121725 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121726 | .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .xword } }, .any, .any }, |
| | 121727 | .patterns = &.{ |
| | 121728 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121729 | }, |
| | 121730 | .extra_temps = .{ |
| | 121731 | .{ .type = .vector_2_u128, .kind = .{ .rc = .sse } }, |
| | 121732 | .unused, |
| | 121733 | .unused, |
| | 121734 | .unused, |
| | 121735 | .unused, |
| | 121736 | .unused, |
| | 121737 | .unused, |
| | 121738 | .unused, |
| | 121739 | .unused, |
| | 121740 | .unused, |
| | 121741 | .unused, |
| | 121742 | }, |
| | 121743 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121744 | .each = .{ .once = &.{ |
| | 121745 | .{ ._, .v_dqa, .mov, .tmp0y, .mem(.src0y), ._, ._ }, |
| | 121746 | .{ ._, .vp_, mir_tag, .dst0x, .tmp0x, .memd(.src0x, 32), ._ }, |
| | 121747 | .{ ._, .v_i128, .extract, .tmp0x, .tmp0y, .ui(1), ._ }, |
| | 121748 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp0x, ._ }, |
| | 121749 | } }, |
| | 121750 | }, .{ |
| | 121751 | .required_features = .{ .avx2, null, null, null }, |
| | 121752 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121753 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| | 121754 | .patterns = &.{ |
| | 121755 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121756 | }, |
| | 121757 | .extra_temps = .{ |
| | 121758 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121759 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121760 | .unused, |
| | 121761 | .unused, |
| | 121762 | .unused, |
| | 121763 | .unused, |
| | 121764 | .unused, |
| | 121765 | .unused, |
| | 121766 | .unused, |
| | 121767 | .unused, |
| | 121768 | .unused, |
| | 121769 | }, |
| | 121770 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121771 | .each = .{ .once = &.{ |
| | 121772 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 121773 | .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 121774 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121775 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121776 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121777 | .{ ._, .v_i128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 121778 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 121779 | } }, |
| | 121780 | }, .{ |
| | 121781 | .required_features = .{ .avx, null, null, null }, |
| | 121782 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121783 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| | 121784 | .patterns = &.{ |
| | 121785 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121786 | }, |
| | 121787 | .extra_temps = .{ |
| | 121788 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121789 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121790 | .unused, |
| | 121791 | .unused, |
| | 121792 | .unused, |
| | 121793 | .unused, |
| | 121794 | .unused, |
| | 121795 | .unused, |
| | 121796 | .unused, |
| | 121797 | .unused, |
| | 121798 | .unused, |
| | 121799 | }, |
| | 121800 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121801 | .each = .{ .once = &.{ |
| | 121802 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 121803 | .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 121804 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121805 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121806 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121807 | .{ ._, .v_f128, .extract, .tmp1x, .dst0y, .ui(1), ._ }, |
| | 121808 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp1x, ._ }, |
| | 121809 | } }, |
| | 121810 | }, .{ |
| | 121811 | .required_features = .{ .sse2, null, null, null }, |
| | 121812 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121813 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 121814 | .patterns = &.{ |
| | 121815 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121816 | }, |
| | 121817 | .extra_temps = .{ |
| | 121818 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121819 | .unused, |
| | 121820 | .unused, |
| | 121821 | .unused, |
| | 121822 | .unused, |
| | 121823 | .unused, |
| | 121824 | .unused, |
| | 121825 | .unused, |
| | 121826 | .unused, |
| | 121827 | .unused, |
| | 121828 | .unused, |
| | 121829 | }, |
| | 121830 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121831 | .each = .{ .once = &.{ |
| | 121832 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_unaligned_size), ._, ._ }, |
| | 121833 | .{ ._, ._dqa, .mov, .dst0x, .memad(.src0x, .add_unaligned_size, -16), ._, ._ }, |
| | 121834 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 121835 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 121836 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121837 | } }, |
| | 121838 | }, .{ |
| | 121839 | .required_features = .{ .avx512f, null, null, null }, |
| | 121840 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121841 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .xword } }, .any, .any }, |
| | 121842 | .patterns = &.{ |
| | 121843 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121844 | }, |
| | 121845 | .extra_temps = .{ |
| | 121846 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121847 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121848 | .ref = .src0, |
| | 121849 | .invert = switch (mir_tag) { |
| | 121850 | else => unreachable, |
| | 121851 | .@"and" => true, |
| | 121852 | .@"or", .xor => false, |
| | 121853 | }, |
| | 121854 | } } }, |
| | 121855 | .{ .type = .vector_2_u128, .kind = .{ .rc = .sse } }, |
| | 121856 | .unused, |
| | 121857 | .unused, |
| | 121858 | .unused, |
| | 121859 | .unused, |
| | 121860 | .unused, |
| | 121861 | .unused, |
| | 121862 | .unused, |
| | 121863 | .unused, |
| | 121864 | }, |
| | 121865 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121866 | .each = .{ .once = &.{ |
| | 121867 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121868 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 121869 | .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ }, |
| | 121870 | .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ }, |
| | 121871 | .{ ._, .vp_, switch (mir_tag) { |
| | 121872 | else => unreachable, |
| | 121873 | .@"and" => .@"or", |
| | 121874 | .@"or", .xor => .@"and", |
| | 121875 | }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ }, |
| | 121876 | .{ ._, .vp_, switch (mir_tag) { |
| | 121877 | else => unreachable, |
| | 121878 | .@"and" => .@"or", |
| | 121879 | .@"or", .xor => .@"and", |
| | 121880 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ }, |
| | 121881 | .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ }, |
| | 121882 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121883 | .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ }, |
| | 121884 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121885 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 121886 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121887 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121888 | } }, |
| | 121889 | }, .{ |
| | 121890 | .required_features = .{ .avx2, null, null, null }, |
| | 121891 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121892 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| | 121893 | .patterns = &.{ |
| | 121894 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121895 | }, |
| | 121896 | .extra_temps = .{ |
| | 121897 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121898 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121899 | .ref = .src0, |
| | 121900 | .invert = switch (mir_tag) { |
| | 121901 | else => unreachable, |
| | 121902 | .@"and" => true, |
| | 121903 | .@"or", .xor => false, |
| | 121904 | }, |
| | 121905 | } } }, |
| | 121906 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121907 | .unused, |
| | 121908 | .unused, |
| | 121909 | .unused, |
| | 121910 | .unused, |
| | 121911 | .unused, |
| | 121912 | .unused, |
| | 121913 | .unused, |
| | 121914 | .unused, |
| | 121915 | }, |
| | 121916 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121917 | .each = .{ .once = &.{ |
| | 121918 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121919 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 121920 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 121921 | .{ ._, .vp_, switch (mir_tag) { |
| | 121922 | else => unreachable, |
| | 121923 | .@"and" => .@"or", |
| | 121924 | .@"or", .xor => .@"and", |
| | 121925 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 121926 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121927 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121928 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121929 | .{ ._, .v_i128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121930 | .{ ._, .vp_, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121931 | } }, |
| | 121932 | }, .{ |
| | 121933 | .required_features = .{ .avx, null, null, null }, |
| | 121934 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121935 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .xword } }, .any, .any }, |
| | 121936 | .patterns = &.{ |
| | 121937 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121938 | }, |
| | 121939 | .extra_temps = .{ |
| | 121940 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121941 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121942 | .ref = .src0, |
| | 121943 | .invert = switch (mir_tag) { |
| | 121944 | else => unreachable, |
| | 121945 | .@"and" => true, |
| | 121946 | .@"or", .xor => false, |
| | 121947 | }, |
| | 121948 | } } }, |
| | 121949 | .{ .type = .vector_1_u128, .kind = .{ .rc = .sse } }, |
| | 121950 | .unused, |
| | 121951 | .unused, |
| | 121952 | .unused, |
| | 121953 | .unused, |
| | 121954 | .unused, |
| | 121955 | .unused, |
| | 121956 | .unused, |
| | 121957 | .unused, |
| | 121958 | }, |
| | 121959 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 121960 | .each = .{ .once = &.{ |
| | 121961 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 121962 | .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 121963 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 121964 | .{ ._, .v_ps, switch (mir_tag) { |
| | 121965 | else => unreachable, |
| | 121966 | .@"and" => .@"or", |
| | 121967 | .@"or", .xor => .@"and", |
| | 121968 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 121969 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 121970 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 121971 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 121972 | .{ ._, .v_f128, .extract, .tmp2x, .dst0y, .ui(1), ._ }, |
| | 121973 | .{ ._, .v_ps, mir_tag, .dst0x, .dst0x, .tmp2x, ._ }, |
| | 121974 | } }, |
| | 121975 | }, .{ |
| | 121976 | .required_features = .{ .sse2, null, null, null }, |
| | 121977 | .dst_constraints = .{ .{ .int = .xword }, .any }, |
| | 121978 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| | 121979 | .patterns = &.{ |
| | 121980 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 121981 | }, |
| | 121982 | .extra_temps = .{ |
| | 121983 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 121984 | .{ .type = .vector_16_u8, .kind = .{ .pand_mask_mem = .{ |
| | 121985 | .ref = .src0, |
| | 121986 | .invert = switch (mir_tag) { |
| | 121987 | else => unreachable, |
| | 121988 | .@"and" => true, |
| | 121989 | .@"or", .xor => false, |
| | 121990 | }, |
| | 121991 | } } }, |
| | 121992 | .unused, |
| | 121993 | .unused, |
| | 121994 | .unused, |
| | 121995 | .unused, |
| | 121996 | .unused, |
| | 121997 | .unused, |
| | 121998 | .unused, |
| | 121999 | .unused, |
| | 122000 | .unused, |
| | 122001 | }, |
| | 122002 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122003 | .each = .{ .once = &.{ |
| | 122004 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122005 | .{ ._, ._dqa, .mov, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 122006 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .src0, .add_size), ._, ._ }, |
| | 122007 | .{ ._, .p_, switch (mir_tag) { |
| | 122008 | else => unreachable, |
| | 122009 | .@"and" => .@"or", |
| | 122010 | .@"or", .xor => .@"and", |
| | 122011 | }, .dst0x, .memad(.src0x, .add_size, -16), ._, ._ }, |
| | 122012 | .{ .@"0:", .p_, mir_tag, .dst0x, .memi(.src0x, .tmp0), ._, ._ }, |
| | 122013 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 122014 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122015 | } }, |
| | 122016 | }, .{ |
| | 122017 | .required_features = .{ .avx, null, null, null }, |
| | 122018 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122019 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 122020 | .patterns = &.{ |
| | 122021 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 122022 | .{ .src = .{ .mut_gpr, .none, .none } }, |
| | 122023 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122024 | }, |
| | 122025 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122026 | .each = .{ .once = &.{} }, |
| | 122027 | }, .{ |
| | 122028 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122029 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 122030 | .patterns = &.{ |
| | 122031 | .{ .src = .{ .to_mut_mem, .none, .none } }, |
| | 122032 | }, |
| | 122033 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122034 | .each = .{ .once = &.{} }, |
| | 122035 | }, .{ |
| | 122036 | .required_features = .{ .avx512f, null, null, null }, |
| | 122037 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122038 | .src_constraints = .{ .{ .scalar_int = .{ .of = .zword, .is = .yword } }, .any, .any }, |
| | 122039 | .patterns = &.{ |
| | 122040 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122041 | }, |
| | 122042 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122043 | .each = .{ .once = &.{ |
| | 122044 | .{ ._, .v_dqa, .mov, .dst0y, .mem(.src0y), ._, ._ }, |
| | 122045 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memd(.src0y, 32), ._ }, |
| | 122046 | } }, |
| | 122047 | }, .{ |
| | 122048 | .required_features = .{ .avx2, null, null, null }, |
| | 122049 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122050 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 122051 | .patterns = &.{ |
| | 122052 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122053 | }, |
| | 122054 | .extra_temps = .{ |
| | 122055 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122056 | .unused, |
| | 122057 | .unused, |
| | 122058 | .unused, |
| | 122059 | .unused, |
| | 122060 | .unused, |
| | 122061 | .unused, |
| | 122062 | .unused, |
| | 122063 | .unused, |
| | 122064 | .unused, |
| | 122065 | .unused, |
| | 122066 | }, |
| | 122067 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122068 | .each = .{ .once = &.{ |
| | 122069 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 122070 | .{ ._, .v_dqa, .mov, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 122071 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 122072 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122073 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122074 | } }, |
| | 122075 | }, .{ |
| | 122076 | .required_features = .{ .avx, null, null, null }, |
| | 122077 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122078 | .src_constraints = .{ .{ .unaligned_multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 122079 | .patterns = &.{ |
| | 122080 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122081 | }, |
| | 122082 | .extra_temps = .{ |
| | 122083 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122084 | .unused, |
| | 122085 | .unused, |
| | 122086 | .unused, |
| | 122087 | .unused, |
| | 122088 | .unused, |
| | 122089 | .unused, |
| | 122090 | .unused, |
| | 122091 | .unused, |
| | 122092 | .unused, |
| | 122093 | .unused, |
| | 122094 | }, |
| | 122095 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122096 | .each = .{ .once = &.{ |
| | 122097 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_unaligned_size), ._, ._ }, |
| | 122098 | .{ ._, .v_ps, .mova, .dst0y, .memad(.src0y, .add_unaligned_size, -32), ._, ._ }, |
| | 122099 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 122100 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122101 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122102 | } }, |
| | 122103 | }, .{ |
| | 122104 | .required_features = .{ .avx512f, null, null, null }, |
| | 122105 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122106 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .zword, .is = .yword } }, .any, .any }, |
| | 122107 | .patterns = &.{ |
| | 122108 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122109 | }, |
| | 122110 | .extra_temps = .{ |
| | 122111 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122112 | .{ .type = .vector_64_u8, .kind = .{ .pand_mask_mem = .{ |
| | 122113 | .ref = .src0, |
| | 122114 | .invert = switch (mir_tag) { |
| | 122115 | else => unreachable, |
| | 122116 | .@"and" => true, |
| | 122117 | .@"or", .xor => false, |
| | 122118 | }, |
| | 122119 | } } }, |
| | 122120 | .{ .type = .vector_1_u256, .kind = .{ .rc = .sse } }, |
| | 122121 | .unused, |
| | 122122 | .unused, |
| | 122123 | .unused, |
| | 122124 | .unused, |
| | 122125 | .unused, |
| | 122126 | .unused, |
| | 122127 | .unused, |
| | 122128 | .unused, |
| | 122129 | }, |
| | 122130 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122131 | .each = .{ .once = &.{ |
| | 122132 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122133 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 122134 | .{ ._, .v_dqa, .mov, .tmp2y, .lead(.tmp0y, 32), ._, ._ }, |
| | 122135 | .{ ._, ._, .mov, .tmp0d, .sia(-128, .src0, .add_size), ._, ._ }, |
| | 122136 | .{ ._, .vp_, switch (mir_tag) { |
| | 122137 | else => unreachable, |
| | 122138 | .@"and" => .@"or", |
| | 122139 | .@"or", .xor => .@"and", |
| | 122140 | }, .tmp2y, .tmp2y, .memad(.src0y, .add_size, -32), ._ }, |
| | 122141 | .{ ._, .vp_, switch (mir_tag) { |
| | 122142 | else => unreachable, |
| | 122143 | .@"and" => .@"or", |
| | 122144 | .@"or", .xor => .@"and", |
| | 122145 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -64), ._ }, |
| | 122146 | .{ .@"0:", .vp_, mir_tag, .tmp2y, .tmp2y, .memid(.src0y, .tmp0, 32), ._ }, |
| | 122147 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 122148 | .{ ._, ._, .sub, .tmp0d, .si(64), ._, ._ }, |
| | 122149 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122150 | .{ ._, .vp_, mir_tag, .dst0y, .dst0y, .tmp2y, ._ }, |
| | 122151 | } }, |
| | 122152 | }, .{ |
| | 122153 | .required_features = .{ .avx2, null, null, null }, |
| | 122154 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122155 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 122156 | .patterns = &.{ |
| | 122157 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122158 | }, |
| | 122159 | .extra_temps = .{ |
| | 122160 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122161 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 122162 | .ref = .src0, |
| | 122163 | .invert = switch (mir_tag) { |
| | 122164 | else => unreachable, |
| | 122165 | .@"and" => true, |
| | 122166 | .@"or", .xor => false, |
| | 122167 | }, |
| | 122168 | } } }, |
| | 122169 | .unused, |
| | 122170 | .unused, |
| | 122171 | .unused, |
| | 122172 | .unused, |
| | 122173 | .unused, |
| | 122174 | .unused, |
| | 122175 | .unused, |
| | 122176 | .unused, |
| | 122177 | .unused, |
| | 122178 | }, |
| | 122179 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122180 | .each = .{ .once = &.{ |
| | 122181 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122182 | .{ ._, .v_dqa, .mov, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 122183 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 122184 | .{ ._, .vp_, switch (mir_tag) { |
| | 122185 | else => unreachable, |
| | 122186 | .@"and" => .@"or", |
| | 122187 | .@"or", .xor => .@"and", |
| | 122188 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 122189 | .{ .@"0:", .vp_, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 122190 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122191 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122192 | } }, |
| | 122193 | }, .{ |
| | 122194 | .required_features = .{ .avx, null, null, null }, |
| | 122195 | .dst_constraints = .{ .{ .int = .yword }, .any }, |
| | 122196 | .src_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .yword } }, .any, .any }, |
| | 122197 | .patterns = &.{ |
| | 122198 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122199 | }, |
| | 122200 | .extra_temps = .{ |
| | 122201 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122202 | .{ .type = .vector_32_u8, .kind = .{ .pand_mask_mem = .{ |
| | 122203 | .ref = .src0, |
| | 122204 | .invert = switch (mir_tag) { |
| | 122205 | else => unreachable, |
| | 122206 | .@"and" => true, |
| | 122207 | .@"or", .xor => false, |
| | 122208 | }, |
| | 122209 | } } }, |
| | 122210 | .unused, |
| | 122211 | .unused, |
| | 122212 | .unused, |
| | 122213 | .unused, |
| | 122214 | .unused, |
| | 122215 | .unused, |
| | 122216 | .unused, |
| | 122217 | .unused, |
| | 122218 | .unused, |
| | 122219 | }, |
| | 122220 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122221 | .each = .{ .once = &.{ |
| | 122222 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122223 | .{ ._, .v_ps, .mova, .dst0y, .lea(.tmp0y), ._, ._ }, |
| | 122224 | .{ ._, ._, .mov, .tmp0d, .sia(-64, .src0, .add_size), ._, ._ }, |
| | 122225 | .{ ._, .v_ps, switch (mir_tag) { |
| | 122226 | else => unreachable, |
| | 122227 | .@"and" => .@"or", |
| | 122228 | .@"or", .xor => .@"and", |
| | 122229 | }, .dst0y, .dst0y, .memad(.src0y, .add_size, -32), ._ }, |
| | 122230 | .{ .@"0:", .v_ps, mir_tag, .dst0y, .dst0y, .memi(.src0y, .tmp0), ._ }, |
| | 122231 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122232 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122233 | } }, |
| | 122234 | }, .{ |
| | 122235 | .dst_constraints = .{ .any_int, .any }, |
| | 122236 | .src_constraints = .{ .{ .vec_len = 1 }, .any, .any }, |
| | 122237 | .patterns = &.{ |
| | 122238 | .{ .src = .{ .to_mut_mem, .none, .none } }, |
| | 122239 | }, |
| | 122240 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122241 | .each = .{ .once = &.{} }, |
| | 122242 | }, .{ |
| | 122243 | .required_features = .{ .@"64bit", null, null, null }, |
| | 122244 | .dst_constraints = .{ .{ .remainder_int = .{ .of = .qword, .is = .qword } }, .any }, |
| | 122245 | .src_constraints = .{ .{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| | 122246 | .patterns = &.{ |
| | 122247 | .{ .src = .{ .to_mem, .none, .none } }, |
| | 122248 | }, |
| | 122249 | .extra_temps = .{ |
| | 122250 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122251 | .{ .type = .u32, .kind = .{ .reg = .rsi } }, |
| | 122252 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 122253 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 122254 | .unused, |
| | 122255 | .unused, |
| | 122256 | .unused, |
| | 122257 | .unused, |
| | 122258 | .unused, |
| | 122259 | .unused, |
| | 122260 | .unused, |
| | 122261 | }, |
| | 122262 | .dst_temps = .{ .mem, .unused }, |
| | 122263 | .clobbers = .{ .eflags = true }, |
| | 122264 | .each = .{ .once = &.{ |
| | 122265 | .{ ._, ._, .mov, .tmp0d, .sa(.src0, .add_unaligned_size_sub_2_elem_size), ._, ._ }, |
| | 122266 | .{ ._, ._, .lea, .tmp1p, .mema(.src0, .add_unaligned_size_sub_elem_size), ._, ._ }, |
| | 122267 | .{ ._, ._, .lea, .tmp2p, .mem(.dst0), ._, ._ }, |
| | 122268 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_size_div_8), ._, ._ }, |
| | 122269 | .{ ._, .@"rep _sq", .mov, ._, ._, ._, ._ }, |
| | 122270 | .{ .@"0:", ._, .mov, .tmp1d, .sia(-8, .dst0, .add_size), ._, ._ }, |
| | 122271 | .{ ._, ._, .lea, .tmp2q, .memi(.src0, .tmp0), ._, ._ }, |
| | 122272 | .{ .@"1:", ._, .mov, .tmp3q, .leai(.tmp2q, .tmp1), ._, ._ }, |
| | 122273 | .{ ._, ._, mir_tag, .memi(.dst0q, .tmp1), .tmp3q, ._, ._ }, |
| | 122274 | .{ ._, ._, .sub, .tmp1d, .si(8), ._, ._ }, |
| | 122275 | .{ ._, ._nb, .j, .@"1b", ._, ._, ._ }, |
| | 122276 | .{ ._, ._, .sub, .tmp0d, .sa(.dst0, .add_size), ._, ._ }, |
| | 122277 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122278 | } }, |
| | 122279 | } }, |
| | 122280 | }, |
| | 122281 | .Min, .Max, .Add, .Mul => unreachable, |
| | 122282 | }) catch |err| switch (err) { |
| | 122283 | error.SelectFailed => return cg.fail("failed to select {s} {} {}", .{ |
| | 122284 | @tagName(air_tag), |
| | 122285 | cg.typeOf(reduce.operand).fmt(pt), |
| | 122286 | ops[0].tracking(cg), |
| | 122287 | }), |
| | 122288 | else => |e| return e, |
| | 122289 | }; |
| | 122290 | try res[0].finish(inst, &.{reduce.operand}, &ops, cg); |
| | 122291 | }, |
| | 122292 | .splat => |air_tag| if (use_old) try cg.airSplat(inst) else fallback: { |
| | 122293 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| | 122294 | if (cg.typeOf(ty_op.operand).toIntern() == .bool_type) break :fallback try cg.airSplat(inst); |
| | 122295 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| | 122296 | var res: [1]Temp = undefined; |
| | 122297 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| | 122298 | .required_features = .{ .avx2, null, null, null }, |
| | 122299 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122300 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122301 | .patterns = &.{ |
| | 122302 | .{ .src = .{ .mem, .none, .none } }, |
| | 122303 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122304 | }, |
| | 122305 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122306 | .each = .{ .once = &.{ |
| | 122307 | .{ ._, .vp_b, .broadcast, .dst0x, .src0b, ._, ._ }, |
| | 122308 | } }, |
| | 122309 | }, .{ |
| | 122310 | .required_features = .{ .avx, null, null, null }, |
| | 122311 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122312 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122313 | .patterns = &.{ |
| | 122314 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122315 | }, |
| | 122316 | .extra_temps = .{ |
| | 122317 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 122318 | .unused, |
| | 122319 | .unused, |
| | 122320 | .unused, |
| | 122321 | .unused, |
| | 122322 | .unused, |
| | 122323 | .unused, |
| | 122324 | .unused, |
| | 122325 | .unused, |
| | 122326 | .unused, |
| | 122327 | .unused, |
| | 122328 | }, |
| | 122329 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122330 | .each = .{ .once = &.{ |
| | 122331 | .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ }, |
| | 122332 | .{ ._, .vp_b, .shuf, .dst0x, .src0x, .tmp0x, ._ }, |
| | 122333 | } }, |
| | 122334 | }, .{ |
| | 122335 | .required_features = .{ .ssse3, null, null, null }, |
| | 122336 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122337 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122338 | .patterns = &.{ |
| | 122339 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122340 | }, |
| | 122341 | .extra_temps = .{ |
| | 122342 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 122343 | .unused, |
| | 122344 | .unused, |
| | 122345 | .unused, |
| | 122346 | .unused, |
| | 122347 | .unused, |
| | 122348 | .unused, |
| | 122349 | .unused, |
| | 122350 | .unused, |
| | 122351 | .unused, |
| | 122352 | .unused, |
| | 122353 | }, |
| | 122354 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122355 | .each = .{ .once = &.{ |
| | 122356 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| | 122357 | .{ ._, .p_b, .shuf, .dst0x, .tmp0x, ._, ._ }, |
| | 122358 | } }, |
| | 122359 | }, .{ |
| | 122360 | .required_features = .{ .sse2, null, null, null }, |
| | 122361 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122362 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122363 | .patterns = &.{ |
| | 122364 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122365 | }, |
| | 122366 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122367 | .each = .{ .once = &.{ |
| | 122368 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 122369 | .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122370 | .{ ._, .p_d, .shuf, .dst0x, .dst0x, .ui(0b00_00_00_00), ._ }, |
| | 122371 | } }, |
| | 122372 | }, .{ |
| | 122373 | .required_features = .{ .avx2, null, null, null }, |
| | 122374 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .byte } }, .any }, |
| | 122375 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122376 | .patterns = &.{ |
| | 122377 | .{ .src = .{ .mem, .none, .none } }, |
| | 122378 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122379 | }, |
| | 122380 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122381 | .each = .{ .once = &.{ |
| | 122382 | .{ ._, .vp_b, .broadcast, .dst0y, .src0b, ._, ._ }, |
| | 122383 | } }, |
| | 122384 | }, .{ |
| | 122385 | .required_features = .{ .avx2, null, null, null }, |
| | 122386 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .byte } }, .any }, |
| | 122387 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122388 | .patterns = &.{ |
| | 122389 | .{ .src = .{ .mem, .none, .none } }, |
| | 122390 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122391 | }, |
| | 122392 | .extra_temps = .{ |
| | 122393 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122394 | .{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122395 | .unused, |
| | 122396 | .unused, |
| | 122397 | .unused, |
| | 122398 | .unused, |
| | 122399 | .unused, |
| | 122400 | .unused, |
| | 122401 | .unused, |
| | 122402 | .unused, |
| | 122403 | .unused, |
| | 122404 | }, |
| | 122405 | .dst_temps = .{ .mem, .unused }, |
| | 122406 | .each = .{ .once = &.{ |
| | 122407 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, |
| | 122408 | .{ ._, .vp_b, .broadcast, .tmp1y, .src0b, ._, ._ }, |
| | 122409 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, |
| | 122410 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122411 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122412 | } }, |
| | 122413 | }, .{ |
| | 122414 | .required_features = .{ .avx, null, null, null }, |
| | 122415 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122416 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122417 | .patterns = &.{ |
| | 122418 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122419 | }, |
| | 122420 | .extra_temps = .{ |
| | 122421 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 122422 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122423 | .{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122424 | .unused, |
| | 122425 | .unused, |
| | 122426 | .unused, |
| | 122427 | .unused, |
| | 122428 | .unused, |
| | 122429 | .unused, |
| | 122430 | .unused, |
| | 122431 | .unused, |
| | 122432 | }, |
| | 122433 | .dst_temps = .{ .mem, .unused }, |
| | 122434 | .each = .{ .once = &.{ |
| | 122435 | .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ }, |
| | 122436 | .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122437 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .tmp0x, ._ }, |
| | 122438 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp1), .tmp2x, ._, ._ }, |
| | 122439 | .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, |
| | 122440 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122441 | } }, |
| | 122442 | }, .{ |
| | 122443 | .required_features = .{ .ssse3, null, null, null }, |
| | 122444 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122445 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122446 | .patterns = &.{ |
| | 122447 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122448 | }, |
| | 122449 | .extra_temps = .{ |
| | 122450 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 122451 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122452 | .unused, |
| | 122453 | .unused, |
| | 122454 | .unused, |
| | 122455 | .unused, |
| | 122456 | .unused, |
| | 122457 | .unused, |
| | 122458 | .unused, |
| | 122459 | .unused, |
| | 122460 | .unused, |
| | 122461 | }, |
| | 122462 | .dst_temps = .{ .mem, .unused }, |
| | 122463 | .each = .{ .once = &.{ |
| | 122464 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| | 122465 | .{ ._, ._, .mov, .tmp1d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122466 | .{ ._, .p_b, .shuf, .src0x, .tmp0x, ._, ._ }, |
| | 122467 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp1), .src0x, ._, ._ }, |
| | 122468 | .{ ._, ._, .sub, .tmp1d, .si(16), ._, ._ }, |
| | 122469 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122470 | } }, |
| | 122471 | }, .{ |
| | 122472 | .required_features = .{ .sse2, null, null, null }, |
| | 122473 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .byte } }, .any }, |
| | 122474 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122475 | .patterns = &.{ |
| | 122476 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122477 | }, |
| | 122478 | .extra_temps = .{ |
| | 122479 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122480 | .unused, |
| | 122481 | .unused, |
| | 122482 | .unused, |
| | 122483 | .unused, |
| | 122484 | .unused, |
| | 122485 | .unused, |
| | 122486 | .unused, |
| | 122487 | .unused, |
| | 122488 | .unused, |
| | 122489 | .unused, |
| | 122490 | }, |
| | 122491 | .dst_temps = .{ .mem, .unused }, |
| | 122492 | .each = .{ .once = &.{ |
| | 122493 | .{ ._, .p_, .unpcklbw, .src0x, .src0x, ._, ._ }, |
| | 122494 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122495 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122496 | .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122497 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, |
| | 122498 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 122499 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122500 | } }, |
| | 122501 | }, .{ |
| | 122502 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 122503 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| | 122504 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122505 | .patterns = &.{ |
| | 122506 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 122507 | }, |
| | 122508 | .extra_temps = .{ |
| | 122509 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122510 | .unused, |
| | 122511 | .unused, |
| | 122512 | .unused, |
| | 122513 | .unused, |
| | 122514 | .unused, |
| | 122515 | .unused, |
| | 122516 | .unused, |
| | 122517 | .unused, |
| | 122518 | .unused, |
| | 122519 | .unused, |
| | 122520 | }, |
| | 122521 | .dst_temps = .{ .mem, .unused }, |
| | 122522 | .each = .{ .once = &.{ |
| | 122523 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_size), ._, ._ }, |
| | 122524 | .{ .@"0:", ._, .mov, .memi(.dst0b, .tmp0), .src0b, ._, ._ }, |
| | 122525 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 122526 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122527 | } }, |
| | 122528 | }, .{ |
| | 122529 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }, .any }, |
| | 122530 | .src_constraints = .{ .{ .int = .byte }, .any, .any }, |
| | 122531 | .patterns = &.{ |
| | 122532 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 122533 | }, |
| | 122534 | .extra_temps = .{ |
| | 122535 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122536 | .unused, |
| | 122537 | .unused, |
| | 122538 | .unused, |
| | 122539 | .unused, |
| | 122540 | .unused, |
| | 122541 | .unused, |
| | 122542 | .unused, |
| | 122543 | .unused, |
| | 122544 | .unused, |
| | 122545 | .unused, |
| | 122546 | }, |
| | 122547 | .dst_temps = .{ .mem, .unused }, |
| | 122548 | .each = .{ .once = &.{ |
| | 122549 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .dst0, .add_size), ._, ._ }, |
| | 122550 | .{ .@"0:", ._, .mov, .memi(.dst0b, .tmp0), .src0b, ._, ._ }, |
| | 122551 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 122552 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 122553 | } }, |
| | 122554 | }, .{ |
| | 122555 | .required_features = .{ .avx2, null, null, null }, |
| | 122556 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122557 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122558 | .patterns = &.{ |
| | 122559 | .{ .src = .{ .mem, .none, .none } }, |
| | 122560 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122561 | }, |
| | 122562 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122563 | .each = .{ .once = &.{ |
| | 122564 | .{ ._, .vp_w, .broadcast, .dst0x, .src0w, ._, ._ }, |
| | 122565 | } }, |
| | 122566 | }, .{ |
| | 122567 | .required_features = .{ .avx, null, null, null }, |
| | 122568 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122569 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122570 | .patterns = &.{ |
| | 122571 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122572 | }, |
| | 122573 | .extra_temps = .{ |
| | 122574 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 122575 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, |
| | 122576 | .unused, |
| | 122577 | .unused, |
| | 122578 | .unused, |
| | 122579 | .unused, |
| | 122580 | .unused, |
| | 122581 | .unused, |
| | 122582 | .unused, |
| | 122583 | .unused, |
| | 122584 | .unused, |
| | 122585 | }, |
| | 122586 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122587 | .each = .{ .once = &.{ |
| | 122588 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122589 | .{ ._, .vp_b, .shuf, .dst0x, .src0x, .lea(.tmp0x), ._ }, |
| | 122590 | } }, |
| | 122591 | }, .{ |
| | 122592 | .required_features = .{ .ssse3, null, null, null }, |
| | 122593 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122594 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122595 | .patterns = &.{ |
| | 122596 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122597 | }, |
| | 122598 | .extra_temps = .{ |
| | 122599 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 122600 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, |
| | 122601 | .unused, |
| | 122602 | .unused, |
| | 122603 | .unused, |
| | 122604 | .unused, |
| | 122605 | .unused, |
| | 122606 | .unused, |
| | 122607 | .unused, |
| | 122608 | .unused, |
| | 122609 | .unused, |
| | 122610 | }, |
| | 122611 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122612 | .each = .{ .once = &.{ |
| | 122613 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122614 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 122615 | } }, |
| | 122616 | }, .{ |
| | 122617 | .required_features = .{ .sse2, null, null, null }, |
| | 122618 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122619 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122620 | .patterns = &.{ |
| | 122621 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122622 | }, |
| | 122623 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122624 | .each = .{ .once = &.{ |
| | 122625 | .{ ._, .p_w, .shufl, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122626 | .{ ._, .p_d, .shuf, .dst0x, .dst0x, .ui(0b00_00_00_00), ._ }, |
| | 122627 | } }, |
| | 122628 | }, .{ |
| | 122629 | .required_features = .{ .avx2, null, null, null }, |
| | 122630 | .dst_constraints = .{ .{ .scalar = .{ .of = .yword, .is = .word } }, .any }, |
| | 122631 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122632 | .patterns = &.{ |
| | 122633 | .{ .src = .{ .mem, .none, .none } }, |
| | 122634 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122635 | }, |
| | 122636 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122637 | .each = .{ .once = &.{ |
| | 122638 | .{ ._, .vp_w, .broadcast, .dst0y, .src0w, ._, ._ }, |
| | 122639 | } }, |
| | 122640 | }, .{ |
| | 122641 | .required_features = .{ .avx2, null, null, null }, |
| | 122642 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .yword, .is = .word } }, .any }, |
| | 122643 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122644 | .patterns = &.{ |
| | 122645 | .{ .src = .{ .mem, .none, .none } }, |
| | 122646 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122647 | }, |
| | 122648 | .extra_temps = .{ |
| | 122649 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122650 | .{ .type = .vector_16_u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122651 | .unused, |
| | 122652 | .unused, |
| | 122653 | .unused, |
| | 122654 | .unused, |
| | 122655 | .unused, |
| | 122656 | .unused, |
| | 122657 | .unused, |
| | 122658 | .unused, |
| | 122659 | .unused, |
| | 122660 | }, |
| | 122661 | .dst_temps = .{ .mem, .unused }, |
| | 122662 | .each = .{ .once = &.{ |
| | 122663 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, |
| | 122664 | .{ ._, .vp_w, .broadcast, .tmp1y, .src0w, ._, ._ }, |
| | 122665 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, |
| | 122666 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122667 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122668 | } }, |
| | 122669 | }, .{ |
| | 122670 | .required_features = .{ .avx, null, null, null }, |
| | 122671 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122672 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122673 | .patterns = &.{ |
| | 122674 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122675 | }, |
| | 122676 | .extra_temps = .{ |
| | 122677 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122678 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, |
| | 122679 | .{ .type = .vector_8_u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122680 | .unused, |
| | 122681 | .unused, |
| | 122682 | .unused, |
| | 122683 | .unused, |
| | 122684 | .unused, |
| | 122685 | .unused, |
| | 122686 | .unused, |
| | 122687 | .unused, |
| | 122688 | }, |
| | 122689 | .dst_temps = .{ .mem, .unused }, |
| | 122690 | .each = .{ .once = &.{ |
| | 122691 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122692 | .{ ._, .vp_b, .shuf, .tmp2x, .src0x, .lea(.tmp0x), ._ }, |
| | 122693 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122694 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp2x, ._, ._ }, |
| | 122695 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 122696 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122697 | } }, |
| | 122698 | }, .{ |
| | 122699 | .required_features = .{ .ssse3, null, null, null }, |
| | 122700 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122701 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122702 | .patterns = &.{ |
| | 122703 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122704 | }, |
| | 122705 | .extra_temps = .{ |
| | 122706 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122707 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_splat_mem = .{ .size = .word } } }, |
| | 122708 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 122709 | .unused, |
| | 122710 | .unused, |
| | 122711 | .unused, |
| | 122712 | .unused, |
| | 122713 | .unused, |
| | 122714 | .unused, |
| | 122715 | .unused, |
| | 122716 | .unused, |
| | 122717 | }, |
| | 122718 | .dst_temps = .{ .mem, .unused }, |
| | 122719 | .each = .{ .once = &.{ |
| | 122720 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 122721 | .{ ._, .p_b, .shuf, .src0x, .lea(.tmp0x), ._, ._ }, |
| | 122722 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122723 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, |
| | 122724 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 122725 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122726 | } }, |
| | 122727 | }, .{ |
| | 122728 | .required_features = .{ .sse2, null, null, null }, |
| | 122729 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .word } }, .any }, |
| | 122730 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122731 | .patterns = &.{ |
| | 122732 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122733 | }, |
| | 122734 | .extra_temps = .{ |
| | 122735 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122736 | .unused, |
| | 122737 | .unused, |
| | 122738 | .unused, |
| | 122739 | .unused, |
| | 122740 | .unused, |
| | 122741 | .unused, |
| | 122742 | .unused, |
| | 122743 | .unused, |
| | 122744 | .unused, |
| | 122745 | .unused, |
| | 122746 | }, |
| | 122747 | .dst_temps = .{ .mem, .unused }, |
| | 122748 | .each = .{ .once = &.{ |
| | 122749 | .{ ._, .p_w, .shufl, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122750 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122751 | .{ ._, .p_d, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122752 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, |
| | 122753 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 122754 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122755 | } }, |
| | 122756 | }, .{ |
| | 122757 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .word, .is = .word } }, .any }, |
| | 122758 | .src_constraints = .{ .{ .int_or_float = .word }, .any, .any }, |
| | 122759 | .patterns = &.{ |
| | 122760 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 122761 | }, |
| | 122762 | .extra_temps = .{ |
| | 122763 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122764 | .unused, |
| | 122765 | .unused, |
| | 122766 | .unused, |
| | 122767 | .unused, |
| | 122768 | .unused, |
| | 122769 | .unused, |
| | 122770 | .unused, |
| | 122771 | .unused, |
| | 122772 | .unused, |
| | 122773 | .unused, |
| | 122774 | }, |
| | 122775 | .dst_temps = .{ .mem, .unused }, |
| | 122776 | .each = .{ .once = &.{ |
| | 122777 | .{ ._, ._, .mov, .tmp0d, .sia(-2, .dst0, .add_size), ._, ._ }, |
| | 122778 | .{ .@"0:", ._, .mov, .memi(.dst0w, .tmp0), .src0w, ._, ._ }, |
| | 122779 | .{ ._, ._, .sub, .tmp0d, .si(2), ._, ._ }, |
| | 122780 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122781 | } }, |
| | 122782 | }, .{ |
| | 122783 | .required_features = .{ .avx2, null, null, null }, |
| | 122784 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122785 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 122786 | .patterns = &.{ |
| | 122787 | .{ .src = .{ .mem, .none, .none } }, |
| | 122788 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122789 | }, |
| | 122790 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122791 | .each = .{ .once = &.{ |
| | 122792 | .{ ._, .vp_d, .broadcast, .dst0x, .src0d, ._, ._ }, |
| | 122793 | } }, |
| | 122794 | }, .{ |
| | 122795 | .required_features = .{ .avx2, null, null, null }, |
| | 122796 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122797 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 122798 | .patterns = &.{ |
| | 122799 | .{ .src = .{ .mem, .none, .none } }, |
| | 122800 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122801 | }, |
| | 122802 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122803 | .each = .{ .once = &.{ |
| | 122804 | .{ ._, .v_ss, .broadcast, .dst0x, .src0d, ._, ._ }, |
| | 122805 | } }, |
| | 122806 | }, .{ |
| | 122807 | .required_features = .{ .avx, null, null, null }, |
| | 122808 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122809 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, |
| | 122810 | .patterns = &.{ |
| | 122811 | .{ .src = .{ .mem, .none, .none } }, |
| | 122812 | }, |
| | 122813 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122814 | .each = .{ .once = &.{ |
| | 122815 | .{ ._, .v_ss, .broadcast, .dst0x, .src0d, ._, ._ }, |
| | 122816 | } }, |
| | 122817 | }, .{ |
| | 122818 | .required_features = .{ .avx, null, null, null }, |
| | 122819 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122820 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 122821 | .patterns = &.{ |
| | 122822 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122823 | }, |
| | 122824 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122825 | .each = .{ .once = &.{ |
| | 122826 | .{ ._, .vp_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122827 | } }, |
| | 122828 | }, .{ |
| | 122829 | .required_features = .{ .avx, null, null, null }, |
| | 122830 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122831 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 122832 | .patterns = &.{ |
| | 122833 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122834 | }, |
| | 122835 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122836 | .each = .{ .once = &.{ |
| | 122837 | .{ ._, .v_ps, .shuf, .dst0x, .src0x, .src0x, .ui(0b00_00_00_00) }, |
| | 122838 | } }, |
| | 122839 | }, .{ |
| | 122840 | .required_features = .{ .sse2, null, null, null }, |
| | 122841 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122842 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 122843 | .patterns = &.{ |
| | 122844 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122845 | }, |
| | 122846 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122847 | .each = .{ .once = &.{ |
| | 122848 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122849 | } }, |
| | 122850 | }, .{ |
| | 122851 | .required_features = .{ .sse, null, null, null }, |
| | 122852 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122853 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 122854 | .patterns = &.{ |
| | 122855 | .{ .src = .{ .mut_sse, .none, .none } }, |
| | 122856 | }, |
| | 122857 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122858 | .each = .{ .once = &.{ |
| | 122859 | .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122860 | } }, |
| | 122861 | }, .{ |
| | 122862 | .required_features = .{ .sse2, null, null, null }, |
| | 122863 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122864 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 122865 | .patterns = &.{ |
| | 122866 | .{ .src = .{ .sse, .none, .none } }, |
| | 122867 | }, |
| | 122868 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 122869 | .each = .{ .once = &.{ |
| | 122870 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122871 | } }, |
| | 122872 | }, .{ |
| | 122873 | .required_features = .{ .sse, null, null, null }, |
| | 122874 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122875 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, |
| | 122876 | .patterns = &.{ |
| | 122877 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 122878 | }, |
| | 122879 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 122880 | .each = .{ .once = &.{ |
| | 122881 | .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 122882 | } }, |
| | 122883 | }, .{ |
| | 122884 | .required_features = .{ .avx2, null, null, null }, |
| | 122885 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| | 122886 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 122887 | .patterns = &.{ |
| | 122888 | .{ .src = .{ .mem, .none, .none } }, |
| | 122889 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122890 | }, |
| | 122891 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122892 | .each = .{ .once = &.{ |
| | 122893 | .{ ._, .vp_d, .broadcast, .dst0y, .src0d, ._, ._ }, |
| | 122894 | } }, |
| | 122895 | }, .{ |
| | 122896 | .required_features = .{ .avx2, null, null, null }, |
| | 122897 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .dword } }, .any }, |
| | 122898 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 122899 | .patterns = &.{ |
| | 122900 | .{ .src = .{ .mem, .none, .none } }, |
| | 122901 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122902 | }, |
| | 122903 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 122904 | .each = .{ .once = &.{ |
| | 122905 | .{ ._, .v_ss, .broadcast, .dst0y, .src0d, ._, ._ }, |
| | 122906 | } }, |
| | 122907 | }, .{ |
| | 122908 | .required_features = .{ .avx2, null, null, null }, |
| | 122909 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } }, .any }, |
| | 122910 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 122911 | .patterns = &.{ |
| | 122912 | .{ .src = .{ .mem, .none, .none } }, |
| | 122913 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122914 | }, |
| | 122915 | .extra_temps = .{ |
| | 122916 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122917 | .{ .type = .vector_8_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122918 | .unused, |
| | 122919 | .unused, |
| | 122920 | .unused, |
| | 122921 | .unused, |
| | 122922 | .unused, |
| | 122923 | .unused, |
| | 122924 | .unused, |
| | 122925 | .unused, |
| | 122926 | .unused, |
| | 122927 | }, |
| | 122928 | .dst_temps = .{ .mem, .unused }, |
| | 122929 | .each = .{ .once = &.{ |
| | 122930 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, |
| | 122931 | .{ ._, .vp_d, .broadcast, .tmp1y, .src0d, ._, ._ }, |
| | 122932 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, |
| | 122933 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122934 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122935 | } }, |
| | 122936 | }, .{ |
| | 122937 | .required_features = .{ .avx2, null, null, null }, |
| | 122938 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }, .any }, |
| | 122939 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 122940 | .patterns = &.{ |
| | 122941 | .{ .src = .{ .mem, .none, .none } }, |
| | 122942 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122943 | }, |
| | 122944 | .extra_temps = .{ |
| | 122945 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122946 | .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122947 | .unused, |
| | 122948 | .unused, |
| | 122949 | .unused, |
| | 122950 | .unused, |
| | 122951 | .unused, |
| | 122952 | .unused, |
| | 122953 | .unused, |
| | 122954 | .unused, |
| | 122955 | .unused, |
| | 122956 | }, |
| | 122957 | .dst_temps = .{ .mem, .unused }, |
| | 122958 | .each = .{ .once = &.{ |
| | 122959 | .{ ._, ._, .mov, .tmp0d, .sia(-32, .dst0, .add_size), ._, ._ }, |
| | 122960 | .{ ._, .v_ss, .broadcast, .tmp1y, .src0d, ._, ._ }, |
| | 122961 | .{ .@"0:", .v_ps, .mova, .memi(.dst0y, .tmp0), .tmp1y, ._, ._ }, |
| | 122962 | .{ ._, ._, .sub, .tmp0d, .si(32), ._, ._ }, |
| | 122963 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122964 | } }, |
| | 122965 | }, .{ |
| | 122966 | .required_features = .{ .avx, null, null, null }, |
| | 122967 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122968 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, |
| | 122969 | .patterns = &.{ |
| | 122970 | .{ .src = .{ .mem, .none, .none } }, |
| | 122971 | }, |
| | 122972 | .extra_temps = .{ |
| | 122973 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 122974 | .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 122975 | .unused, |
| | 122976 | .unused, |
| | 122977 | .unused, |
| | 122978 | .unused, |
| | 122979 | .unused, |
| | 122980 | .unused, |
| | 122981 | .unused, |
| | 122982 | .unused, |
| | 122983 | .unused, |
| | 122984 | }, |
| | 122985 | .dst_temps = .{ .mem, .unused }, |
| | 122986 | .each = .{ .once = &.{ |
| | 122987 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 122988 | .{ ._, .v_ss, .broadcast, .tmp1x, .src0d, ._, ._ }, |
| | 122989 | .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, |
| | 122990 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 122991 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 122992 | } }, |
| | 122993 | }, .{ |
| | 122994 | .required_features = .{ .avx, null, null, null }, |
| | 122995 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 122996 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 122997 | .patterns = &.{ |
| | 122998 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 122999 | }, |
| | 123000 | .extra_temps = .{ |
| | 123001 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123002 | .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 123003 | .unused, |
| | 123004 | .unused, |
| | 123005 | .unused, |
| | 123006 | .unused, |
| | 123007 | .unused, |
| | 123008 | .unused, |
| | 123009 | .unused, |
| | 123010 | .unused, |
| | 123011 | .unused, |
| | 123012 | }, |
| | 123013 | .dst_temps = .{ .mem, .unused }, |
| | 123014 | .each = .{ .once = &.{ |
| | 123015 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 123016 | .{ ._, .vp_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 123017 | .{ .@"0:", .v_dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, |
| | 123018 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 123019 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123020 | } }, |
| | 123021 | }, .{ |
| | 123022 | .required_features = .{ .avx, null, null, null }, |
| | 123023 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 123024 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 123025 | .patterns = &.{ |
| | 123026 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123027 | }, |
| | 123028 | .extra_temps = .{ |
| | 123029 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123030 | .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 123031 | .unused, |
| | 123032 | .unused, |
| | 123033 | .unused, |
| | 123034 | .unused, |
| | 123035 | .unused, |
| | 123036 | .unused, |
| | 123037 | .unused, |
| | 123038 | .unused, |
| | 123039 | .unused, |
| | 123040 | }, |
| | 123041 | .dst_temps = .{ .mem, .unused }, |
| | 123042 | .each = .{ .once = &.{ |
| | 123043 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 123044 | .{ ._, .v_ps, .shuf, .tmp1x, .tmp1x, .src0x, .ui(0b00_00_00_00) }, |
| | 123045 | .{ .@"0:", .v_ps, .mova, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, |
| | 123046 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 123047 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123048 | } }, |
| | 123049 | }, .{ |
| | 123050 | .required_features = .{ .sse2, null, null, null }, |
| | 123051 | .dst_constraints = .{ .{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } }, .any }, |
| | 123052 | .src_constraints = .{ .{ .int = .dword }, .any, .any }, |
| | 123053 | .patterns = &.{ |
| | 123054 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123055 | }, |
| | 123056 | .extra_temps = .{ |
| | 123057 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123058 | .{ .type = .vector_4_u32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| | 123059 | .unused, |
| | 123060 | .unused, |
| | 123061 | .unused, |
| | 123062 | .unused, |
| | 123063 | .unused, |
| | 123064 | .unused, |
| | 123065 | .unused, |
| | 123066 | .unused, |
| | 123067 | .unused, |
| | 123068 | }, |
| | 123069 | .dst_temps = .{ .mem, .unused }, |
| | 123070 | .each = .{ .once = &.{ |
| | 123071 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 123072 | .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 123073 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, |
| | 123074 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 123075 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123076 | } }, |
| | 123077 | }, .{ |
| | 123078 | .required_features = .{ .sse, null, null, null }, |
| | 123079 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 123080 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 123081 | .patterns = &.{ |
| | 123082 | .{ .src = .{ .mut_sse, .none, .none } }, |
| | 123083 | }, |
| | 123084 | .extra_temps = .{ |
| | 123085 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123086 | .unused, |
| | 123087 | .unused, |
| | 123088 | .unused, |
| | 123089 | .unused, |
| | 123090 | .unused, |
| | 123091 | .unused, |
| | 123092 | .unused, |
| | 123093 | .unused, |
| | 123094 | .unused, |
| | 123095 | .unused, |
| | 123096 | }, |
| | 123097 | .dst_temps = .{ .mem, .unused }, |
| | 123098 | .each = .{ .once = &.{ |
| | 123099 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 123100 | .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 123101 | .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, |
| | 123102 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 123103 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123104 | } }, |
| | 123105 | }, .{ |
| | 123106 | .required_features = .{ .sse2, null, null, null }, |
| | 123107 | .dst_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any }, |
| | 123108 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| | 123109 | .patterns = &.{ |
| | 123110 | .{ .src = .{ .sse, .none, .none } }, |
| | 123111 | }, |
| | 123112 | .extra_temps = .{ |
| | 123113 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123114 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 123115 | .unused, |
| | 123116 | .unused, |
| | 123117 | .unused, |
| | 123118 | .unused, |
| | 123119 | .unused, |
| | 123120 | .unused, |
| | 123121 | .unused, |
| | 123122 | .unused, |
| | 123123 | .unused, |
| | 123124 | }, |
| | 123125 | .dst_temps = .{ .mem, .unused }, |
| | 123126 | .each = .{ .once = &.{ |
| | 123127 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 123128 | .{ ._, .p_d, .shuf, .tmp1x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 123129 | .{ .@"0:", ._dqa, .mov, .memi(.dst0x, .tmp0), .tmp1x, ._, ._ }, |
| | 123130 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 123131 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123132 | } }, |
| | 123133 | }, .{ |
| | 123134 | .required_features = .{ .sse, null, null, null }, |
| | 123135 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .xword, .is = .dword } }, .any }, |
| | 123136 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, |
| | 123137 | .patterns = &.{ |
| | 123138 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 123139 | }, |
| | 123140 | .extra_temps = .{ |
| | 123141 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123142 | .unused, |
| | 123143 | .unused, |
| | 123144 | .unused, |
| | 123145 | .unused, |
| | 123146 | .unused, |
| | 123147 | .unused, |
| | 123148 | .unused, |
| | 123149 | .unused, |
| | 123150 | .unused, |
| | 123151 | .unused, |
| | 123152 | }, |
| | 123153 | .dst_temps = .{ .mem, .unused }, |
| | 123154 | .each = .{ .once = &.{ |
| | 123155 | .{ ._, ._, .mov, .tmp0d, .sia(-16, .dst0, .add_size), ._, ._ }, |
| | 123156 | .{ ._, ._ps, .shuf, .src0x, .src0x, .ui(0b00_00_00_00), ._ }, |
| | 123157 | .{ .@"0:", ._ps, .mova, .memi(.dst0x, .tmp0), .src0x, ._, ._ }, |
| | 123158 | .{ ._, ._, .sub, .tmp0d, .si(16), ._, ._ }, |
| | 123159 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123160 | } }, |
| | 123161 | }, .{ |
| | 123162 | .dst_constraints = .{ .{ .multiple_scalar = .{ .of = .dword, .is = .dword } }, .any }, |
| | 123163 | .src_constraints = .{ .{ .int_or_float = .dword }, .any, .any }, |
| | 123164 | .patterns = &.{ |
| | 123165 | .{ .src = .{ .to_gpr, .none, .none } }, |
| | 123166 | }, |
| | 123167 | .extra_temps = .{ |
| | 123168 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 123169 | .unused, |
| | 123170 | .unused, |
| | 123171 | .unused, |
| | 123172 | .unused, |
| | 123173 | .unused, |
| | 123174 | .unused, |
| | 123175 | .unused, |
| | 123176 | .unused, |
| | 123177 | .unused, |
| | 123178 | .unused, |
| | 123179 | }, |
| | 123180 | .dst_temps = .{ .mem, .unused }, |
| | 123181 | .each = .{ .once = &.{ |
| | 123182 | .{ ._, ._, .mov, .tmp0d, .sia(-4, .dst0, .add_size), ._, ._ }, |
| | 123183 | .{ .@"0:", ._, .mov, .memi(.dst0d, .tmp0), .src0d, ._, ._ }, |
| | 123184 | .{ ._, ._, .sub, .tmp0d, .si(4), ._, ._ }, |
| | 123185 | .{ ._, ._nb, .j, .@"0b", ._, ._, ._ }, |
| | 123186 | } }, |
| | 123187 | }, .{ |
| | 123188 | .required_features = .{ .avx2, null, null, null }, |
| | 123189 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123190 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| | 123191 | .patterns = &.{ |
| | 123192 | .{ .src = .{ .mem, .none, .none } }, |
| | 123193 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123194 | }, |
| | 123195 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123196 | .each = .{ .once = &.{ |
| | 123197 | .{ ._, .vp_q, .broadcast, .dst0x, .src0q, ._, ._ }, |
| | 123198 | } }, |
| | 123199 | }, .{ |
| | 123200 | .required_features = .{ .avx2, null, null, null }, |
| | 123201 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123202 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| | 123203 | .patterns = &.{ |
| | 123204 | .{ .src = .{ .mem, .none, .none } }, |
| | 123205 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123206 | }, |
| | 123207 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123208 | .each = .{ .once = &.{ |
| | 123209 | .{ ._, .v_, .movddup, .dst0x, .src0q, ._, ._ }, |
| | 123210 | } }, |
| | 123211 | }, .{ |
| | 123212 | .required_features = .{ .avx, null, null, null }, |
| | 123213 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123214 | .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any }, |
| | 123215 | .patterns = &.{ |
| | 123216 | .{ .src = .{ .mem, .none, .none } }, |
| | 123217 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123218 | }, |
| | 123219 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123220 | .each = .{ .once = &.{ |
| | 123221 | .{ ._, .v_, .movddup, .dst0x, .src0q, ._, ._ }, |
| | 123222 | } }, |
| | 123223 | }, .{ |
| | 123224 | .required_features = .{ .sse3, null, null, null }, |
| | 123225 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123226 | .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any }, |
| | 123227 | .patterns = &.{ |
| | 123228 | .{ .src = .{ .mem, .none, .none } }, |
| | 123229 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123230 | }, |
| | 123231 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123232 | .each = .{ .once = &.{ |
| | 123233 | .{ ._, ._, .movddup, .dst0x, .src0q, ._, ._ }, |
| | 123234 | } }, |
| | 123235 | }, .{ |
| | 123236 | .required_features = .{ .sse2, null, null, null }, |
| | 123237 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123238 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| | 123239 | .patterns = &.{ |
| | 123240 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123241 | }, |
| | 123242 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123243 | .each = .{ .once = &.{ |
| | 123244 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ }, |
| | 123245 | } }, |
| | 123246 | }, .{ |
| | 123247 | .required_features = .{ .sse2, null, null, null }, |
| | 123248 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123249 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| | 123250 | .patterns = &.{ |
| | 123251 | .{ .src = .{ .mut_sse, .none, .none } }, |
| | 123252 | }, |
| | 123253 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 123254 | .each = .{ .once = &.{ |
| | 123255 | .{ ._, ._pd, .shuf, .dst0x, .src0x, .ui(0b0_0), ._ }, |
| | 123256 | } }, |
| | 123257 | }, .{ |
| | 123258 | .required_features = .{ .sse2, null, null, null }, |
| | 123259 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123260 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| | 123261 | .patterns = &.{ |
| | 123262 | .{ .src = .{ .sse, .none, .none } }, |
| | 123263 | }, |
| | 123264 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 123265 | .each = .{ .once = &.{ |
| | 123266 | .{ ._, .p_d, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ }, |
| | 123267 | } }, |
| | 123268 | }, .{ |
| | 123269 | .required_features = .{ .sse2, null, null, null }, |
| | 123270 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123271 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| | 123272 | .patterns = &.{ |
| | 123273 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 123274 | }, |
| | 123275 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 123276 | .each = .{ .once = &.{ |
| | 123277 | .{ ._, ._pd, .shuf, .dst0x, .src0x, .ui(0b0_0), ._ }, |
| | 123278 | } }, |
| | 123279 | }, .{ |
| | 123280 | .required_features = .{ .sse, null, null, null }, |
| | 123281 | .dst_constraints = .{ .{ .scalar = .{ .of = .xword, .is = .qword } }, .any }, |
| | 123282 | .src_constraints = .{ .{ .int_or_float = .qword }, .any, .any }, |
| | 123283 | .patterns = &.{ |
| | 123284 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| | 123285 | }, |
| | 123286 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 123287 | .each = .{ .once = &.{ |
| | 123288 | .{ ._, ._ps, .shuf, .dst0x, .src0x, .ui(0b01_00_01_00), ._ }, |
| | 123289 | } }, |
| | 123290 | }, .{ |
| | 123291 | .required_features = .{ .avx2, null, null, null }, |
| | 123292 | .dst_constraints = .{ .{ .scalar_int = .{ .of = .yword, .is = .qword } }, .any }, |
| | 123293 | .src_constraints = .{ .{ .int = .qword }, .any, .any }, |
| | 123294 | .patterns = &.{ |
| | 123295 | .{ .src = .{ .mem, .none, .none } }, |
| | 123296 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123297 | }, |
| | 123298 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123299 | .each = .{ .once = &.{ |
| | 123300 | .{ ._, .vp_q, .broadcast, .dst0y, .src0q, ._, ._ }, |
| | 123301 | } }, |
| | 123302 | }, .{ |
| | 123303 | .required_features = .{ .avx2, null, null, null }, |
| | 123304 | .dst_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any }, |
| | 123305 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| | 123306 | .patterns = &.{ |
| | 123307 | .{ .src = .{ .mem, .none, .none } }, |
| | 123308 | .{ .src = .{ .to_sse, .none, .none } }, |
| | 123309 | }, |
| | 123310 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 123311 | .each = .{ .once = &.{ |
| | 123312 | .{ ._, .v_sd, .broadcast, .dst0y, .src0q, ._, ._ }, |
| 117854 | } }, | 123313 | } }, |
| 117855 | }, .{ | 123314 | }, .{ |
| 117856 | .required_features = .{ .avx2, null, null, null }, | 123315 | .required_features = .{ .avx2, null, null, null }, |
| ... | @@ -119166,15 +124625,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -119166,15 +124625,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 119166 | }, | 124625 | }, |
| 119167 | .union_init => if (use_old) try cg.airUnionInit(inst) else { | 124626 | .union_init => if (use_old) try cg.airUnionInit(inst) else { |
| 119168 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 124627 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 119169 | const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; | 124628 | const union_init = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; |
| 119170 | const union_ty = ty_pl.ty.toType(); | 124629 | const union_ty = ty_pl.ty.toType(); |
| 119171 | var ops = try cg.tempsFromOperands(inst, .{extra.init}); | 124630 | var ops = try cg.tempsFromOperands(inst, .{union_init.init}); |
| 119172 | var res = try cg.tempAllocMem(union_ty); | 124631 | var res = try cg.tempAllocMem(union_ty); |
| 119173 | const union_layout = union_ty.unionGetLayout(zcu); | 124632 | const union_layout = union_ty.unionGetLayout(zcu); |
| 119174 | if (union_layout.tag_size > 0) { | 124633 | if (union_layout.tag_size > 0) { |
| 119175 | var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex( | 124634 | var tag_temp = try cg.tempFromValue(try pt.enumValueFieldIndex( |
| 119176 | union_ty.unionTagTypeSafety(zcu).?, | 124635 | union_ty.unionTagTypeSafety(zcu).?, |
| 119177 | extra.field_index, | 124636 | union_init.field_index, |
| 119178 | )); | 124637 | )); |
| 119179 | try res.write(&tag_temp, .{ | 124638 | try res.write(&tag_temp, .{ |
| 119180 | .disp = @intCast(union_layout.tagOffset()), | 124639 | .disp = @intCast(union_layout.tagOffset()), |
| ... | @@ -119184,7 +124643,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -119184,7 +124643,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 119184 | try res.write(&ops[0], .{ | 124643 | try res.write(&ops[0], .{ |
| 119185 | .disp = @intCast(union_layout.payloadOffset()), | 124644 | .disp = @intCast(union_layout.payloadOffset()), |
| 119186 | }, cg); | 124645 | }, cg); |
| 119187 | try res.finish(inst, &.{extra.init}, &ops, cg); | 124646 | try res.finish(inst, &.{union_init.init}, &ops, cg); |
| 119188 | }, | 124647 | }, |
| 119189 | .prefetch => { | 124648 | .prefetch => { |
| 119190 | const prefetch = air_datas[@intFromEnum(inst)].prefetch; | 124649 | const prefetch = air_datas[@intFromEnum(inst)].prefetch; |
| ... | @@ -120381,14 +125840,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -120381,14 +125840,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 120381 | }, | 125840 | }, |
| 120382 | .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else { | 125841 | .field_parent_ptr => if (use_old) try cg.airFieldParentPtr(inst) else { |
| 120383 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; | 125842 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| 120384 | const extra = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; | 125843 | const field_parent_ptr = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; |
| 120385 | var ops = try cg.tempsFromOperands(inst, .{extra.field_ptr}); | 125844 | var ops = try cg.tempsFromOperands(inst, .{field_parent_ptr.field_ptr}); |
| 120386 | try ops[0].toOffset(-cg.fieldOffset( | 125845 | try ops[0].toOffset(-cg.fieldOffset( |
| 120387 | ty_pl.ty.toType(), | 125846 | ty_pl.ty.toType(), |
| 120388 | cg.typeOf(extra.field_ptr), | 125847 | cg.typeOf(field_parent_ptr.field_ptr), |
| 120389 | extra.field_index, | 125848 | field_parent_ptr.field_index, |
| 120390 | ), cg); | 125849 | ), cg); |
| 120391 | try ops[0].finish(inst, &.{extra.field_ptr}, &ops, cg); | 125850 | try ops[0].finish(inst, &.{field_parent_ptr.field_ptr}, &ops, cg); |
| 120392 | }, | 125851 | }, |
| 120393 | .wasm_memory_size, .wasm_memory_grow => unreachable, | 125852 | .wasm_memory_size, .wasm_memory_grow => unreachable, |
| 120394 | .cmp_lt_errors_len => |air_tag| if (use_old) try cg.airCmpLtErrorsLen(inst) else { | 125853 | .cmp_lt_errors_len => |air_tag| if (use_old) try cg.airCmpLtErrorsLen(inst) else { |
| ... | @@ -120514,9 +125973,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -120514,9 +125973,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 120514 | try res.finish(inst, &.{}, &.{}, cg); | 125973 | try res.finish(inst, &.{}, &.{}, cg); |
| 120515 | }, | 125974 | }, |
| 120516 | .vector_store_elem => { | 125975 | .vector_store_elem => { |
| 120517 | const extra = air_datas[@intFromEnum(inst)].vector_store_elem; | 125976 | const vector_store_elem = air_datas[@intFromEnum(inst)].vector_store_elem; |
| 120518 | const bin_op = cg.air.extraData(Air.Bin, extra.payload).data; | 125977 | const bin_op = cg.air.extraData(Air.Bin, vector_store_elem.payload).data; |
| 120519 | var ops = try cg.tempsFromOperands(inst, .{ extra.vector_ptr, bin_op.lhs, bin_op.rhs }); | 125978 | var ops = try cg.tempsFromOperands(inst, .{ vector_store_elem.vector_ptr, bin_op.lhs, bin_op.rhs }); |
| 120520 | cg.select(&.{}, &.{}, &ops, comptime &.{ .{ | 125979 | cg.select(&.{}, &.{}, &ops, comptime &.{ .{ |
| 120521 | .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool }, | 125980 | .src_constraints = .{ .{ .ptr_bool_vec = .byte }, .any, .bool }, |
| 120522 | .patterns = &.{ | 125981 | .patterns = &.{ |
| ... | @@ -120878,7 +126337,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -120878,7 +126337,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 120878 | } }, | 126337 | } }, |
| 120879 | } }) catch |err| switch (err) { | 126338 | } }) catch |err| switch (err) { |
| 120880 | error.SelectFailed => { | 126339 | error.SelectFailed => { |
| 120881 | const elem_size = cg.typeOf(extra.vector_ptr).childType(zcu).childType(zcu).abiSize(zcu); | 126340 | const elem_size = cg.typeOf(bin_op.rhs).abiSize(zcu); |
| 120882 | while (try ops[0].toBase(false, cg) or | 126341 | while (try ops[0].toBase(false, cg) or |
| 120883 | try ops[1].toRegClass(true, .general_purpose, cg)) | 126342 | try ops[1].toRegClass(true, .general_purpose, cg)) |
| 120884 | {} | 126343 | {} |
| ... | @@ -127728,14 +133187,14 @@ fn genShiftBinOpMir( | ... | @@ -127728,14 +133187,14 @@ fn genShiftBinOpMir( |
| 127728 | info.double_tag, | 133187 | info.double_tag, |
| 127729 | lhs_regs[info.indices[1]], | 133188 | lhs_regs[info.indices[1]], |
| 127730 | lhs_regs[info.indices[0]], | 133189 | lhs_regs[info.indices[0]], |
| 127731 | registerAlias(shift_reg, 1), | 133190 | shift_reg.to8(), |
| 127732 | ); | 133191 | ); |
| 127733 | try self.asmRegisterRegister( | 133192 | try self.asmRegisterRegister( |
| 127734 | tag, | 133193 | tag, |
| 127735 | lhs_regs[info.indices[0]], | 133194 | lhs_regs[info.indices[0]], |
| 127736 | registerAlias(shift_reg, 1), | 133195 | shift_reg.to8(), |
| 127737 | ); | 133196 | ); |
| 127738 | try self.asmRegisterImmediate(.{ ._, .cmp }, registerAlias(shift_reg, 1), .u(64)); | 133197 | try self.asmRegisterImmediate(.{ ._, .cmp }, shift_reg.to8(), .u(64)); |
| 127739 | try self.asmCmovccRegisterRegister( | 133198 | try self.asmCmovccRegisterRegister( |
| 127740 | .ae, | 133199 | .ae, |
| 127741 | lhs_regs[info.indices[1]], | 133200 | lhs_regs[info.indices[1]], |
| ... | @@ -127888,12 +133347,12 @@ fn genShiftBinOpMir( | ... | @@ -127888,12 +133347,12 @@ fn genShiftBinOpMir( |
| 127888 | info.double_tag, | 133347 | info.double_tag, |
| 127889 | second_reg, | 133348 | second_reg, |
| 127890 | first_reg, | 133349 | first_reg, |
| 127891 | registerAlias(shift_reg, 1), | 133350 | shift_reg.to8(), |
| 127892 | ); | 133351 | ); |
| 127893 | try self.asmRegisterRegister(tag, first_reg, registerAlias(shift_reg, 1)); | 133352 | try self.asmRegisterRegister(tag, first_reg, shift_reg.to8()); |
| 127894 | try self.asmRegisterImmediate( | 133353 | try self.asmRegisterImmediate( |
| 127895 | .{ ._, .cmp }, | 133354 | .{ ._, .cmp }, |
| 127896 | registerAlias(shift_reg, 1), | 133355 | shift_reg.to8(), |
| 127897 | .u(64), | 133356 | .u(64), |
| 127898 | ); | 133357 | ); |
| 127899 | try self.asmCmovccRegisterRegister(.ae, second_reg, first_reg); | 133358 | try self.asmCmovccRegisterRegister(.ae, second_reg, first_reg); |
| ... | @@ -127937,7 +133396,7 @@ fn genShiftBinOpMir( | ... | @@ -127937,7 +133396,7 @@ fn genShiftBinOpMir( |
| 127937 | .register => |shift_reg| return self.asmRegisterRegister( | 133396 | .register => |shift_reg| return self.asmRegisterRegister( |
| 127938 | tag, | 133397 | tag, |
| 127939 | registerAlias(lhs_reg, abi_size), | 133398 | registerAlias(lhs_reg, abi_size), |
| 127940 | registerAlias(shift_reg, 1), | 133399 | shift_reg.to8(), |
| 127941 | ), | 133400 | ), |
| 127942 | else => {}, | 133401 | else => {}, |
| 127943 | }, | 133402 | }, |
| ... | @@ -127975,7 +133434,7 @@ fn genShiftBinOpMir( | ... | @@ -127975,7 +133434,7 @@ fn genShiftBinOpMir( |
| 127975 | .register => |shift_reg| return self.asmMemoryRegister( | 133434 | .register => |shift_reg| return self.asmMemoryRegister( |
| 127976 | tag, | 133435 | tag, |
| 127977 | lhs_mem, | 133436 | lhs_mem, |
| 127978 | registerAlias(shift_reg, 1), | 133437 | shift_reg.to8(), |
| 127979 | ), | 133438 | ), |
| 127980 | else => {}, | 133439 | else => {}, |
| 127981 | } | 133440 | } |
| ... | @@ -132477,7 +137936,7 @@ fn lowerSwitchBr( | ... | @@ -132477,7 +137936,7 @@ fn lowerSwitchBr( |
| 132477 | .base = .table, | 137936 | .base = .table, |
| 132478 | .mod = .{ .rm = .{ | 137937 | .mod = .{ .rm = .{ |
| 132479 | .size = .ptr, | 137938 | .size = .ptr, |
| 132480 | .index = registerAlias(condition_index_reg, ptr_size), | 137939 | .index = condition_index_reg.toSize(.ptr, cg.target), |
| 132481 | .scale = .fromFactor(@intCast(ptr_size)), | 137940 | .scale = .fromFactor(@intCast(ptr_size)), |
| 132482 | .disp = table_start * ptr_size, | 137941 | .disp = table_start * ptr_size, |
| 132483 | } }, | 137942 | } }, |
| ... | @@ -132832,7 +138291,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -132832,7 +138291,7 @@ fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 132832 | .base = .table, | 138291 | .base = .table, |
| 132833 | .mod = .{ .rm = .{ | 138292 | .mod = .{ .rm = .{ |
| 132834 | .size = .ptr, | 138293 | .size = .ptr, |
| 132835 | .index = registerAlias(condition_index_reg, ptr_size), | 138294 | .index = condition_index_reg.toSize(.ptr, self.target), |
| 132836 | .scale = .fromFactor(@intCast(ptr_size)), | 138295 | .scale = .fromFactor(@intCast(ptr_size)), |
| 132837 | .disp = @intCast(table.start * ptr_size), | 138296 | .disp = @intCast(table.start * ptr_size), |
| 132838 | } }, | 138297 | } }, |
| ... | @@ -133742,7 +139201,7 @@ const MoveStrategy = union(enum) { | ... | @@ -133742,7 +139201,7 @@ const MoveStrategy = union(enum) { |
| 133742 | .base = .{ .frame = tmp_frame_index }, | 139201 | .base = .{ .frame = tmp_frame_index }, |
| 133743 | .mod = .{ .rm = .{ .size = .word } }, | 139202 | .mod = .{ .rm = .{ .size = .word } }, |
| 133744 | }); | 139203 | }); |
| 133745 | try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.to16()); | 139204 | try cg.asmMemoryRegister(.{ ._, .mov }, dst_mem, tmp_reg.toSize(dst_mem.mod.rm.size, cg.target)); |
| 133746 | }, | 139205 | }, |
| 133747 | .load_store => |tag| try cg.asmMemoryRegister(tag, dst_mem, src_reg), | 139206 | .load_store => |tag| try cg.asmMemoryRegister(tag, dst_mem, src_reg), |
| 133748 | .load_store_x87 => if (cg.register_manager.isKnownRegFree(.st7)) { | 139207 | .load_store_x87 => if (cg.register_manager.isKnownRegFree(.st7)) { |
| ... | @@ -139513,6 +144972,17 @@ fn unalignedSize(cg: *CodeGen, ty: Type) u64 { | ... | @@ -139513,6 +144972,17 @@ fn unalignedSize(cg: *CodeGen, ty: Type) u64 { |
| 139513 | }; | 144972 | }; |
| 139514 | } | 144973 | } |
| 139515 | | 144974 | |
| | 144975 | fn nonBoolScalarBitSize(cg: *CodeGen, ty: Type) u32 { |
| | 144976 | const zcu = cg.pt.zcu; |
| | 144977 | return switch (zcu.intern_pool.indexToKey(ty.toIntern())) { |
| | 144978 | .vector_type => |vector_type| switch (vector_type.child) { |
| | 144979 | .bool_type => vector_type.len, |
| | 144980 | else => @intCast(Type.fromInterned(vector_type.child).bitSize(zcu)), |
| | 144981 | }, |
| | 144982 | else => @intCast(ty.bitSize(zcu)), |
| | 144983 | }; |
| | 144984 | } |
| | 144985 | |
| 139516 | fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int { | 144986 | fn intInfo(cg: *CodeGen, ty: Type) ?std.builtin.Type.Int { |
| 139517 | const zcu = cg.pt.zcu; | 144987 | const zcu = cg.pt.zcu; |
| 139518 | const ip = &zcu.intern_pool; | 144988 | const ip = &zcu.intern_pool; |
| ... | @@ -145229,8 +150699,12 @@ const Select = struct { | ... | @@ -145229,8 +150699,12 @@ const Select = struct { |
| 145229 | po2_any, | 150699 | po2_any, |
| 145230 | bool, | 150700 | bool, |
| 145231 | bool_vec: Memory.Size, | 150701 | bool_vec: Memory.Size, |
| 145232 | ptr_bool_vec: Memory.Size, | 150702 | exact_bool_vec: u16, |
| | 150703 | vec_len: u32, |
| 145233 | ptr_any_bool_vec, | 150704 | ptr_any_bool_vec, |
| | 150705 | ptr_bool_vec: Memory.Size, |
| | 150706 | remainder_bool_vec: OfIsSizes, |
| | 150707 | exact_remainder_bool_vec: struct { of: Memory.Size, is: u16 }, |
| 145234 | signed_int_vec: Memory.Size, | 150708 | signed_int_vec: Memory.Size, |
| 145235 | signed_int_or_full_vec: Memory.Size, | 150709 | signed_int_or_full_vec: Memory.Size, |
| 145236 | unsigned_int_vec: Memory.Size, | 150710 | unsigned_int_vec: Memory.Size, |
| ... | @@ -145243,6 +150717,7 @@ const Select = struct { | ... | @@ -145243,6 +150717,7 @@ const Select = struct { |
| 145243 | scalar_unsigned_int_is: Memory.Size, | 150717 | scalar_unsigned_int_is: Memory.Size, |
| 145244 | scalar: OfIsSizes, | 150718 | scalar: OfIsSizes, |
| 145245 | scalar_int: OfIsSizes, | 150719 | scalar_int: OfIsSizes, |
| | 150720 | exact_scalar_int: OfIsSizes, |
| 145246 | scalar_signed_int: OfIsSizes, | 150721 | scalar_signed_int: OfIsSizes, |
| 145247 | scalar_unsigned_int: OfIsSizes, | 150722 | scalar_unsigned_int: OfIsSizes, |
| 145248 | scalar_signed_or_exclusive_int: OfIsSizes, | 150723 | scalar_signed_or_exclusive_int: OfIsSizes, |
| ... | @@ -145251,6 +150726,7 @@ const Select = struct { | ... | @@ -145251,6 +150726,7 @@ const Select = struct { |
| 145251 | scalar_exact_unsigned_int: struct { of: Memory.Size, is: u16 }, | 150726 | scalar_exact_unsigned_int: struct { of: Memory.Size, is: u16 }, |
| 145252 | multiple_scalar: OfIsSizes, | 150727 | multiple_scalar: OfIsSizes, |
| 145253 | multiple_scalar_int: OfIsSizes, | 150728 | multiple_scalar_int: OfIsSizes, |
| | 150729 | unaligned_multiple_scalar_int: OfIsSizes, |
| 145254 | multiple_scalar_signed_int: OfIsSizes, | 150730 | multiple_scalar_signed_int: OfIsSizes, |
| 145255 | multiple_scalar_unsigned_int: OfIsSizes, | 150731 | multiple_scalar_unsigned_int: OfIsSizes, |
| 145256 | multiple_scalar_signed_or_exclusive_int: OfIsSizes, | 150732 | multiple_scalar_signed_or_exclusive_int: OfIsSizes, |
| ... | @@ -145309,6 +150785,9 @@ const Select = struct { | ... | @@ -145309,6 +150785,9 @@ const Select = struct { |
| 145309 | .bool => ty.toIntern() == .bool_type, | 150785 | .bool => ty.toIntern() == .bool_type, |
| 145310 | .bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and | 150786 | .bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| 145311 | size.bitSize(cg.target) >= ty.vectorLen(zcu), | 150787 | size.bitSize(cg.target) >= ty.vectorLen(zcu), |
| | 150788 | .exact_bool_vec => |size| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| | 150789 | size == ty.vectorLen(zcu), |
| | 150790 | .vec_len => |len| ty.isVector(zcu) and ty.vectorLen(zcu) == len, |
| 145312 | .ptr_any_bool_vec => switch (zcu.intern_pool.indexToKey(ty.childType(zcu).toIntern())) { | 150791 | .ptr_any_bool_vec => switch (zcu.intern_pool.indexToKey(ty.childType(zcu).toIntern())) { |
| 145313 | .vector_type => |vector_type| vector_type.child == .bool_type, | 150792 | .vector_type => |vector_type| vector_type.child == .bool_type, |
| 145314 | else => false, | 150793 | else => false, |
| ... | @@ -145317,6 +150796,10 @@ const Select = struct { | ... | @@ -145317,6 +150796,10 @@ const Select = struct { |
| 145317 | .vector_type => |vector_type| vector_type.child == .bool_type and size.bitSize(cg.target) >= vector_type.len, | 150796 | .vector_type => |vector_type| vector_type.child == .bool_type and size.bitSize(cg.target) >= vector_type.len, |
| 145318 | else => false, | 150797 | else => false, |
| 145319 | }, | 150798 | }, |
| | 150799 | .remainder_bool_vec => |of_is| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| | 150800 | of_is.is.bitSize(cg.target) >= (ty.vectorLen(zcu) - 1) % of_is.of.bitSize(cg.target) + 1, |
| | 150801 | .exact_remainder_bool_vec => |of_is| ty.isVector(zcu) and ty.scalarType(zcu).toIntern() == .bool_type and |
| | 150802 | of_is.is == (ty.vectorLen(zcu) - 1) % of_is.of.bitSize(cg.target) + 1, |
| 145320 | .signed_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and | 150803 | .signed_int_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and |
| 145321 | if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .signed else false, | 150804 | if (cg.intInfo(ty.childType(zcu))) |int_info| int_info.signedness == .signed else false, |
| 145322 | .signed_int_or_full_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and | 150805 | .signed_int_or_full_vec => |size| ty.isVector(zcu) and @divExact(size.bitSize(cg.target), 8) >= ty.abiSize(zcu) and |
| ... | @@ -145356,6 +150839,8 @@ const Select = struct { | ... | @@ -145356,6 +150839,8 @@ const Select = struct { |
| 145356 | false, | 150839 | false, |
| 145357 | .scalar_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and | 150840 | .scalar_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and |
| 145358 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false, | 150841 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false, |
| | 150842 | .exact_scalar_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) == cg.unalignedSize(ty) and |
| | 150843 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false, |
| 145359 | .scalar_signed_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and | 150844 | .scalar_signed_int => |of_is| @divExact(of_is.of.bitSize(cg.target), 8) >= cg.unalignedSize(ty) and |
| 145360 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and | 150845 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and |
| 145361 | of_is.is.bitSize(cg.target) >= int_info.bits else false, | 150846 | of_is.is.bitSize(cg.target) >= int_info.bits else false, |
| ... | @@ -145384,6 +150869,8 @@ const Select = struct { | ... | @@ -145384,6 +150869,8 @@ const Select = struct { |
| 145384 | false, | 150869 | false, |
| 145385 | .multiple_scalar_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and | 150870 | .multiple_scalar_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and |
| 145386 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false, | 150871 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false, |
| | 150872 | .unaligned_multiple_scalar_int => |of_is| cg.unalignedSize(ty) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and |
| | 150873 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| of_is.is.bitSize(cg.target) >= int_info.bits else false, |
| 145387 | .multiple_scalar_signed_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and | 150874 | .multiple_scalar_signed_int => |of_is| ty.abiSize(zcu) % @divExact(of_is.of.bitSize(cg.target), 8) == 0 and |
| 145388 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and | 150875 | if (cg.intInfo(ty.scalarType(zcu))) |int_info| int_info.signedness == .signed and |
| 145389 | of_is.is.bitSize(cg.target) >= int_info.bits else false, | 150876 | of_is.is.bitSize(cg.target) >= int_info.bits else false, |
| ... | @@ -145554,6 +151041,25 @@ const Select = struct { | ... | @@ -145554,6 +151041,25 @@ const Select = struct { |
| 145554 | to_ymm, | 151041 | to_ymm, |
| 145555 | mut_ymm, | 151042 | mut_ymm, |
| 145556 | to_mut_ymm, | 151043 | to_mut_ymm, |
| | 151044 | reg_mask: RegMaskSpec, |
| | 151045 | all_reg_mask: RegMaskSpec, |
| | 151046 | |
| | 151047 | const RegMaskSpec = struct { |
| | 151048 | size: Memory.Size, |
| | 151049 | is: enum { |
| | 151050 | any, |
| | 151051 | uninverted, |
| | 151052 | inverted, |
| | 151053 | |
| | 151054 | fn matches(is: @This(), inverted: bool) bool { |
| | 151055 | return switch (is) { |
| | 151056 | .any => true, |
| | 151057 | .uninverted => !inverted, |
| | 151058 | .inverted => inverted, |
| | 151059 | }; |
| | 151060 | } |
| | 151061 | } = .any, |
| | 151062 | }; |
| 145557 | | 151063 | |
| 145558 | fn matches(src: Src, temp: Temp, cg: *CodeGen) bool { | 151064 | fn matches(src: Src, temp: Temp, cg: *CodeGen) bool { |
| 145559 | return switch (src) { | 151065 | return switch (src) { |
| ... | @@ -145668,12 +151174,24 @@ const Select = struct { | ... | @@ -145668,12 +151174,24 @@ const Select = struct { |
| 145668 | else => false, | 151174 | else => false, |
| 145669 | }, | 151175 | }, |
| 145670 | .to_ymm, .to_mut_ymm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 32, | 151176 | .to_ymm, .to_mut_ymm => temp.typeOf(cg).abiSize(cg.pt.zcu) == 32, |
| | 151177 | .reg_mask => |mask_spec| switch (temp.tracking(cg).short) { |
| | 151178 | .register_mask => |reg_mask| mask_spec.size.bitSize(cg.target) >= |
| | 151179 | reg_mask.info.scalar.bitSize(cg.target) * temp.typeOf(cg).vectorLen(cg.pt.zcu) and |
| | 151180 | mask_spec.is.matches(reg_mask.info.inverted), |
| | 151181 | else => false, |
| | 151182 | }, |
| | 151183 | .all_reg_mask => |mask_spec| switch (temp.tracking(cg).short) { |
| | 151184 | .register_mask => |reg_mask| mask_spec.size.bitSize(cg.target) == |
| | 151185 | reg_mask.info.scalar.bitSize(cg.target) * temp.typeOf(cg).vectorLen(cg.pt.zcu) and |
| | 151186 | reg_mask.info.kind == .all and mask_spec.is.matches(reg_mask.info.inverted), |
| | 151187 | else => false, |
| | 151188 | }, |
| 145671 | }; | 151189 | }; |
| 145672 | } | 151190 | } |
| 145673 | | 151191 | |
| 145674 | fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool { | 151192 | fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool { |
| 145675 | return switch (src) { | 151193 | return switch (src) { |
| 145676 | .none, .any, .imm, .imm8, .imm16, .imm32, .simm32 => false, | 151194 | .none, .any, .imm, .imm8, .imm16, .imm32, .simm32, .reg_mask, .all_reg_mask => false, |
| 145677 | .mem, .to_mem => try temp.toBase(false, cg), | 151195 | .mem, .to_mem => try temp.toBase(false, cg), |
| 145678 | .mut_mem, .to_mut_mem => try temp.toBase(true, cg), | 151196 | .mut_mem, .to_mut_mem => try temp.toBase(true, cg), |
| 145679 | .to_reg => |reg| try temp.toReg(reg, cg), | 151197 | .to_reg => |reg| try temp.toReg(reg, cg), |
| ... | @@ -145707,6 +151225,7 @@ const Select = struct { | ... | @@ -145707,6 +151225,7 @@ const Select = struct { |
| 145707 | none, | 151225 | none, |
| 145708 | undef, | 151226 | undef, |
| 145709 | cc: Condition, | 151227 | cc: Condition, |
| | 151228 | ptest_cc: struct { ref: Select.Operand.Ref, not: bool = false, all: u1 }, |
| 145710 | imm: i32, | 151229 | imm: i32, |
| 145711 | ref: Select.Operand.Ref, | 151230 | ref: Select.Operand.Ref, |
| 145712 | reg: Register, | 151231 | reg: Register, |
| ... | @@ -145736,6 +151255,8 @@ const Select = struct { | ... | @@ -145736,6 +151255,8 @@ const Select = struct { |
| 145736 | pshufb_splat_mem: struct { of: Memory.Size = .none, size: Memory.Size }, | 151255 | pshufb_splat_mem: struct { of: Memory.Size = .none, size: Memory.Size }, |
| 145737 | pshufb_trunc_mem: struct { of: Memory.Size = .none, from: Memory.Size, to: Memory.Size }, | 151256 | pshufb_trunc_mem: struct { of: Memory.Size = .none, from: Memory.Size, to: Memory.Size }, |
| 145738 | pand_trunc_mem: struct { from: Memory.Size, to: Memory.Size }, | 151257 | pand_trunc_mem: struct { from: Memory.Size, to: Memory.Size }, |
| | 151258 | pand_mask_mem: struct { ref: Select.Operand.Ref, invert: bool = false }, |
| | 151259 | ptest_mask_mem: Select.Operand.Ref, |
| 145739 | pshufb_bswap_mem: struct { repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 }, | 151260 | pshufb_bswap_mem: struct { repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 }, |
| 145740 | forward_bits_mem, | 151261 | forward_bits_mem, |
| 145741 | reverse_bits_mem, | 151262 | reverse_bits_mem, |
| ... | @@ -145800,6 +151321,14 @@ const Select = struct { | ... | @@ -145800,6 +151321,14 @@ const Select = struct { |
| 145800 | .undef => .{ try cg.tempInit(spec.type, .undef), true }, | 151321 | .undef => .{ try cg.tempInit(spec.type, .undef), true }, |
| 145801 | .imm => |imm| .{ try cg.tempInit(spec.type, .{ .immediate = @bitCast(@as(i64, imm)) }), true }, | 151322 | .imm => |imm| .{ try cg.tempInit(spec.type, .{ .immediate = @bitCast(@as(i64, imm)) }), true }, |
| 145802 | .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, | 151323 | .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, |
| | 151324 | .ptest_cc => |cc_spec| { |
| | 151325 | const ccs: [2]Condition = .{ .z, .c }; |
| | 151326 | const cc = ccs[cc_spec.all ^ @intFromBool(cc_spec.ref.valueOf(s).register_mask.info.inverted)]; |
| | 151327 | return .{ try cg.tempInit(spec.type, .{ .eflags = switch (cc_spec.not) { |
| | 151328 | false => cc, |
| | 151329 | true => cc.negate(), |
| | 151330 | } }), true }; |
| | 151331 | }, |
| 145803 | .ref => |ref| .{ ref.tempOf(s), false }, | 151332 | .ref => |ref| .{ ref.tempOf(s), false }, |
| 145804 | .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, | 151333 | .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, |
| 145805 | .reg_pair => |regs| .{ try cg.tempInit(spec.type, .{ .register_pair = regs }), true }, | 151334 | .reg_pair => |regs| .{ try cg.tempInit(spec.type, .{ .register_pair = regs }), true }, |
| ... | @@ -145988,16 +151517,15 @@ const Select = struct { | ... | @@ -145988,16 +151517,15 @@ const Select = struct { |
| 145988 | } }))), true }, | 151517 | } }))), true }, |
| 145989 | .pshufb_splat_mem => |splat_spec| { | 151518 | .pshufb_splat_mem => |splat_spec| { |
| 145990 | const zcu = pt.zcu; | 151519 | const zcu = pt.zcu; |
| 145991 | assert(spec.type.isVector(zcu)); | 151520 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| 145992 | assert(spec.type.childType(zcu).toIntern() == .u8_type); | | |
| 145993 | var elem_buf: [32]u8 = @splat(1 << 7); | 151521 | var elem_buf: [32]u8 = @splat(1 << 7); |
| 145994 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; | 151522 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; |
| 145995 | const of_bytes: u32 = @intCast(switch (splat_spec.of) { | 151523 | const of_bytes: u6 = @intCast(switch (splat_spec.of) { |
| 145996 | .none => elems.len, | 151524 | .none => elems.len, |
| 145997 | else => |of| @divExact(of.bitSize(cg.target), 8), | 151525 | else => |of| @divExact(of.bitSize(cg.target), 8), |
| 145998 | }); | 151526 | }); |
| 145999 | const size_bytes: u32 = @intCast(@divExact(splat_spec.size.bitSize(cg.target), 8)); | 151527 | const size_bytes: u6 = @intCast(@divExact(splat_spec.size.bitSize(cg.target), 8)); |
| 146000 | var index: u32 = 0; | 151528 | var index: u6 = 0; |
| 146001 | while (index < of_bytes) : (index += size_bytes) for (0..size_bytes) |byte_off| { | 151529 | while (index < of_bytes) : (index += size_bytes) for (0..size_bytes) |byte_off| { |
| 146002 | elems[index + byte_off] = @as(u4, @truncate(byte_off)); | 151530 | elems[index + byte_off] = @as(u4, @truncate(byte_off)); |
| 146003 | }; | 151531 | }; |
| ... | @@ -146008,18 +151536,17 @@ const Select = struct { | ... | @@ -146008,18 +151536,17 @@ const Select = struct { |
| 146008 | }, | 151536 | }, |
| 146009 | .pshufb_trunc_mem => |trunc_spec| { | 151537 | .pshufb_trunc_mem => |trunc_spec| { |
| 146010 | const zcu = pt.zcu; | 151538 | const zcu = pt.zcu; |
| 146011 | assert(spec.type.isVector(zcu)); | 151539 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| 146012 | assert(spec.type.childType(zcu).toIntern() == .u8_type); | | |
| 146013 | var elem_buf: [32]u8 = @splat(1 << 7); | 151540 | var elem_buf: [32]u8 = @splat(1 << 7); |
| 146014 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; | 151541 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; |
| 146015 | const of_bytes: u32 = @intCast(switch (trunc_spec.of) { | 151542 | const of_bytes: u6 = @intCast(switch (trunc_spec.of) { |
| 146016 | .none => elems.len, | 151543 | .none => elems.len, |
| 146017 | else => |of| @divExact(of.bitSize(cg.target), 8), | 151544 | else => |of| @divExact(of.bitSize(cg.target), 8), |
| 146018 | }); | 151545 | }); |
| 146019 | const from_bytes: u32 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8)); | 151546 | const from_bytes: u5 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8)); |
| 146020 | const to_bytes: u32 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8)); | 151547 | const to_bytes: u5 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8)); |
| 146021 | var from_index: u32 = 0; | 151548 | var from_index: u6 = 0; |
| 146022 | var to_index: u32 = 0; | 151549 | var to_index: u6 = 0; |
| 146023 | while (from_index < of_bytes) : ({ | 151550 | while (from_index < of_bytes) : ({ |
| 146024 | from_index += from_bytes; | 151551 | from_index += from_bytes; |
| 146025 | switch (from_index % 16) { | 151552 | switch (from_index % 16) { |
| ... | @@ -146036,27 +151563,69 @@ const Select = struct { | ... | @@ -146036,27 +151563,69 @@ const Select = struct { |
| 146036 | }, | 151563 | }, |
| 146037 | .pand_trunc_mem => |trunc_spec| { | 151564 | .pand_trunc_mem => |trunc_spec| { |
| 146038 | const zcu = pt.zcu; | 151565 | const zcu = pt.zcu; |
| 146039 | assert(spec.type.isVector(zcu)); | 151566 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| 146040 | assert(spec.type.childType(zcu).toIntern() == .u8_type); | | |
| 146041 | var elem_buf: [32]u8 = @splat(0); | 151567 | var elem_buf: [32]u8 = @splat(0); |
| 146042 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; | 151568 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; |
| 146043 | const from_bytes: u32 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8)); | 151569 | const from_bytes: u6 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8)); |
| 146044 | const to_bytes: u32 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8)); | 151570 | const to_bytes: u6 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8)); |
| 146045 | var index: u32 = 0; | 151571 | var index: u6 = 0; |
| 146046 | while (index < elems.len) : (index += from_bytes) @memset(elems[index..][0..to_bytes], std.math.maxInt(u8)); | 151572 | while (index < elems.len) : (index += from_bytes) @memset(elems[index..][0..to_bytes], std.math.maxInt(u8)); |
| 146047 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ | 151573 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| 146048 | .ty = spec.type.toIntern(), | 151574 | .ty = spec.type.toIntern(), |
| 146049 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, | 151575 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| 146050 | } }))), true }; | 151576 | } }))), true }; |
| 146051 | }, | 151577 | }, |
| | 151578 | .pand_mask_mem => |mask_spec| { |
| | 151579 | const zcu = pt.zcu; |
| | 151580 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| | 151581 | const ty = mask_spec.ref.typeOf(s); |
| | 151582 | assert(ty.isVector(zcu)); |
| | 151583 | var elem_buf: [64]u8 = undefined; |
| | 151584 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; |
| | 151585 | const mask_len: usize = @intCast(cg.unalignedSize(ty) % elems.len); |
| | 151586 | const invert_mask: u8 = switch (mask_spec.invert) { |
| | 151587 | false => std.math.minInt(u8), |
| | 151588 | true => std.math.maxInt(u8), |
| | 151589 | }; |
| | 151590 | @memset(elems[0..mask_len], ~invert_mask); |
| | 151591 | @memset(elems[mask_len..], invert_mask); |
| | 151592 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| | 151593 | .ty = spec.type.toIntern(), |
| | 151594 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| | 151595 | } }))), true }; |
| | 151596 | }, |
| | 151597 | .ptest_mask_mem => |mask_ref| { |
| | 151598 | const zcu = pt.zcu; |
| | 151599 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| | 151600 | const ty = mask_ref.typeOf(s); |
| | 151601 | assert(ty.isVector(zcu) and ty.childType(zcu).toIntern() == .bool_type); |
| | 151602 | const mask_info = mask_ref.valueOf(s).register_mask.info; |
| | 151603 | var elem_buf: [64]u8 = @splat(0); |
| | 151604 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; |
| | 151605 | const elem_bytes: u6 = @intCast(@divExact(mask_info.scalar.bitSize(cg.target), 8)); |
| | 151606 | var index: u7 = 0; |
| | 151607 | for (0..@intCast(ty.vectorLen(zcu))) |_| { |
| | 151608 | switch (mask_info.kind) { |
| | 151609 | .sign => { |
| | 151610 | @memset(elems[index..][0 .. elem_bytes - 1], std.math.minInt(u8)); |
| | 151611 | elems[index + elem_bytes - 1] = @bitCast(@as(i8, std.math.minInt(i8))); |
| | 151612 | }, |
| | 151613 | .all => @memset(elems[index..][0..elem_bytes], std.math.maxInt(u8)), |
| | 151614 | } |
| | 151615 | index += elem_bytes; |
| | 151616 | } |
| | 151617 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| | 151618 | .ty = spec.type.toIntern(), |
| | 151619 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) }, |
| | 151620 | } }))), true }; |
| | 151621 | }, |
| 146052 | .pshufb_bswap_mem => |bswap_spec| { | 151622 | .pshufb_bswap_mem => |bswap_spec| { |
| 146053 | const zcu = pt.zcu; | 151623 | const zcu = pt.zcu; |
| 146054 | assert(spec.type.isVector(zcu)); | 151624 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| 146055 | assert(spec.type.childType(zcu).toIntern() == .u8_type); | | |
| 146056 | var elem_buf: [32]u8 = @splat(1 << 7); | 151625 | var elem_buf: [32]u8 = @splat(1 << 7); |
| 146057 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; | 151626 | const elems = elem_buf[0..spec.type.vectorLen(zcu)]; |
| 146058 | const len: usize = @intCast(@divExact(bswap_spec.size.bitSize(cg.target), 8)); | 151627 | const len: usize = @intCast(@divExact(bswap_spec.size.bitSize(cg.target), 8)); |
| 146059 | var to_index: u32 = 0; | 151628 | var to_index: u6 = 0; |
| 146060 | for (0..bswap_spec.repeat) |_| for (0..len) |from_index| { | 151629 | for (0..bswap_spec.repeat) |_| for (0..len) |from_index| { |
| 146061 | @memset(elems[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index)); | 151630 | @memset(elems[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index)); |
| 146062 | to_index += bswap_spec.smear; | 151631 | to_index += bswap_spec.smear; |
| ... | @@ -146068,8 +151637,7 @@ const Select = struct { | ... | @@ -146068,8 +151637,7 @@ const Select = struct { |
| 146068 | }, | 151637 | }, |
| 146069 | .forward_bits_mem, .reverse_bits_mem => { | 151638 | .forward_bits_mem, .reverse_bits_mem => { |
| 146070 | const zcu = pt.zcu; | 151639 | const zcu = pt.zcu; |
| 146071 | assert(spec.type.isVector(zcu)); | 151640 | assert(spec.type.isVector(zcu) and spec.type.childType(zcu).toIntern() == .u8_type); |
| 146072 | assert(spec.type.childType(zcu).toIntern() == .u8_type); | | |
| 146073 | var bytes: [32]u8 = undefined; | 151641 | var bytes: [32]u8 = undefined; |
| 146074 | const elems = bytes[0..spec.type.vectorLen(zcu)]; | 151642 | const elems = bytes[0..spec.type.vectorLen(zcu)]; |
| 146075 | for (elems, 0..) |*elem, index| elem.* = switch (spec.kind) { | 151643 | for (elems, 0..) |*elem, index| elem.* = switch (spec.kind) { |
| ... | @@ -146170,6 +151738,7 @@ const Select = struct { | ... | @@ -146170,6 +151738,7 @@ const Select = struct { |
| 146170 | unaligned_size, | 151738 | unaligned_size, |
| 146171 | unaligned_size_add_elem_size, | 151739 | unaligned_size_add_elem_size, |
| 146172 | unaligned_size_sub_elem_size, | 151740 | unaligned_size_sub_elem_size, |
| | 151741 | unaligned_size_sub_2_elem_size, |
| 146173 | bit_size, | 151742 | bit_size, |
| 146174 | src0_bit_size, | 151743 | src0_bit_size, |
| 146175 | @"8_size_sub_bit_size", | 151744 | @"8_size_sub_bit_size", |
| ... | @@ -146213,9 +151782,15 @@ const Select = struct { | ... | @@ -146213,9 +151782,15 @@ const Select = struct { |
| 146213 | const sub_unaligned_size: Adjust = .{ .sign = .neg, .lhs = .unaligned_size, .op = .mul, .rhs = .@"1" }; | 151782 | const sub_unaligned_size: Adjust = .{ .sign = .neg, .lhs = .unaligned_size, .op = .mul, .rhs = .@"1" }; |
| 146214 | const add_unaligned_size_add_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_add_elem_size, .op = .mul, .rhs = .@"1" }; | 151783 | const add_unaligned_size_add_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_add_elem_size, .op = .mul, .rhs = .@"1" }; |
| 146215 | const add_unaligned_size_sub_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_sub_elem_size, .op = .mul, .rhs = .@"1" }; | 151784 | const add_unaligned_size_sub_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_sub_elem_size, .op = .mul, .rhs = .@"1" }; |
| | 151785 | const add_unaligned_size_sub_2_elem_size: Adjust = .{ .sign = .pos, .lhs = .unaligned_size_sub_2_elem_size, .op = .mul, .rhs = .@"1" }; |
| 146216 | const add_2_bit_size: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .mul, .rhs = .@"2" }; | 151786 | const add_2_bit_size: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .mul, .rhs = .@"2" }; |
| 146217 | const add_bit_size: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .mul, .rhs = .@"1" }; | 151787 | const add_bit_size: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .mul, .rhs = .@"1" }; |
| | 151788 | const add_bit_size_rem_8: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"1" }; |
| 146218 | const add_bit_size_rem_64: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"8" }; | 151789 | const add_bit_size_rem_64: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"8" }; |
| | 151790 | const add_bit_size_div_8: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div, .rhs = .@"8" }; |
| | 151791 | const add_bit_size_div_8_down_1: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div_8_down, .rhs = .@"1" }; |
| | 151792 | const add_bit_size_div_8_down_2: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div_8_down, .rhs = .@"2" }; |
| | 151793 | const add_bit_size_div_8_down_8: Adjust = .{ .sign = .pos, .lhs = .bit_size, .op = .div_8_down, .rhs = .@"8" }; |
| 146219 | const sub_bit_size_rem_64: Adjust = .{ .sign = .neg, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"8" }; | 151794 | const sub_bit_size_rem_64: Adjust = .{ .sign = .neg, .lhs = .bit_size, .op = .rem_8_mul, .rhs = .@"8" }; |
| 146220 | const sub_bit_size: Adjust = .{ .sign = .neg, .lhs = .bit_size, .op = .mul, .rhs = .@"1" }; | 151795 | const sub_bit_size: Adjust = .{ .sign = .neg, .lhs = .bit_size, .op = .mul, .rhs = .@"1" }; |
| 146221 | const add_src0_bit_size: Adjust = .{ .sign = .pos, .lhs = .src0_bit_size, .op = .mul, .rhs = .@"1" }; | 151796 | const add_src0_bit_size: Adjust = .{ .sign = .pos, .lhs = .src0_bit_size, .op = .mul, .rhs = .@"1" }; |
| ... | @@ -147004,8 +152579,12 @@ const Select = struct { | ... | @@ -147004,8 +152579,12 @@ const Select = struct { |
| 147004 | const ty = op.flags.base.ref.typeOf(s); | 152579 | const ty = op.flags.base.ref.typeOf(s); |
| 147005 | break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)); | 152580 | break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)); |
| 147006 | }, | 152581 | }, |
| 147007 | .bit_size => @intCast(op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu)), | 152582 | .unaligned_size_sub_2_elem_size => { |
| 147008 | .src0_bit_size => @intCast(Select.Operand.Ref.src0.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu)), | 152583 | const ty = op.flags.base.ref.typeOf(s); |
| | 152584 | break :lhs @intCast(s.cg.unalignedSize(ty) - ty.elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * 2); |
| | 152585 | }, |
| | 152586 | .bit_size => @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s))), |
| | 152587 | .src0_bit_size => @intCast(s.cg.nonBoolScalarBitSize(Select.Operand.Ref.src0.typeOf(s))), |
| 147009 | .@"8_size_sub_bit_size" => { | 152588 | .@"8_size_sub_bit_size" => { |
| 147010 | const ty = op.flags.base.ref.typeOf(s); | 152589 | const ty = op.flags.base.ref.typeOf(s); |
| 147011 | break :lhs @intCast(8 * ty.abiSize(s.cg.pt.zcu) - ty.bitSize(s.cg.pt.zcu)); | 152590 | break :lhs @intCast(8 * ty.abiSize(s.cg.pt.zcu) - ty.bitSize(s.cg.pt.zcu)); |
| ... | @@ -147022,26 +152601,35 @@ const Select = struct { | ... | @@ -147022,26 +152601,35 @@ const Select = struct { |
| 147022 | Select.Operand.Ref.src1.valueOf(s).immediate), | 152601 | Select.Operand.Ref.src1.valueOf(s).immediate), |
| 147023 | .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate), | 152602 | .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate), |
| 147024 | .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) - | 152603 | .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) - |
| 147025 | @as(SignedImm, @intCast(op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu))), | 152604 | @as(SignedImm, @intCast(s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))), |
| 147026 | .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))), | 152605 | .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))), |
| 147027 | .smin => @as(SignedImm, std.math.minInt(SignedImm)) >> @truncate( | 152606 | inline .smin, .smax, .umax, .smin_shr_src1, .smax_shr_src1, .umax_shr_src1 => |adjust| switch (op.flags.base.size) { |
| 147028 | -%op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), | 152607 | else => unreachable, |
| 147029 | ), | 152608 | inline .none, .byte, .word, .dword, .qword => |size| { |
| 147030 | .smax => @as(SignedImm, std.math.maxInt(SignedImm)) >> @truncate( | 152609 | const Imm = switch (adjust) { |
| 147031 | -%op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), | 152610 | else => comptime unreachable, |
| 147032 | ), | 152611 | .smin, .smax, .smin_shr_src1, .smax_shr_src1 => SignedImm, |
| 147033 | .umax => @bitCast(@as(UnsignedImm, std.math.maxInt(UnsignedImm)) >> @truncate( | 152612 | .umax, .umax_shr_src1 => UnsignedImm, |
| 147034 | -%op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), | 152613 | }; |
| 147035 | )), | 152614 | const RefImm = switch (size) { |
| 147036 | .smax_shr_src1 => @as(SignedImm, std.math.maxInt(SignedImm)) >> @truncate( | 152615 | else => comptime unreachable, |
| 147037 | Select.Operand.Ref.src1.valueOf(s).immediate -% op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), | 152616 | .none => Imm, |
| 147038 | ), | 152617 | .byte, .word, .dword, .qword => @Type(comptime .{ .int = .{ |
| 147039 | .smin_shr_src1 => @as(SignedImm, std.math.minInt(SignedImm)) >> @truncate( | 152618 | .signedness = @typeInfo(Imm).int.signedness, |
| 147040 | Select.Operand.Ref.src1.valueOf(s).immediate -% op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), | 152619 | .bits = size.bitSize(undefined), |
| 147041 | ), | 152620 | } }), |
| 147042 | .umax_shr_src1 => @bitCast(@as(UnsignedImm, std.math.maxInt(UnsignedImm)) >> @truncate( | 152621 | }; |
| 147043 | Select.Operand.Ref.src1.valueOf(s).immediate -% op.flags.base.ref.typeOf(s).scalarType(s.cg.pt.zcu).bitSize(s.cg.pt.zcu), | 152622 | break :lhs @bitCast(@as(Imm, @intCast(@as(RefImm, switch (adjust) { |
| 147044 | )), | 152623 | else => comptime unreachable, |
| | 152624 | .smin, .smin_shr_src1 => std.math.minInt, |
| | 152625 | .smax, .umax, .smax_shr_src1, .umax_shr_src1 => std.math.maxInt, |
| | 152626 | }(RefImm)) >> @truncate(switch (adjust) { |
| | 152627 | else => comptime unreachable, |
| | 152628 | .smin, .smax, .umax => 0, |
| | 152629 | .smin_shr_src1, .smax_shr_src1, .umax_shr_src1 => Select.Operand.Ref.src1.valueOf(s).immediate, |
| | 152630 | } -% s.cg.nonBoolScalarBitSize(op.flags.base.ref.typeOf(s)))))); |
| | 152631 | }, |
| | 152632 | }, |
| 147045 | .repeat => switch (SignedImm) { | 152633 | .repeat => switch (SignedImm) { |
| 147046 | else => unreachable, | 152634 | else => unreachable, |
| 147047 | i64 => return @as(i64, op.imm) << 32 | @as(u32, @bitCast(op.imm)), | 152635 | i64 => return @as(i64, op.imm) << 32 | @as(u32, @bitCast(op.imm)), |
| ... | @@ -147084,6 +152672,7 @@ const Select = struct { | ... | @@ -147084,6 +152672,7 @@ const Select = struct { |
| 147084 | } }, | 152672 | } }, |
| 147085 | else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.flags.base.size }) }, | 152673 | else => |mcv| .{ .mem = try mcv.mem(s.cg, .{ .size = op.flags.base.size }) }, |
| 147086 | .register => |reg| .{ .reg = s.lowerReg(reg.toSize(op.flags.base.size, s.cg.target)) }, | 152674 | .register => |reg| .{ .reg = s.lowerReg(reg.toSize(op.flags.base.size, s.cg.target)) }, |
| | 152675 | .register_mask => |reg_mask| .{ .reg = s.lowerReg(reg_mask.reg.toSize(op.flags.base.size, s.cg.target)) }, |
| 147087 | .lea_symbol => |sym_off| .{ .imm = .rel(sym_off) }, | 152676 | .lea_symbol => |sym_off| .{ .imm = .rel(sym_off) }, |
| 147088 | }, | 152677 | }, |
| 147089 | .simm => .{ .imm = .s(op.adjustedImm(i32, s)) }, | 152678 | .simm => .{ .imm = .s(op.adjustedImm(i32, s)) }, |