| ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2408 | } | 2408 | } |
| 2409 | | 2409 | |
| 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2411 | @setEvalBranchQuota(15_900); | 2411 | @setEvalBranchQuota(16_900); |
| 2412 | const pt = cg.pt; | 2412 | const pt = cg.pt; |
| 2413 | const zcu = pt.zcu; | 2413 | const zcu = pt.zcu; |
| 2414 | const ip = &zcu.intern_pool; | 2414 | const ip = &zcu.intern_pool; |
| ... | @@ -2691,6 +2691,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2691,6 +2691,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2691 | .unused, | 2691 | .unused, |
| 2692 | }, | 2692 | }, |
| 2693 | .dst_temps = .{ .mem, .unused }, | 2693 | .dst_temps = .{ .mem, .unused }, |
| | 2694 | .clobbers = .{ .eflags = true }, |
| 2694 | .each = .{ .once = &.{ | 2695 | .each = .{ .once = &.{ |
| 2695 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2696 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2696 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 2697 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2723,6 +2724,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2723,6 +2724,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2723 | .unused, | 2724 | .unused, |
| 2724 | }, | 2725 | }, |
| 2725 | .dst_temps = .{ .mem, .unused }, | 2726 | .dst_temps = .{ .mem, .unused }, |
| | 2727 | .clobbers = .{ .eflags = true }, |
| 2726 | .each = .{ .once = &.{ | 2728 | .each = .{ .once = &.{ |
| 2727 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2729 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2728 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 2730 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2755,6 +2757,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2755,6 +2757,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2755 | .unused, | 2757 | .unused, |
| 2756 | }, | 2758 | }, |
| 2757 | .dst_temps = .{ .mem, .unused }, | 2759 | .dst_temps = .{ .mem, .unused }, |
| | 2760 | .clobbers = .{ .eflags = true }, |
| 2758 | .each = .{ .once = &.{ | 2761 | .each = .{ .once = &.{ |
| 2759 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2762 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2760 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 2763 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2787,6 +2790,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2787,6 +2790,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2787 | .unused, | 2790 | .unused, |
| 2788 | }, | 2791 | }, |
| 2789 | .dst_temps = .{ .mem, .unused }, | 2792 | .dst_temps = .{ .mem, .unused }, |
| | 2793 | .clobbers = .{ .eflags = true }, |
| 2790 | .each = .{ .once = &.{ | 2794 | .each = .{ .once = &.{ |
| 2791 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2795 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2792 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 2796 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2818,6 +2822,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2818,6 +2822,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2818 | .unused, | 2822 | .unused, |
| 2819 | }, | 2823 | }, |
| 2820 | .dst_temps = .{ .mem, .unused }, | 2824 | .dst_temps = .{ .mem, .unused }, |
| | 2825 | .clobbers = .{ .eflags = true }, |
| 2821 | .each = .{ .once = &.{ | 2826 | .each = .{ .once = &.{ |
| 2822 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2827 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2823 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 2828 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2898,6 +2903,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2898,6 +2903,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2898 | .unused, | 2903 | .unused, |
| 2899 | }, | 2904 | }, |
| 2900 | .dst_temps = .{ .mem, .unused }, | 2905 | .dst_temps = .{ .mem, .unused }, |
| | 2906 | .clobbers = .{ .eflags = true }, |
| 2901 | .each = .{ .once = &.{ | 2907 | .each = .{ .once = &.{ |
| 2902 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2908 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2903 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 2909 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2930,6 +2936,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2930,6 +2936,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2930 | .unused, | 2936 | .unused, |
| 2931 | }, | 2937 | }, |
| 2932 | .dst_temps = .{ .mem, .unused }, | 2938 | .dst_temps = .{ .mem, .unused }, |
| | 2939 | .clobbers = .{ .eflags = true }, |
| 2933 | .each = .{ .once = &.{ | 2940 | .each = .{ .once = &.{ |
| 2934 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2941 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2935 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 2942 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2962,6 +2969,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2962,6 +2969,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2962 | .unused, | 2969 | .unused, |
| 2963 | }, | 2970 | }, |
| 2964 | .dst_temps = .{ .mem, .unused }, | 2971 | .dst_temps = .{ .mem, .unused }, |
| | 2972 | .clobbers = .{ .eflags = true }, |
| 2965 | .each = .{ .once = &.{ | 2973 | .each = .{ .once = &.{ |
| 2966 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 2974 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2967 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 2975 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -2993,6 +3001,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2993,6 +3001,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2993 | .unused, | 3001 | .unused, |
| 2994 | }, | 3002 | }, |
| 2995 | .dst_temps = .{ .mem, .unused }, | 3003 | .dst_temps = .{ .mem, .unused }, |
| | 3004 | .clobbers = .{ .eflags = true }, |
| 2996 | .each = .{ .once = &.{ | 3005 | .each = .{ .once = &.{ |
| 2997 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3006 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 2998 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 3007 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3073,6 +3082,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3073,6 +3082,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3073 | .unused, | 3082 | .unused, |
| 3074 | }, | 3083 | }, |
| 3075 | .dst_temps = .{ .mem, .unused }, | 3084 | .dst_temps = .{ .mem, .unused }, |
| | 3085 | .clobbers = .{ .eflags = true }, |
| 3076 | .each = .{ .once = &.{ | 3086 | .each = .{ .once = &.{ |
| 3077 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3087 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3078 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 3088 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3105,6 +3115,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3105,6 +3115,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3105 | .unused, | 3115 | .unused, |
| 3106 | }, | 3116 | }, |
| 3107 | .dst_temps = .{ .mem, .unused }, | 3117 | .dst_temps = .{ .mem, .unused }, |
| | 3118 | .clobbers = .{ .eflags = true }, |
| 3108 | .each = .{ .once = &.{ | 3119 | .each = .{ .once = &.{ |
| 3109 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3120 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3110 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 3121 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3137,6 +3148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3137,6 +3148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3137 | .unused, | 3148 | .unused, |
| 3138 | }, | 3149 | }, |
| 3139 | .dst_temps = .{ .mem, .unused }, | 3150 | .dst_temps = .{ .mem, .unused }, |
| | 3151 | .clobbers = .{ .eflags = true }, |
| 3140 | .each = .{ .once = &.{ | 3152 | .each = .{ .once = &.{ |
| 3141 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3153 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3142 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 3154 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3168,6 +3180,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3168,6 +3180,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3168 | .unused, | 3180 | .unused, |
| 3169 | }, | 3181 | }, |
| 3170 | .dst_temps = .{ .mem, .unused }, | 3182 | .dst_temps = .{ .mem, .unused }, |
| | 3183 | .clobbers = .{ .eflags = true }, |
| 3171 | .each = .{ .once = &.{ | 3184 | .each = .{ .once = &.{ |
| 3172 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3185 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3173 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 3186 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3248,6 +3261,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3248,6 +3261,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3248 | .unused, | 3261 | .unused, |
| 3249 | }, | 3262 | }, |
| 3250 | .dst_temps = .{ .mem, .unused }, | 3263 | .dst_temps = .{ .mem, .unused }, |
| | 3264 | .clobbers = .{ .eflags = true }, |
| 3251 | .each = .{ .once = &.{ | 3265 | .each = .{ .once = &.{ |
| 3252 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3266 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3253 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 3267 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3280,6 +3294,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3280,6 +3294,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3280 | .unused, | 3294 | .unused, |
| 3281 | }, | 3295 | }, |
| 3282 | .dst_temps = .{ .mem, .unused }, | 3296 | .dst_temps = .{ .mem, .unused }, |
| | 3297 | .clobbers = .{ .eflags = true }, |
| 3283 | .each = .{ .once = &.{ | 3298 | .each = .{ .once = &.{ |
| 3284 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3299 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3285 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 3300 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3312,6 +3327,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3312,6 +3327,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3312 | .unused, | 3327 | .unused, |
| 3313 | }, | 3328 | }, |
| 3314 | .dst_temps = .{ .mem, .unused }, | 3329 | .dst_temps = .{ .mem, .unused }, |
| | 3330 | .clobbers = .{ .eflags = true }, |
| 3315 | .each = .{ .once = &.{ | 3331 | .each = .{ .once = &.{ |
| 3316 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3332 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3317 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 3333 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3344,6 +3360,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3344,6 +3360,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3344 | .unused, | 3360 | .unused, |
| 3345 | }, | 3361 | }, |
| 3346 | .dst_temps = .{ .mem, .unused }, | 3362 | .dst_temps = .{ .mem, .unused }, |
| | 3363 | .clobbers = .{ .eflags = true }, |
| 3347 | .each = .{ .once = &.{ | 3364 | .each = .{ .once = &.{ |
| 3348 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3365 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3349 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 3366 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -3376,6 +3393,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3376,6 +3393,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3376 | .unused, | 3393 | .unused, |
| 3377 | }, | 3394 | }, |
| 3378 | .dst_temps = .{ .mem, .unused }, | 3395 | .dst_temps = .{ .mem, .unused }, |
| | 3396 | .clobbers = .{ .eflags = true }, |
| 3379 | .each = .{ .once = &.{ | 3397 | .each = .{ .once = &.{ |
| 3380 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3398 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3381 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, | 3399 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| ... | @@ -3414,6 +3432,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -3414,6 +3432,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 3414 | .unused, | 3432 | .unused, |
| 3415 | }, | 3433 | }, |
| 3416 | .dst_temps = .{ .mem, .unused }, | 3434 | .dst_temps = .{ .mem, .unused }, |
| | 3435 | .clobbers = .{ .eflags = true }, |
| 3417 | .each = .{ .once = &.{ | 3436 | .each = .{ .once = &.{ |
| 3418 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 3437 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 3419 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, | 3438 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| ... | @@ -4085,6 +4104,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4085,6 +4104,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4085 | .unused, | 4104 | .unused, |
| 4086 | }, | 4105 | }, |
| 4087 | .dst_temps = .{ .mem, .unused }, | 4106 | .dst_temps = .{ .mem, .unused }, |
| | 4107 | .clobbers = .{ .eflags = true }, |
| 4088 | .each = .{ .once = &.{ | 4108 | .each = .{ .once = &.{ |
| 4089 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 4109 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4090 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 4110 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -4178,6 +4198,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4178,6 +4198,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4178 | .unused, | 4198 | .unused, |
| 4179 | }, | 4199 | }, |
| 4180 | .dst_temps = .{ .mem, .unused }, | 4200 | .dst_temps = .{ .mem, .unused }, |
| | 4201 | .clobbers = .{ .eflags = true }, |
| 4181 | .each = .{ .once = &.{ | 4202 | .each = .{ .once = &.{ |
| 4182 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 4203 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 4183 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 4204 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -4345,12 +4366,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4345,12 +4366,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4345 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 4366 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 4346 | }, | 4367 | }, |
| 4347 | .add_safe => unreachable, | 4368 | .add_safe => unreachable, |
| 4348 | .add_sat => |air_tag| if (use_old) try cg.airAddSat(inst) else fallback: { | 4369 | .add_sat => |air_tag| if (use_old) try cg.airAddSat(inst) else { |
| 4349 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 4370 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 4350 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSat(inst); | | |
| 4351 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 4371 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 4352 | var res: [1]Temp = undefined; | 4372 | var res: [1]Temp = undefined; |
| 4353 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 4373 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| | 4374 | .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any }, |
| | 4375 | .patterns = &.{ |
| | 4376 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 4377 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 4378 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 4379 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 4380 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 4381 | }, |
| | 4382 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 4383 | .clobbers = .{ .eflags = true }, |
| | 4384 | .each = .{ .once = &.{ |
| | 4385 | .{ ._, ._, .@"or", .dst0b, .src1b, ._, ._ }, |
| | 4386 | } }, |
| | 4387 | }, .{ |
| 4354 | .required_features = .{ .cmov, null, null, null }, | 4388 | .required_features = .{ .cmov, null, null, null }, |
| 4355 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, | 4389 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| 4356 | .patterns = &.{ | 4390 | .patterns = &.{ |
| ... | @@ -4427,8 +4461,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4427,8 +4461,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4427 | .each = .{ .once = &.{ | 4461 | .each = .{ .once = &.{ |
| 4428 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, | 4462 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4429 | .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ }, | 4463 | .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ }, |
| 4430 | .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ }, | | |
| 4431 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, | 4464 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| | 4465 | .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ }, |
| 4432 | .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, | 4466 | .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| 4433 | .{ ._, ._po, .cmov, .dst0d, .tmp0d, ._, ._ }, | 4467 | .{ ._, ._po, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4434 | } }, | 4468 | } }, |
| ... | @@ -4528,7 +4562,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4528,7 +4562,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4528 | .{ ._, ._, .mov, .dst0b, .ua(.src0, .add_umax), ._, ._ }, | 4562 | .{ ._, ._, .mov, .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| 4529 | } }, | 4563 | } }, |
| 4530 | }, .{ | 4564 | }, .{ |
| 4531 | .required_features = .{ .fast_imm16, .cmov, null, null }, | 4565 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| 4532 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, | 4566 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| 4533 | .patterns = &.{ | 4567 | .patterns = &.{ |
| 4534 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, | 4568 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| ... | @@ -4538,7 +4572,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4538,7 +4572,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4538 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | 4572 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4539 | }, | 4573 | }, |
| 4540 | .extra_temps = .{ | 4574 | .extra_temps = .{ |
| 4541 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, | 4575 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4542 | .unused, | 4576 | .unused, |
| 4543 | .unused, | 4577 | .unused, |
| 4544 | .unused, | 4578 | .unused, |
| ... | @@ -4627,7 +4661,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4627,7 +4661,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4627 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ }, | 4661 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ }, |
| 4628 | } }, | 4662 | } }, |
| 4629 | }, .{ | 4663 | }, .{ |
| 4630 | .required_features = .{ .fast_imm16, .cmov, null, null }, | 4664 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| 4631 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, | 4665 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4632 | .patterns = &.{ | 4666 | .patterns = &.{ |
| 4633 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, | 4667 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| ... | @@ -4660,7 +4694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4660,7 +4694,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4660 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, | 4694 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4661 | } }, | 4695 | } }, |
| 4662 | }, .{ | 4696 | }, .{ |
| 4663 | .required_features = .{ .fast_imm16, .cmov, null, null }, | 4697 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| 4664 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, | 4698 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4665 | .patterns = &.{ | 4699 | .patterns = &.{ |
| 4666 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | 4700 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| ... | @@ -4873,7 +4907,133 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4873,7 +4907,133 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4873 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, | 4907 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4874 | } }, | 4908 | } }, |
| 4875 | }, .{ | 4909 | }, .{ |
| 4876 | .required_features = .{ .fast_imm16, .cmov, null, null }, | 4910 | .required_features = .{ .bmi2, .cmov, .fast_imm16, null }, |
| | 4911 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 4912 | .patterns = &.{ |
| | 4913 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 4914 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 4915 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 4916 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 4917 | }, |
| | 4918 | .extra_temps = .{ |
| | 4919 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 4920 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 4921 | .unused, |
| | 4922 | .unused, |
| | 4923 | .unused, |
| | 4924 | .unused, |
| | 4925 | .unused, |
| | 4926 | .unused, |
| | 4927 | .unused, |
| | 4928 | .unused, |
| | 4929 | .unused, |
| | 4930 | }, |
| | 4931 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 4932 | .clobbers = .{ .eflags = true }, |
| | 4933 | .each = .{ .once = &.{ |
| | 4934 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 4935 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| | 4936 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 4937 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| | 4938 | .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ }, |
| | 4939 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 4940 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 4941 | } }, |
| | 4942 | }, .{ |
| | 4943 | .required_features = .{ .bmi2, .cmov, .fast_imm16, null }, |
| | 4944 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 4945 | .patterns = &.{ |
| | 4946 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 4947 | }, |
| | 4948 | .extra_temps = .{ |
| | 4949 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 4950 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 4951 | .unused, |
| | 4952 | .unused, |
| | 4953 | .unused, |
| | 4954 | .unused, |
| | 4955 | .unused, |
| | 4956 | .unused, |
| | 4957 | .unused, |
| | 4958 | .unused, |
| | 4959 | .unused, |
| | 4960 | }, |
| | 4961 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 4962 | .clobbers = .{ .eflags = true }, |
| | 4963 | .each = .{ .once = &.{ |
| | 4964 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 4965 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| | 4966 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 4967 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| | 4968 | .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ }, |
| | 4969 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 4970 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 4971 | } }, |
| | 4972 | }, .{ |
| | 4973 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 4974 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 4975 | .patterns = &.{ |
| | 4976 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 4977 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 4978 | }, |
| | 4979 | .extra_temps = .{ |
| | 4980 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 4981 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 4982 | .unused, |
| | 4983 | .unused, |
| | 4984 | .unused, |
| | 4985 | .unused, |
| | 4986 | .unused, |
| | 4987 | .unused, |
| | 4988 | .unused, |
| | 4989 | .unused, |
| | 4990 | .unused, |
| | 4991 | }, |
| | 4992 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 4993 | .clobbers = .{ .eflags = true }, |
| | 4994 | .each = .{ .once = &.{ |
| | 4995 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 4996 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| | 4997 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 4998 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| | 4999 | .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ }, |
| | 5000 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 5001 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 5002 | } }, |
| | 5003 | }, .{ |
| | 5004 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 5005 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 5006 | .patterns = &.{ |
| | 5007 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 5008 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5009 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5010 | }, |
| | 5011 | .extra_temps = .{ |
| | 5012 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 5013 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 5014 | .unused, |
| | 5015 | .unused, |
| | 5016 | .unused, |
| | 5017 | .unused, |
| | 5018 | .unused, |
| | 5019 | .unused, |
| | 5020 | .unused, |
| | 5021 | .unused, |
| | 5022 | .unused, |
| | 5023 | }, |
| | 5024 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5025 | .clobbers = .{ .eflags = true }, |
| | 5026 | .each = .{ .once = &.{ |
| | 5027 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 5028 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| | 5029 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 5030 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| | 5031 | .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ }, |
| | 5032 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 5033 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 5034 | } }, |
| | 5035 | }, .{ |
| | 5036 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| 4877 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, | 5037 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 4878 | .patterns = &.{ | 5038 | .patterns = &.{ |
| 4879 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, | 5039 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| ... | @@ -4907,7 +5067,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4907,7 +5067,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4907 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, | 5067 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4908 | } }, | 5068 | } }, |
| 4909 | }, .{ | 5069 | }, .{ |
| 4910 | .required_features = .{ .fast_imm16, .cmov, null, null }, | 5070 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| 4911 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, | 5071 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 4912 | .patterns = &.{ | 5072 | .patterns = &.{ |
| 4913 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | 5073 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| ... | @@ -5387,6 +5547,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5387,6 +5547,40 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5387 | .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ }, | 5547 | .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ }, |
| 5388 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, | 5548 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5389 | } }, | 5549 | } }, |
| | 5550 | }, .{ |
| | 5551 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 5552 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| | 5553 | .patterns = &.{ |
| | 5554 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 5555 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5556 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 5557 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5558 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5559 | }, |
| | 5560 | .extra_temps = .{ |
| | 5561 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 5562 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 5563 | .unused, |
| | 5564 | .unused, |
| | 5565 | .unused, |
| | 5566 | .unused, |
| | 5567 | .unused, |
| | 5568 | .unused, |
| | 5569 | .unused, |
| | 5570 | .unused, |
| | 5571 | .unused, |
| | 5572 | }, |
| | 5573 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5574 | .clobbers = .{ .eflags = true }, |
| | 5575 | .each = .{ .once = &.{ |
| | 5576 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 5577 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| | 5578 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 5579 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| | 5580 | .{ ._, ._rx, .ro, .tmp1d, .dst0d, .uia(1, .src0, .add_bit_size), ._ }, |
| | 5581 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 5582 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| | 5583 | } }, |
| 5390 | }, .{ | 5584 | }, .{ |
| 5391 | .required_features = .{ .cmov, null, null, null }, | 5585 | .required_features = .{ .cmov, null, null, null }, |
| 5392 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, | 5586 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| ... | @@ -5636,18 +5830,6497 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5636,18 +5830,6497 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5636 | .required_features = .{ .@"64bit", null, null, null }, | 5830 | .required_features = .{ .@"64bit", null, null, null }, |
| 5637 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, | 5831 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, |
| 5638 | .patterns = &.{ | 5832 | .patterns = &.{ |
| 5639 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | 5833 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5640 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | 5834 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5641 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | 5835 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5642 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | 5836 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5643 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | 5837 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5838 | }, |
| | 5839 | .extra_temps = .{ |
| | 5840 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 5841 | .unused, |
| | 5842 | .unused, |
| | 5843 | .unused, |
| | 5844 | .unused, |
| | 5845 | .unused, |
| | 5846 | .unused, |
| | 5847 | .unused, |
| | 5848 | .unused, |
| | 5849 | .unused, |
| | 5850 | .unused, |
| | 5851 | }, |
| | 5852 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5853 | .clobbers = .{ .eflags = true }, |
| | 5854 | .each = .{ .once = &.{ |
| | 5855 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 5856 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 5857 | .{ ._, ._, .add, .tmp0q, .tmp0q, ._, ._ }, |
| | 5858 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| | 5859 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| | 5860 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ }, |
| | 5861 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, |
| | 5862 | } }, |
| | 5863 | }, .{ |
| | 5864 | .required_features = .{ .@"64bit", .bmi2, .cmov, null }, |
| | 5865 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 5866 | .patterns = &.{ |
| | 5867 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 5868 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5869 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 5870 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5871 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5872 | }, |
| | 5873 | .extra_temps = .{ |
| | 5874 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 5875 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 5876 | .unused, |
| | 5877 | .unused, |
| | 5878 | .unused, |
| | 5879 | .unused, |
| | 5880 | .unused, |
| | 5881 | .unused, |
| | 5882 | .unused, |
| | 5883 | .unused, |
| | 5884 | .unused, |
| | 5885 | }, |
| | 5886 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5887 | .clobbers = .{ .eflags = true }, |
| | 5888 | .each = .{ .once = &.{ |
| | 5889 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 5890 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 5891 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 5892 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 5893 | .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ }, |
| | 5894 | .{ ._, ._rx, .ro, .tmp1q, .dst0q, .sia(-31, .src0, .add_bit_size), ._ }, |
| | 5895 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 5896 | .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| | 5897 | } }, |
| | 5898 | }, .{ |
| | 5899 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 5900 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 5901 | .patterns = &.{ |
| | 5902 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 5903 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5904 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 5905 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5906 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5907 | }, |
| | 5908 | .extra_temps = .{ |
| | 5909 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 5910 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 5911 | .unused, |
| | 5912 | .unused, |
| | 5913 | .unused, |
| | 5914 | .unused, |
| | 5915 | .unused, |
| | 5916 | .unused, |
| | 5917 | .unused, |
| | 5918 | .unused, |
| | 5919 | .unused, |
| | 5920 | }, |
| | 5921 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5922 | .clobbers = .{ .eflags = true }, |
| | 5923 | .each = .{ .once = &.{ |
| | 5924 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 5925 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 5926 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 5927 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 5928 | .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ }, |
| | 5929 | .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ }, |
| | 5930 | .{ ._, ._r, .sh, .tmp1q, .sia(-31, .src0, .add_bit_size), ._, ._ }, |
| | 5931 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| | 5932 | .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| | 5933 | } }, |
| | 5934 | }, .{ |
| | 5935 | .required_features = .{ .@"64bit", null, null, null }, |
| | 5936 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 5937 | .patterns = &.{ |
| | 5938 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 5939 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5940 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 5941 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5942 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5943 | }, |
| | 5944 | .extra_temps = .{ |
| | 5945 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 5946 | .unused, |
| | 5947 | .unused, |
| | 5948 | .unused, |
| | 5949 | .unused, |
| | 5950 | .unused, |
| | 5951 | .unused, |
| | 5952 | .unused, |
| | 5953 | .unused, |
| | 5954 | .unused, |
| | 5955 | .unused, |
| | 5956 | }, |
| | 5957 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5958 | .clobbers = .{ .eflags = true }, |
| | 5959 | .each = .{ .once = &.{ |
| | 5960 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 5961 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 5962 | .{ ._, ._r, .sh, .tmp0q, .sia(-31, .src0, .add_bit_size), ._, ._ }, |
| | 5963 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| | 5964 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| | 5965 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| | 5966 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ }, |
| | 5967 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, |
| | 5968 | } }, |
| | 5969 | }, .{ |
| | 5970 | .required_features = .{ .@"64bit", null, null, null }, |
| | 5971 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, |
| | 5972 | .patterns = &.{ |
| | 5973 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 5974 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5975 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 5976 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 5977 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 5978 | }, |
| | 5979 | .extra_temps = .{ |
| | 5980 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 5981 | .unused, |
| | 5982 | .unused, |
| | 5983 | .unused, |
| | 5984 | .unused, |
| | 5985 | .unused, |
| | 5986 | .unused, |
| | 5987 | .unused, |
| | 5988 | .unused, |
| | 5989 | .unused, |
| | 5990 | .unused, |
| | 5991 | }, |
| | 5992 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 5993 | .clobbers = .{ .eflags = true }, |
| | 5994 | .each = .{ .once = &.{ |
| | 5995 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 5996 | .{ ._, ._, .sbb, .tmp0q, .tmp0q, ._, ._ }, |
| | 5997 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| | 5998 | } }, |
| | 5999 | }, .{ |
| | 6000 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 6001 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 6002 | .patterns = &.{ |
| | 6003 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 6004 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 6005 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 6006 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 6007 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 6008 | }, |
| | 6009 | .extra_temps = .{ |
| | 6010 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6011 | .unused, |
| | 6012 | .unused, |
| | 6013 | .unused, |
| | 6014 | .unused, |
| | 6015 | .unused, |
| | 6016 | .unused, |
| | 6017 | .unused, |
| | 6018 | .unused, |
| | 6019 | .unused, |
| | 6020 | .unused, |
| | 6021 | }, |
| | 6022 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6023 | .clobbers = .{ .eflags = true }, |
| | 6024 | .each = .{ .once = &.{ |
| | 6025 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 6026 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6027 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, |
| | 6028 | .{ ._, ._a, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| | 6029 | } }, |
| | 6030 | }, .{ |
| | 6031 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6032 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 6033 | .patterns = &.{ |
| | 6034 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 6035 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 6036 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 6037 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 6038 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 6039 | }, |
| | 6040 | .extra_temps = .{ |
| | 6041 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 6042 | .unused, |
| | 6043 | .unused, |
| | 6044 | .unused, |
| | 6045 | .unused, |
| | 6046 | .unused, |
| | 6047 | .unused, |
| | 6048 | .unused, |
| | 6049 | .unused, |
| | 6050 | .unused, |
| | 6051 | .unused, |
| | 6052 | }, |
| | 6053 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6054 | .clobbers = .{ .eflags = true }, |
| | 6055 | .each = .{ .once = &.{ |
| | 6056 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 6057 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6058 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, |
| | 6059 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| | 6060 | .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ }, |
| | 6061 | } }, |
| | 6062 | }, .{ |
| | 6063 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6064 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 6065 | .patterns = &.{ |
| | 6066 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 6067 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 6068 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 6069 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 6070 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 6071 | }, |
| | 6072 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6073 | .clobbers = .{ .eflags = true }, |
| | 6074 | .each = .{ .once = &.{ |
| | 6075 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 6076 | .{ ._, ._, .cmp, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6077 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| | 6078 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6079 | } }, |
| | 6080 | }, .{ |
| | 6081 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6082 | .src_constraints = .{ |
| | 6083 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 6084 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 6085 | .any, |
| | 6086 | }, |
| | 6087 | .patterns = &.{ |
| | 6088 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6089 | }, |
| | 6090 | .extra_temps = .{ |
| | 6091 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6092 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 6093 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6094 | .unused, |
| | 6095 | .unused, |
| | 6096 | .unused, |
| | 6097 | .unused, |
| | 6098 | .unused, |
| | 6099 | .unused, |
| | 6100 | .unused, |
| | 6101 | .unused, |
| | 6102 | }, |
| | 6103 | .dst_temps = .{ .mem, .unused }, |
| | 6104 | .clobbers = .{ .eflags = true }, |
| | 6105 | .each = .{ .once = &.{ |
| | 6106 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 6107 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6108 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6109 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6110 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6111 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6112 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6113 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 6114 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 6115 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| | 6116 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6117 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 6118 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 6119 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6120 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| | 6121 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| | 6122 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6123 | } }, |
| | 6124 | }, .{ |
| | 6125 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6126 | .src_constraints = .{ |
| | 6127 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 6128 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 6129 | .any, |
| | 6130 | }, |
| | 6131 | .patterns = &.{ |
| | 6132 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6133 | }, |
| | 6134 | .extra_temps = .{ |
| | 6135 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6136 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 6137 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6138 | .unused, |
| | 6139 | .unused, |
| | 6140 | .unused, |
| | 6141 | .unused, |
| | 6142 | .unused, |
| | 6143 | .unused, |
| | 6144 | .unused, |
| | 6145 | .unused, |
| | 6146 | }, |
| | 6147 | .dst_temps = .{ .mem, .unused }, |
| | 6148 | .clobbers = .{ .eflags = true }, |
| | 6149 | .each = .{ .once = &.{ |
| | 6150 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| | 6151 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6152 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 6153 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 6154 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ }, |
| | 6155 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6156 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6157 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 6158 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6159 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 6160 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| | 6161 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6162 | } }, |
| | 6163 | }, .{ |
| | 6164 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6165 | .src_constraints = .{ |
| | 6166 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 6167 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 6168 | .any, |
| | 6169 | }, |
| | 6170 | .patterns = &.{ |
| | 6171 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6172 | }, |
| | 6173 | .extra_temps = .{ |
| | 6174 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6175 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 6176 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6177 | .unused, |
| | 6178 | .unused, |
| | 6179 | .unused, |
| | 6180 | .unused, |
| | 6181 | .unused, |
| | 6182 | .unused, |
| | 6183 | .unused, |
| | 6184 | .unused, |
| | 6185 | }, |
| | 6186 | .dst_temps = .{ .mem, .unused }, |
| | 6187 | .clobbers = .{ .eflags = true }, |
| | 6188 | .each = .{ .once = &.{ |
| | 6189 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 6190 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6191 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 6192 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 6193 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -16), .tmp1q, ._, ._ }, |
| | 6194 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6195 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6196 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 6197 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 6198 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| | 6199 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6200 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 6201 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, |
| | 6202 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6203 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| | 6204 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| | 6205 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, |
| | 6206 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 6207 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6208 | } }, |
| | 6209 | }, .{ |
| | 6210 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6211 | .src_constraints = .{ |
| | 6212 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 6213 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 6214 | .any, |
| | 6215 | }, |
| | 6216 | .patterns = &.{ |
| | 6217 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6218 | }, |
| | 6219 | .extra_temps = .{ |
| | 6220 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6221 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 6222 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6223 | .unused, |
| | 6224 | .unused, |
| | 6225 | .unused, |
| | 6226 | .unused, |
| | 6227 | .unused, |
| | 6228 | .unused, |
| | 6229 | .unused, |
| | 6230 | .unused, |
| | 6231 | }, |
| | 6232 | .dst_temps = .{ .mem, .unused }, |
| | 6233 | .clobbers = .{ .eflags = true }, |
| | 6234 | .each = .{ .once = &.{ |
| | 6235 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 6236 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6237 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6238 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6239 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6240 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6241 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6242 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| | 6243 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6244 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 6245 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 6246 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6247 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 6248 | } }, |
| | 6249 | }, .{ |
| | 6250 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6251 | .src_constraints = .{ |
| | 6252 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 6253 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 6254 | .any, |
| | 6255 | }, |
| | 6256 | .patterns = &.{ |
| | 6257 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6258 | }, |
| | 6259 | .extra_temps = .{ |
| | 6260 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6261 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 6262 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6263 | .unused, |
| | 6264 | .unused, |
| | 6265 | .unused, |
| | 6266 | .unused, |
| | 6267 | .unused, |
| | 6268 | .unused, |
| | 6269 | .unused, |
| | 6270 | .unused, |
| | 6271 | }, |
| | 6272 | .dst_temps = .{ .mem, .unused }, |
| | 6273 | .clobbers = .{ .eflags = true }, |
| | 6274 | .each = .{ .once = &.{ |
| | 6275 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 6276 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6277 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6278 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6279 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6280 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6281 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6282 | .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 6283 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, |
| | 6284 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| | 6285 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6286 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 6287 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, |
| | 6288 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6289 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| | 6290 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| | 6291 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, |
| | 6292 | .{ .@"0:", ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 6293 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6294 | } }, |
| | 6295 | }, .{ |
| | 6296 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6297 | .src_constraints = .{ |
| | 6298 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 6299 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 6300 | .any, |
| | 6301 | }, |
| | 6302 | .patterns = &.{ |
| | 6303 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6304 | }, |
| | 6305 | .extra_temps = .{ |
| | 6306 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6307 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 6308 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6309 | .unused, |
| | 6310 | .unused, |
| | 6311 | .unused, |
| | 6312 | .unused, |
| | 6313 | .unused, |
| | 6314 | .unused, |
| | 6315 | .unused, |
| | 6316 | .unused, |
| | 6317 | }, |
| | 6318 | .dst_temps = .{ .mem, .unused }, |
| | 6319 | .clobbers = .{ .eflags = true }, |
| | 6320 | .each = .{ .once = &.{ |
| | 6321 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 6322 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6323 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6324 | .{ .@"0:", ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6325 | .{ ._, ._, .adc, .tmp2q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 6326 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp2q, ._, ._ }, |
| | 6327 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6328 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6329 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, |
| | 6330 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| | 6331 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, |
| | 6332 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6333 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 6334 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, |
| | 6335 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6336 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 6337 | } }, |
| | 6338 | }, .{ |
| | 6339 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6340 | .src_constraints = .{ |
| | 6341 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 6342 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 6343 | .any, |
| | 6344 | }, |
| | 6345 | .patterns = &.{ |
| | 6346 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6347 | }, |
| | 6348 | .extra_temps = .{ |
| | 6349 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6350 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 6351 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6352 | .unused, |
| | 6353 | .unused, |
| | 6354 | .unused, |
| | 6355 | .unused, |
| | 6356 | .unused, |
| | 6357 | .unused, |
| | 6358 | .unused, |
| | 6359 | .unused, |
| | 6360 | }, |
| | 6361 | .dst_temps = .{ .mem, .unused }, |
| | 6362 | .clobbers = .{ .eflags = true }, |
| | 6363 | .each = .{ .once = &.{ |
| | 6364 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| | 6365 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6366 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 6367 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 6368 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ }, |
| | 6369 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6370 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6371 | .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 6372 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, |
| | 6373 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| | 6374 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6375 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 6376 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 6377 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6378 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| | 6379 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| | 6380 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6381 | } }, |
| | 6382 | }, .{ |
| | 6383 | .required_features = .{ .@"64bit", null, null, null }, |
| | 6384 | .src_constraints = .{ |
| | 6385 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 6386 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 6387 | .any, |
| | 6388 | }, |
| | 6389 | .patterns = &.{ |
| | 6390 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 6391 | }, |
| | 6392 | .extra_temps = .{ |
| | 6393 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 6394 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 6395 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 6396 | .unused, |
| | 6397 | .unused, |
| | 6398 | .unused, |
| | 6399 | .unused, |
| | 6400 | .unused, |
| | 6401 | .unused, |
| | 6402 | .unused, |
| | 6403 | .unused, |
| | 6404 | }, |
| | 6405 | .dst_temps = .{ .mem, .unused }, |
| | 6406 | .clobbers = .{ .eflags = true }, |
| | 6407 | .each = .{ .once = &.{ |
| | 6408 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| | 6409 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 6410 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 6411 | .{ .@"0:", ._, .mov, .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 6412 | .{ ._, ._, .adc, .tmp2q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 6413 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp2q, ._, ._ }, |
| | 6414 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 6415 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 6416 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, |
| | 6417 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| | 6418 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| | 6419 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| | 6420 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| | 6421 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 6422 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 6423 | } }, |
| | 6424 | }, .{ |
| | 6425 | .required_features = .{ .mmx, null, null, null }, |
| | 6426 | .src_constraints = .{ |
| | 6427 | .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 6428 | .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 6429 | .any, |
| | 6430 | }, |
| | 6431 | .patterns = &.{ |
| | 6432 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 6433 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 6434 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, |
| | 6435 | }, |
| | 6436 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6437 | .each = .{ .once = &.{ |
| | 6438 | .{ ._, .p_, .@"or", .dst0q, .src1q, ._, ._ }, |
| | 6439 | } }, |
| | 6440 | }, .{ |
| | 6441 | .required_features = .{ .avx, null, null, null }, |
| | 6442 | .src_constraints = .{ |
| | 6443 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 6444 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 6445 | .any, |
| | 6446 | }, |
| | 6447 | .patterns = &.{ |
| | 6448 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6449 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6450 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6451 | }, |
| | 6452 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6453 | .each = .{ .once = &.{ |
| | 6454 | .{ ._, .vp_, .@"or", .dst0x, .src0x, .src1x, ._ }, |
| | 6455 | } }, |
| | 6456 | }, .{ |
| | 6457 | .required_features = .{ .sse2, null, null, null }, |
| | 6458 | .src_constraints = .{ |
| | 6459 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 6460 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 6461 | .any, |
| | 6462 | }, |
| | 6463 | .patterns = &.{ |
| | 6464 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6465 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6466 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6467 | }, |
| | 6468 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6469 | .each = .{ .once = &.{ |
| | 6470 | .{ ._, .p_, .@"or", .dst0x, .src1x, ._, ._ }, |
| | 6471 | } }, |
| | 6472 | }, .{ |
| | 6473 | .required_features = .{ .sse, null, null, null }, |
| | 6474 | .src_constraints = .{ |
| | 6475 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 6476 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 6477 | .any, |
| | 6478 | }, |
| | 6479 | .patterns = &.{ |
| | 6480 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6481 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6482 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6483 | }, |
| | 6484 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6485 | .each = .{ .once = &.{ |
| | 6486 | .{ ._, ._ps, .@"or", .dst0x, .src1x, ._, ._ }, |
| | 6487 | } }, |
| | 6488 | }, .{ |
| | 6489 | .required_features = .{ .avx2, null, null, null }, |
| | 6490 | .src_constraints = .{ |
| | 6491 | .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 6492 | .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 6493 | .any, |
| | 6494 | }, |
| | 6495 | .patterns = &.{ |
| | 6496 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6497 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6498 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6499 | }, |
| | 6500 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6501 | .each = .{ .once = &.{ |
| | 6502 | .{ ._, .vp_, .@"or", .dst0y, .src0y, .src1y, ._ }, |
| | 6503 | } }, |
| | 6504 | }, .{ |
| | 6505 | .required_features = .{ .mmx, null, null, null }, |
| | 6506 | .src_constraints = .{ |
| | 6507 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 6508 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 6509 | .any, |
| | 6510 | }, |
| | 6511 | .patterns = &.{ |
| | 6512 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 6513 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 6514 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, |
| | 6515 | }, |
| | 6516 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6517 | .each = .{ .once = &.{ |
| | 6518 | .{ ._, .p_b, .adds, .dst0q, .src1q, ._, ._ }, |
| | 6519 | } }, |
| | 6520 | }, .{ |
| | 6521 | .required_features = .{ .avx, null, null, null }, |
| | 6522 | .src_constraints = .{ |
| | 6523 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 6524 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 6525 | .any, |
| | 6526 | }, |
| | 6527 | .patterns = &.{ |
| | 6528 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6529 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6530 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6531 | }, |
| | 6532 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6533 | .each = .{ .once = &.{ |
| | 6534 | .{ ._, .vp_b, .adds, .dst0x, .src0x, .src1x, ._ }, |
| | 6535 | } }, |
| | 6536 | }, .{ |
| | 6537 | .required_features = .{ .sse2, null, null, null }, |
| | 6538 | .src_constraints = .{ |
| | 6539 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 6540 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 6541 | .any, |
| | 6542 | }, |
| | 6543 | .patterns = &.{ |
| | 6544 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6545 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6546 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6547 | }, |
| | 6548 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6549 | .each = .{ .once = &.{ |
| | 6550 | .{ ._, .p_b, .adds, .dst0x, .src1x, ._, ._ }, |
| | 6551 | } }, |
| | 6552 | }, .{ |
| | 6553 | .required_features = .{ .avx2, null, null, null }, |
| | 6554 | .src_constraints = .{ |
| | 6555 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 6556 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 6557 | .any, |
| | 6558 | }, |
| | 6559 | .patterns = &.{ |
| | 6560 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6561 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6562 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6563 | }, |
| | 6564 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6565 | .each = .{ .once = &.{ |
| | 6566 | .{ ._, .vp_b, .adds, .dst0y, .src0y, .src1y, ._ }, |
| | 6567 | } }, |
| | 6568 | }, .{ |
| | 6569 | .required_features = .{ .avx, null, null, null }, |
| | 6570 | .src_constraints = .{ |
| | 6571 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 6572 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 6573 | .any, |
| | 6574 | }, |
| | 6575 | .patterns = &.{ |
| | 6576 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6577 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6578 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6579 | }, |
| | 6580 | .extra_temps = .{ |
| | 6581 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6582 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6583 | .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6584 | .unused, |
| | 6585 | .unused, |
| | 6586 | .unused, |
| | 6587 | .unused, |
| | 6588 | .unused, |
| | 6589 | .unused, |
| | 6590 | .unused, |
| | 6591 | .unused, |
| | 6592 | }, |
| | 6593 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6594 | .each = .{ .once = &.{ |
| | 6595 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6596 | .{ ._, .vp_b, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 6597 | .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 6598 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 6599 | .{ ._, .vp_b, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 6600 | } }, |
| | 6601 | }, .{ |
| | 6602 | .required_features = .{ .sse4_1, null, null, null }, |
| | 6603 | .src_constraints = .{ |
| | 6604 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 6605 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 6606 | .any, |
| | 6607 | }, |
| | 6608 | .patterns = &.{ |
| | 6609 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6610 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6611 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6612 | }, |
| | 6613 | .extra_temps = .{ |
| | 6614 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6615 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6616 | .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6617 | .unused, |
| | 6618 | .unused, |
| | 6619 | .unused, |
| | 6620 | .unused, |
| | 6621 | .unused, |
| | 6622 | .unused, |
| | 6623 | .unused, |
| | 6624 | .unused, |
| | 6625 | }, |
| | 6626 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6627 | .each = .{ .once = &.{ |
| | 6628 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6629 | .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ }, |
| | 6630 | .{ ._, .p_b, .maxs, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 6631 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 6632 | .{ ._, .p_b, .mins, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 6633 | } }, |
| | 6634 | }, .{ |
| | 6635 | .required_features = .{ .sse2, null, null, null }, |
| | 6636 | .src_constraints = .{ |
| | 6637 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 6638 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 6639 | .any, |
| | 6640 | }, |
| | 6641 | .patterns = &.{ |
| | 6642 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6643 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6644 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6645 | }, |
| | 6646 | .extra_temps = .{ |
| | 6647 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6648 | .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6649 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 6650 | .unused, |
| | 6651 | .unused, |
| | 6652 | .unused, |
| | 6653 | .unused, |
| | 6654 | .unused, |
| | 6655 | .unused, |
| | 6656 | .unused, |
| | 6657 | .unused, |
| | 6658 | }, |
| | 6659 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6660 | .each = .{ .once = &.{ |
| | 6661 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6662 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 6663 | .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ }, |
| | 6664 | .{ ._, .p_b, .adds, .dst0x, .src1x, ._, ._ }, |
| | 6665 | .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ }, |
| | 6666 | .{ ._, .p_b, .adds, .dst0x, .tmp2x, ._, ._ }, |
| | 6667 | .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ }, |
| | 6668 | } }, |
| | 6669 | }, .{ |
| | 6670 | .required_features = .{ .avx2, null, null, null }, |
| | 6671 | .src_constraints = .{ |
| | 6672 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 6673 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 6674 | .any, |
| | 6675 | }, |
| | 6676 | .patterns = &.{ |
| | 6677 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6678 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6679 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6680 | }, |
| | 6681 | .extra_temps = .{ |
| | 6682 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6683 | .{ .type = .vector_32_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 6684 | .{ .type = .vector_32_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 6685 | .unused, |
| | 6686 | .unused, |
| | 6687 | .unused, |
| | 6688 | .unused, |
| | 6689 | .unused, |
| | 6690 | .unused, |
| | 6691 | .unused, |
| | 6692 | .unused, |
| | 6693 | }, |
| | 6694 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6695 | .each = .{ .once = &.{ |
| | 6696 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6697 | .{ ._, .vp_b, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 6698 | .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 6699 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 6700 | .{ ._, .vp_b, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 6701 | } }, |
| | 6702 | }, .{ |
| | 6703 | .required_features = .{ .mmx, null, null, null }, |
| | 6704 | .src_constraints = .{ |
| | 6705 | .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } }, |
| | 6706 | .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } }, |
| | 6707 | .any, |
| | 6708 | }, |
| | 6709 | .patterns = &.{ |
| | 6710 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 6711 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 6712 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, |
| | 6713 | }, |
| | 6714 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6715 | .each = .{ .once = &.{ |
| | 6716 | .{ ._, .p_b, .addus, .dst0q, .src1q, ._, ._ }, |
| | 6717 | } }, |
| | 6718 | }, .{ |
| | 6719 | .required_features = .{ .avx, null, null, null }, |
| | 6720 | .src_constraints = .{ |
| | 6721 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 6722 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 6723 | .any, |
| | 6724 | }, |
| | 6725 | .patterns = &.{ |
| | 6726 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6727 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6728 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6729 | }, |
| | 6730 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6731 | .each = .{ .once = &.{ |
| | 6732 | .{ ._, .vp_b, .addus, .dst0x, .src0x, .src1x, ._ }, |
| | 6733 | } }, |
| | 6734 | }, .{ |
| | 6735 | .required_features = .{ .sse2, null, null, null }, |
| | 6736 | .src_constraints = .{ |
| | 6737 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 6738 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 6739 | .any, |
| | 6740 | }, |
| | 6741 | .patterns = &.{ |
| | 6742 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6743 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6744 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6745 | }, |
| | 6746 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6747 | .each = .{ .once = &.{ |
| | 6748 | .{ ._, .p_b, .addus, .dst0x, .src1x, ._, ._ }, |
| | 6749 | } }, |
| | 6750 | }, .{ |
| | 6751 | .required_features = .{ .avx2, null, null, null }, |
| | 6752 | .src_constraints = .{ |
| | 6753 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } }, |
| | 6754 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } }, |
| | 6755 | .any, |
| | 6756 | }, |
| | 6757 | .patterns = &.{ |
| | 6758 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6759 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6760 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6761 | }, |
| | 6762 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6763 | .each = .{ .once = &.{ |
| | 6764 | .{ ._, .vp_b, .addus, .dst0y, .src0y, .src1y, ._ }, |
| | 6765 | } }, |
| | 6766 | }, .{ |
| | 6767 | .required_features = .{ .sse, .mmx, null, null }, |
| | 6768 | .src_constraints = .{ |
| | 6769 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 6770 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 6771 | .any, |
| | 6772 | }, |
| | 6773 | .patterns = &.{ |
| | 6774 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 6775 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 6776 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 6777 | }, |
| | 6778 | .extra_temps = .{ |
| | 6779 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6780 | .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6781 | .unused, |
| | 6782 | .unused, |
| | 6783 | .unused, |
| | 6784 | .unused, |
| | 6785 | .unused, |
| | 6786 | .unused, |
| | 6787 | .unused, |
| | 6788 | .unused, |
| | 6789 | .unused, |
| | 6790 | }, |
| | 6791 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6792 | .each = .{ .once = &.{ |
| | 6793 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6794 | .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ }, |
| | 6795 | .{ ._, .p_b, .minu, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 6796 | } }, |
| | 6797 | }, .{ |
| | 6798 | .required_features = .{ .avx, null, null, null }, |
| | 6799 | .src_constraints = .{ |
| | 6800 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 6801 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 6802 | .any, |
| | 6803 | }, |
| | 6804 | .patterns = &.{ |
| | 6805 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6806 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6807 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6808 | }, |
| | 6809 | .extra_temps = .{ |
| | 6810 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6811 | .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6812 | .unused, |
| | 6813 | .unused, |
| | 6814 | .unused, |
| | 6815 | .unused, |
| | 6816 | .unused, |
| | 6817 | .unused, |
| | 6818 | .unused, |
| | 6819 | .unused, |
| | 6820 | .unused, |
| | 6821 | }, |
| | 6822 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6823 | .each = .{ .once = &.{ |
| | 6824 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6825 | .{ ._, .vp_b, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 6826 | .{ ._, .vp_b, .minu, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 6827 | } }, |
| | 6828 | }, .{ |
| | 6829 | .required_features = .{ .sse2, null, null, null }, |
| | 6830 | .src_constraints = .{ |
| | 6831 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 6832 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 6833 | .any, |
| | 6834 | }, |
| | 6835 | .patterns = &.{ |
| | 6836 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6837 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6838 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6839 | }, |
| | 6840 | .extra_temps = .{ |
| | 6841 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6842 | .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 6843 | .unused, |
| | 6844 | .unused, |
| | 6845 | .unused, |
| | 6846 | .unused, |
| | 6847 | .unused, |
| | 6848 | .unused, |
| | 6849 | .unused, |
| | 6850 | .unused, |
| | 6851 | .unused, |
| | 6852 | }, |
| | 6853 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6854 | .each = .{ .once = &.{ |
| | 6855 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6856 | .{ ._, .p_b, .add, .dst0x, .src1x, ._, ._ }, |
| | 6857 | .{ ._, .p_b, .minu, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 6858 | } }, |
| | 6859 | }, .{ |
| | 6860 | .required_features = .{ .avx2, null, null, null }, |
| | 6861 | .src_constraints = .{ |
| | 6862 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 6863 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 6864 | .any, |
| | 6865 | }, |
| | 6866 | .patterns = &.{ |
| | 6867 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6868 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6869 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6870 | }, |
| | 6871 | .extra_temps = .{ |
| | 6872 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6873 | .{ .type = .vector_32_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 6874 | .unused, |
| | 6875 | .unused, |
| | 6876 | .unused, |
| | 6877 | .unused, |
| | 6878 | .unused, |
| | 6879 | .unused, |
| | 6880 | .unused, |
| | 6881 | .unused, |
| | 6882 | .unused, |
| | 6883 | }, |
| | 6884 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6885 | .each = .{ .once = &.{ |
| | 6886 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6887 | .{ ._, .vp_b, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 6888 | .{ ._, .vp_b, .minu, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 6889 | } }, |
| | 6890 | }, .{ |
| | 6891 | .required_features = .{ .mmx, null, null, null }, |
| | 6892 | .src_constraints = .{ |
| | 6893 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } }, |
| | 6894 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } }, |
| | 6895 | .any, |
| | 6896 | }, |
| | 6897 | .patterns = &.{ |
| | 6898 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 6899 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 6900 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, |
| | 6901 | }, |
| | 6902 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6903 | .each = .{ .once = &.{ |
| | 6904 | .{ ._, .p_w, .adds, .dst0q, .src1q, ._, ._ }, |
| | 6905 | } }, |
| | 6906 | }, .{ |
| | 6907 | .required_features = .{ .avx, null, null, null }, |
| | 6908 | .src_constraints = .{ |
| | 6909 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 6910 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 6911 | .any, |
| | 6912 | }, |
| | 6913 | .patterns = &.{ |
| | 6914 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6915 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6916 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6917 | }, |
| | 6918 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6919 | .each = .{ .once = &.{ |
| | 6920 | .{ ._, .vp_w, .adds, .dst0x, .src0x, .src1x, ._ }, |
| | 6921 | } }, |
| | 6922 | }, .{ |
| | 6923 | .required_features = .{ .sse2, null, null, null }, |
| | 6924 | .src_constraints = .{ |
| | 6925 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 6926 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 6927 | .any, |
| | 6928 | }, |
| | 6929 | .patterns = &.{ |
| | 6930 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 6931 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6932 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 6933 | }, |
| | 6934 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6935 | .each = .{ .once = &.{ |
| | 6936 | .{ ._, .p_w, .adds, .dst0x, .src1x, ._, ._ }, |
| | 6937 | } }, |
| | 6938 | }, .{ |
| | 6939 | .required_features = .{ .avx2, null, null, null }, |
| | 6940 | .src_constraints = .{ |
| | 6941 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 6942 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 6943 | .any, |
| | 6944 | }, |
| | 6945 | .patterns = &.{ |
| | 6946 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6947 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6948 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6949 | }, |
| | 6950 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 6951 | .each = .{ .once = &.{ |
| | 6952 | .{ ._, .vp_w, .adds, .dst0y, .src0y, .src1y, ._ }, |
| | 6953 | } }, |
| | 6954 | }, .{ |
| | 6955 | .required_features = .{ .sse, .mmx, null, null }, |
| | 6956 | .src_constraints = .{ |
| | 6957 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 6958 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 6959 | .any, |
| | 6960 | }, |
| | 6961 | .patterns = &.{ |
| | 6962 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 6963 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 6964 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 6965 | }, |
| | 6966 | .extra_temps = .{ |
| | 6967 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 6968 | .{ .type = .vector_4_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .qword } } }, |
| | 6969 | .{ .type = .vector_4_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .qword } } }, |
| | 6970 | .unused, |
| | 6971 | .unused, |
| | 6972 | .unused, |
| | 6973 | .unused, |
| | 6974 | .unused, |
| | 6975 | .unused, |
| | 6976 | .unused, |
| | 6977 | .unused, |
| | 6978 | }, |
| | 6979 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 6980 | .each = .{ .once = &.{ |
| | 6981 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 6982 | .{ ._, .p_w, .add, .dst0q, .src1q, ._, ._ }, |
| | 6983 | .{ ._, .p_w, .maxs, .dst0q, .lea(.tmp0q), ._, ._ }, |
| | 6984 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 6985 | .{ ._, .p_w, .mins, .dst0q, .lea(.tmp0q), ._, ._ }, |
| | 6986 | } }, |
| | 6987 | }, .{ |
| | 6988 | .required_features = .{ .avx, null, null, null }, |
| | 6989 | .src_constraints = .{ |
| | 6990 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 6991 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 6992 | .any, |
| | 6993 | }, |
| | 6994 | .patterns = &.{ |
| | 6995 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 6996 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 6997 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 6998 | }, |
| | 6999 | .extra_temps = .{ |
| | 7000 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7001 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7002 | .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7003 | .unused, |
| | 7004 | .unused, |
| | 7005 | .unused, |
| | 7006 | .unused, |
| | 7007 | .unused, |
| | 7008 | .unused, |
| | 7009 | .unused, |
| | 7010 | .unused, |
| | 7011 | }, |
| | 7012 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7013 | .each = .{ .once = &.{ |
| | 7014 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7015 | .{ ._, .vp_w, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7016 | .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 7017 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 7018 | .{ ._, .vp_w, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 7019 | } }, |
| | 7020 | }, .{ |
| | 7021 | .required_features = .{ .sse4_1, null, null, null }, |
| | 7022 | .src_constraints = .{ |
| | 7023 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 7024 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 7025 | .any, |
| | 7026 | }, |
| | 7027 | .patterns = &.{ |
| | 7028 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7029 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7030 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7031 | }, |
| | 7032 | .extra_temps = .{ |
| | 7033 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7034 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7035 | .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7036 | .unused, |
| | 7037 | .unused, |
| | 7038 | .unused, |
| | 7039 | .unused, |
| | 7040 | .unused, |
| | 7041 | .unused, |
| | 7042 | .unused, |
| | 7043 | .unused, |
| | 7044 | }, |
| | 7045 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7046 | .each = .{ .once = &.{ |
| | 7047 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7048 | .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ }, |
| | 7049 | .{ ._, .p_w, .maxs, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 7050 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 7051 | .{ ._, .p_w, .mins, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 7052 | } }, |
| | 7053 | }, .{ |
| | 7054 | .required_features = .{ .avx2, null, null, null }, |
| | 7055 | .src_constraints = .{ |
| | 7056 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 7057 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 7058 | .any, |
| | 7059 | }, |
| | 7060 | .patterns = &.{ |
| | 7061 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7062 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7063 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7064 | }, |
| | 7065 | .extra_temps = .{ |
| | 7066 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7067 | .{ .type = .vector_16_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7068 | .{ .type = .vector_16_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7069 | .unused, |
| | 7070 | .unused, |
| | 7071 | .unused, |
| | 7072 | .unused, |
| | 7073 | .unused, |
| | 7074 | .unused, |
| | 7075 | .unused, |
| | 7076 | .unused, |
| | 7077 | }, |
| | 7078 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7079 | .each = .{ .once = &.{ |
| | 7080 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7081 | .{ ._, .vp_w, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7082 | .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 7083 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 7084 | .{ ._, .vp_w, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 7085 | } }, |
| | 7086 | }, .{ |
| | 7087 | .required_features = .{ .mmx, null, null, null }, |
| | 7088 | .src_constraints = .{ |
| | 7089 | .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } }, |
| | 7090 | .{ .scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } }, |
| | 7091 | .any, |
| | 7092 | }, |
| | 7093 | .patterns = &.{ |
| | 7094 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 7095 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| | 7096 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, |
| | 7097 | }, |
| | 7098 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7099 | .each = .{ .once = &.{ |
| | 7100 | .{ ._, .p_w, .addus, .dst0q, .src1q, ._, ._ }, |
| | 7101 | } }, |
| | 7102 | }, .{ |
| | 7103 | .required_features = .{ .avx, null, null, null }, |
| | 7104 | .src_constraints = .{ |
| | 7105 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 7106 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 7107 | .any, |
| | 7108 | }, |
| | 7109 | .patterns = &.{ |
| | 7110 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7111 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7112 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7113 | }, |
| | 7114 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7115 | .each = .{ .once = &.{ |
| | 7116 | .{ ._, .vp_w, .addus, .dst0x, .src0x, .src1x, ._ }, |
| | 7117 | } }, |
| | 7118 | }, .{ |
| | 7119 | .required_features = .{ .sse2, null, null, null }, |
| | 7120 | .src_constraints = .{ |
| | 7121 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 7122 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 7123 | .any, |
| | 7124 | }, |
| | 7125 | .patterns = &.{ |
| | 7126 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7127 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7128 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7129 | }, |
| | 7130 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7131 | .each = .{ .once = &.{ |
| | 7132 | .{ ._, .p_w, .addus, .dst0x, .src1x, ._, ._ }, |
| | 7133 | } }, |
| | 7134 | }, .{ |
| | 7135 | .required_features = .{ .avx2, null, null, null }, |
| | 7136 | .src_constraints = .{ |
| | 7137 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } }, |
| | 7138 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } }, |
| | 7139 | .any, |
| | 7140 | }, |
| | 7141 | .patterns = &.{ |
| | 7142 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7143 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7144 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7145 | }, |
| | 7146 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7147 | .each = .{ .once = &.{ |
| | 7148 | .{ ._, .vp_w, .addus, .dst0y, .src0y, .src1y, ._ }, |
| | 7149 | } }, |
| | 7150 | }, .{ |
| | 7151 | .required_features = .{ .avx, null, null, null }, |
| | 7152 | .src_constraints = .{ |
| | 7153 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 7154 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 7155 | .any, |
| | 7156 | }, |
| | 7157 | .patterns = &.{ |
| | 7158 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7159 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7160 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7161 | }, |
| | 7162 | .extra_temps = .{ |
| | 7163 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7164 | .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7165 | .unused, |
| | 7166 | .unused, |
| | 7167 | .unused, |
| | 7168 | .unused, |
| | 7169 | .unused, |
| | 7170 | .unused, |
| | 7171 | .unused, |
| | 7172 | .unused, |
| | 7173 | .unused, |
| | 7174 | }, |
| | 7175 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7176 | .each = .{ .once = &.{ |
| | 7177 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7178 | .{ ._, .vp_w, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7179 | .{ ._, .vp_w, .minu, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 7180 | } }, |
| | 7181 | }, .{ |
| | 7182 | .required_features = .{ .sse4_1, null, null, null }, |
| | 7183 | .src_constraints = .{ |
| | 7184 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 7185 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 7186 | .any, |
| | 7187 | }, |
| | 7188 | .patterns = &.{ |
| | 7189 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7190 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7191 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7192 | }, |
| | 7193 | .extra_temps = .{ |
| | 7194 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7195 | .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7196 | .unused, |
| | 7197 | .unused, |
| | 7198 | .unused, |
| | 7199 | .unused, |
| | 7200 | .unused, |
| | 7201 | .unused, |
| | 7202 | .unused, |
| | 7203 | .unused, |
| | 7204 | .unused, |
| | 7205 | }, |
| | 7206 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7207 | .each = .{ .once = &.{ |
| | 7208 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7209 | .{ ._, .p_w, .add, .dst0x, .src1x, ._, ._ }, |
| | 7210 | .{ ._, .p_w, .minu, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 7211 | } }, |
| | 7212 | }, .{ |
| | 7213 | .required_features = .{ .sse2, null, null, null }, |
| | 7214 | .src_constraints = .{ |
| | 7215 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 7216 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 7217 | .any, |
| | 7218 | }, |
| | 7219 | .patterns = &.{ |
| | 7220 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7221 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7222 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7223 | }, |
| | 7224 | .extra_temps = .{ |
| | 7225 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7226 | .{ .type = .vector_8_u16, .kind = .{ .umax_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7227 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 7228 | .unused, |
| | 7229 | .unused, |
| | 7230 | .unused, |
| | 7231 | .unused, |
| | 7232 | .unused, |
| | 7233 | .unused, |
| | 7234 | .unused, |
| | 7235 | .unused, |
| | 7236 | }, |
| | 7237 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7238 | .each = .{ .once = &.{ |
| | 7239 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7240 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 7241 | .{ ._, .p_w, .add, .dst0x, .tmp2x, ._, ._ }, |
| | 7242 | .{ ._, .p_w, .addus, .dst0x, .src1x, ._, ._ }, |
| | 7243 | .{ ._, .p_w, .sub, .dst0x, .tmp2x, ._, ._ }, |
| | 7244 | } }, |
| | 7245 | }, .{ |
| | 7246 | .required_features = .{ .avx2, null, null, null }, |
| | 7247 | .src_constraints = .{ |
| | 7248 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 7249 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 7250 | .any, |
| | 7251 | }, |
| | 7252 | .patterns = &.{ |
| | 7253 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7254 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7255 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7256 | }, |
| | 7257 | .extra_temps = .{ |
| | 7258 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7259 | .{ .type = .vector_16_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7260 | .unused, |
| | 7261 | .unused, |
| | 7262 | .unused, |
| | 7263 | .unused, |
| | 7264 | .unused, |
| | 7265 | .unused, |
| | 7266 | .unused, |
| | 7267 | .unused, |
| | 7268 | .unused, |
| | 7269 | }, |
| | 7270 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7271 | .each = .{ .once = &.{ |
| | 7272 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7273 | .{ ._, .vp_w, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7274 | .{ ._, .vp_w, .minu, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 7275 | } }, |
| | 7276 | }, .{ |
| | 7277 | .required_features = .{ .avx, null, null, null }, |
| | 7278 | .src_constraints = .{ |
| | 7279 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 7280 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 7281 | .any, |
| | 7282 | }, |
| | 7283 | .patterns = &.{ |
| | 7284 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7285 | }, |
| | 7286 | .extra_temps = .{ |
| | 7287 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7288 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7289 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 7290 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 7291 | .unused, |
| | 7292 | .unused, |
| | 7293 | .unused, |
| | 7294 | .unused, |
| | 7295 | .unused, |
| | 7296 | .unused, |
| | 7297 | .unused, |
| | 7298 | }, |
| | 7299 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7300 | .each = .{ .once = &.{ |
| | 7301 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7302 | .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7303 | .{ ._, .vp_d, .sra, .tmp2x, .src0x, .ui(31), ._ }, |
| | 7304 | .{ ._, .vp_d, .cmpgt, .tmp3x, .dst0x, .src0x, ._ }, |
| | 7305 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ }, |
| | 7306 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ }, |
| | 7307 | .{ ._, .v_ps, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x }, |
| | 7308 | } }, |
| | 7309 | }, .{ |
| | 7310 | .required_features = .{ .sse4_1, null, null, null }, |
| | 7311 | .src_constraints = .{ |
| | 7312 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 7313 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 7314 | .any, |
| | 7315 | }, |
| | 7316 | .patterns = &.{ |
| | 7317 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7318 | }, |
| | 7319 | .extra_temps = .{ |
| | 7320 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7321 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7322 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 7323 | .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } }, |
| | 7324 | .unused, |
| | 7325 | .unused, |
| | 7326 | .unused, |
| | 7327 | .unused, |
| | 7328 | .unused, |
| | 7329 | .unused, |
| | 7330 | .unused, |
| | 7331 | }, |
| | 7332 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7333 | .each = .{ .once = &.{ |
| | 7334 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7335 | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| | 7336 | .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ }, |
| | 7337 | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| | 7338 | .{ ._, .p_d, .sra, .tmp2x, .ui(31), ._, ._ }, |
| | 7339 | .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ }, |
| | 7340 | .{ ._, .p_d, .cmpgt, .tmp3x, .dst0x, ._, ._ }, |
| | 7341 | .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 7342 | .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ }, |
| | 7343 | .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 7344 | } }, |
| | 7345 | }, .{ |
| | 7346 | .required_features = .{ .avx2, null, null, null }, |
| | 7347 | .src_constraints = .{ |
| | 7348 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 7349 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 7350 | .any, |
| | 7351 | }, |
| | 7352 | .patterns = &.{ |
| | 7353 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7354 | }, |
| | 7355 | .extra_temps = .{ |
| | 7356 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7357 | .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7358 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 7359 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 7360 | .unused, |
| | 7361 | .unused, |
| | 7362 | .unused, |
| | 7363 | .unused, |
| | 7364 | .unused, |
| | 7365 | .unused, |
| | 7366 | .unused, |
| | 7367 | }, |
| | 7368 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7369 | .each = .{ .once = &.{ |
| | 7370 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7371 | .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7372 | .{ ._, .vp_d, .sra, .tmp2y, .src0y, .ui(31), ._ }, |
| | 7373 | .{ ._, .vp_d, .cmpgt, .tmp3y, .dst0y, .src0y, ._ }, |
| | 7374 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ }, |
| | 7375 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ }, |
| | 7376 | .{ ._, .v_ps, .blendv, .dst0y, .tmp2y, .dst0y, .tmp3y }, |
| | 7377 | } }, |
| | 7378 | }, .{ |
| | 7379 | .required_features = .{ .avx, null, null, null }, |
| | 7380 | .src_constraints = .{ |
| | 7381 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 7382 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 7383 | .any, |
| | 7384 | }, |
| | 7385 | .patterns = &.{ |
| | 7386 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7387 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7388 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7389 | }, |
| | 7390 | .extra_temps = .{ |
| | 7391 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7392 | .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7393 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7394 | .unused, |
| | 7395 | .unused, |
| | 7396 | .unused, |
| | 7397 | .unused, |
| | 7398 | .unused, |
| | 7399 | .unused, |
| | 7400 | .unused, |
| | 7401 | .unused, |
| | 7402 | }, |
| | 7403 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7404 | .each = .{ .once = &.{ |
| | 7405 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7406 | .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7407 | .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 7408 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 7409 | .{ ._, .vp_d, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 7410 | } }, |
| | 7411 | }, .{ |
| | 7412 | .required_features = .{ .sse4_1, null, null, null }, |
| | 7413 | .src_constraints = .{ |
| | 7414 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 7415 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 7416 | .any, |
| | 7417 | }, |
| | 7418 | .patterns = &.{ |
| | 7419 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7420 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7421 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7422 | }, |
| | 7423 | .extra_temps = .{ |
| | 7424 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7425 | .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7426 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7427 | .unused, |
| | 7428 | .unused, |
| | 7429 | .unused, |
| | 7430 | .unused, |
| | 7431 | .unused, |
| | 7432 | .unused, |
| | 7433 | .unused, |
| | 7434 | .unused, |
| | 7435 | }, |
| | 7436 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7437 | .each = .{ .once = &.{ |
| | 7438 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7439 | .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ }, |
| | 7440 | .{ ._, .p_d, .maxs, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 7441 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 7442 | .{ ._, .p_d, .mins, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 7443 | } }, |
| | 7444 | }, .{ |
| | 7445 | .required_features = .{ .avx2, null, null, null }, |
| | 7446 | .src_constraints = .{ |
| | 7447 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 7448 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 7449 | .any, |
| | 7450 | }, |
| | 7451 | .patterns = &.{ |
| | 7452 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7453 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7454 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7455 | }, |
| | 7456 | .extra_temps = .{ |
| | 7457 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7458 | .{ .type = .vector_8_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7459 | .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7460 | .unused, |
| | 7461 | .unused, |
| | 7462 | .unused, |
| | 7463 | .unused, |
| | 7464 | .unused, |
| | 7465 | .unused, |
| | 7466 | .unused, |
| | 7467 | .unused, |
| | 7468 | }, |
| | 7469 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7470 | .each = .{ .once = &.{ |
| | 7471 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7472 | .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7473 | .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 7474 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 7475 | .{ ._, .vp_d, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 7476 | } }, |
| | 7477 | }, .{ |
| | 7478 | .required_features = .{ .avx, null, null, null }, |
| | 7479 | .src_constraints = .{ |
| | 7480 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 7481 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 7482 | .any, |
| | 7483 | }, |
| | 7484 | .patterns = &.{ |
| | 7485 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7486 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7487 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7488 | }, |
| | 7489 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7490 | .each = .{ .once = &.{ |
| | 7491 | .{ ._, .vp_d, .cmpeq, .dst0x, .dst0x, .dst0x, ._ }, |
| | 7492 | .{ ._, .vp_, .xor, .dst0x, .src0x, .dst0x, ._ }, |
| | 7493 | .{ ._, .vp_d, .minu, .dst0x, .dst0x, .src1x, ._ }, |
| | 7494 | .{ ._, .vp_d, .add, .dst0x, .dst0x, .src0x, ._ }, |
| | 7495 | } }, |
| | 7496 | }, .{ |
| | 7497 | .required_features = .{ .sse4_1, null, null, null }, |
| | 7498 | .src_constraints = .{ |
| | 7499 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 7500 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 7501 | .any, |
| | 7502 | }, |
| | 7503 | .patterns = &.{ |
| | 7504 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7505 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7506 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7507 | }, |
| | 7508 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7509 | .each = .{ .once = &.{ |
| | 7510 | .{ ._, .p_d, .cmpeq, .dst0x, .dst0x, ._, ._ }, |
| | 7511 | .{ ._, .p_, .xor, .dst0x, .src0x, ._, ._ }, |
| | 7512 | .{ ._, .p_d, .minu, .dst0x, .src1x, ._, ._ }, |
| | 7513 | .{ ._, .p_d, .add, .dst0x, .src0x, ._, ._ }, |
| | 7514 | } }, |
| | 7515 | }, .{ |
| | 7516 | .required_features = .{ .avx2, null, null, null }, |
| | 7517 | .src_constraints = .{ |
| | 7518 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } }, |
| | 7519 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } }, |
| | 7520 | .any, |
| | 7521 | }, |
| | 7522 | .patterns = &.{ |
| | 7523 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7524 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7525 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7526 | }, |
| | 7527 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7528 | .each = .{ .once = &.{ |
| | 7529 | .{ ._, .vp_d, .cmpeq, .dst0y, .dst0y, .dst0y, ._ }, |
| | 7530 | .{ ._, .vp_, .xor, .dst0y, .src0y, .dst0y, ._ }, |
| | 7531 | .{ ._, .vp_d, .minu, .dst0y, .dst0y, .src1y, ._ }, |
| | 7532 | .{ ._, .vp_d, .add, .dst0y, .dst0y, .src0y, ._ }, |
| | 7533 | } }, |
| | 7534 | }, .{ |
| | 7535 | .required_features = .{ .avx, null, null, null }, |
| | 7536 | .src_constraints = .{ |
| | 7537 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 7538 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 7539 | .any, |
| | 7540 | }, |
| | 7541 | .patterns = &.{ |
| | 7542 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7543 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7544 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7545 | }, |
| | 7546 | .extra_temps = .{ |
| | 7547 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7548 | .{ .type = .vector_4_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7549 | .unused, |
| | 7550 | .unused, |
| | 7551 | .unused, |
| | 7552 | .unused, |
| | 7553 | .unused, |
| | 7554 | .unused, |
| | 7555 | .unused, |
| | 7556 | .unused, |
| | 7557 | .unused, |
| | 7558 | }, |
| | 7559 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7560 | .each = .{ .once = &.{ |
| | 7561 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7562 | .{ ._, .vp_d, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7563 | .{ ._, .vp_d, .minu, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 7564 | } }, |
| | 7565 | }, .{ |
| | 7566 | .required_features = .{ .sse4_1, null, null, null }, |
| | 7567 | .src_constraints = .{ |
| | 7568 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 7569 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 7570 | .any, |
| | 7571 | }, |
| | 7572 | .patterns = &.{ |
| | 7573 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7574 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7575 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7576 | }, |
| | 7577 | .extra_temps = .{ |
| | 7578 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7579 | .{ .type = .vector_4_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7580 | .unused, |
| | 7581 | .unused, |
| | 7582 | .unused, |
| | 7583 | .unused, |
| | 7584 | .unused, |
| | 7585 | .unused, |
| | 7586 | .unused, |
| | 7587 | .unused, |
| | 7588 | .unused, |
| | 7589 | }, |
| | 7590 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7591 | .each = .{ .once = &.{ |
| | 7592 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7593 | .{ ._, .p_d, .add, .dst0x, .src1x, ._, ._ }, |
| | 7594 | .{ ._, .p_d, .minu, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 7595 | } }, |
| | 7596 | }, .{ |
| | 7597 | .required_features = .{ .avx2, null, null, null }, |
| | 7598 | .src_constraints = .{ |
| | 7599 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 7600 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 7601 | .any, |
| | 7602 | }, |
| | 7603 | .patterns = &.{ |
| | 7604 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7605 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7606 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7607 | }, |
| | 7608 | .extra_temps = .{ |
| | 7609 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7610 | .{ .type = .vector_8_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7611 | .unused, |
| | 7612 | .unused, |
| | 7613 | .unused, |
| | 7614 | .unused, |
| | 7615 | .unused, |
| | 7616 | .unused, |
| | 7617 | .unused, |
| | 7618 | .unused, |
| | 7619 | .unused, |
| | 7620 | }, |
| | 7621 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7622 | .each = .{ .once = &.{ |
| | 7623 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7624 | .{ ._, .vp_d, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7625 | .{ ._, .vp_d, .minu, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 7626 | } }, |
| | 7627 | }, .{ |
| | 7628 | .required_features = .{ .avx, null, null, null }, |
| | 7629 | .src_constraints = .{ |
| | 7630 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 7631 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 7632 | .any, |
| | 7633 | }, |
| | 7634 | .patterns = &.{ |
| | 7635 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7636 | }, |
| | 7637 | .extra_temps = .{ |
| | 7638 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7639 | .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7640 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7641 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7642 | .unused, |
| | 7643 | .unused, |
| | 7644 | .unused, |
| | 7645 | .unused, |
| | 7646 | .unused, |
| | 7647 | .unused, |
| | 7648 | .unused, |
| | 7649 | }, |
| | 7650 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7651 | .each = .{ .once = &.{ |
| | 7652 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7653 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 7654 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7655 | .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .src0x, ._ }, |
| | 7656 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .src0x, ._ }, |
| | 7657 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ }, |
| | 7658 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ }, |
| | 7659 | .{ ._, .v_pd, .blendv, .dst0x, .tmp2x, .dst0x, .tmp3x }, |
| | 7660 | } }, |
| | 7661 | }, .{ |
| | 7662 | .required_features = .{ .sse4_2, null, null, null }, |
| | 7663 | .src_constraints = .{ |
| | 7664 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 7665 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 7666 | .any, |
| | 7667 | }, |
| | 7668 | .patterns = &.{ |
| | 7669 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7670 | }, |
| | 7671 | .extra_temps = .{ |
| | 7672 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7673 | .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 7674 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7675 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 7676 | .unused, |
| | 7677 | .unused, |
| | 7678 | .unused, |
| | 7679 | .unused, |
| | 7680 | .unused, |
| | 7681 | .unused, |
| | 7682 | .unused, |
| | 7683 | }, |
| | 7684 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7685 | .each = .{ .once = &.{ |
| | 7686 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7687 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| | 7688 | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| | 7689 | .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ }, |
| | 7690 | .{ ._, .p_q, .cmpgt, .tmp2x, .src0x, ._, ._ }, |
| | 7691 | .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ }, |
| | 7692 | .{ ._, .p_q, .cmpgt, .tmp3x, .dst0x, ._, ._ }, |
| | 7693 | .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 7694 | .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ }, |
| | 7695 | .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 7696 | } }, |
| | 7697 | }, .{ |
| | 7698 | .required_features = .{ .avx2, null, null, null }, |
| | 7699 | .src_constraints = .{ |
| | 7700 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 7701 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 7702 | .any, |
| | 7703 | }, |
| | 7704 | .patterns = &.{ |
| | 7705 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7706 | }, |
| | 7707 | .extra_temps = .{ |
| | 7708 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7709 | .{ .type = .vector_4_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 7710 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 7711 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 7712 | .unused, |
| | 7713 | .unused, |
| | 7714 | .unused, |
| | 7715 | .unused, |
| | 7716 | .unused, |
| | 7717 | .unused, |
| | 7718 | .unused, |
| | 7719 | }, |
| | 7720 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 7721 | .each = .{ .once = &.{ |
| | 7722 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7723 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 7724 | .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7725 | .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .src0y, ._ }, |
| | 7726 | .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .src0y, ._ }, |
| | 7727 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ }, |
| | 7728 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ }, |
| | 7729 | .{ ._, .v_pd, .blendv, .dst0y, .tmp2y, .dst0y, .tmp3y }, |
| | 7730 | } }, |
| | 7731 | }, .{ |
| | 7732 | .required_features = .{ .avx2, null, null, null }, |
| | 7733 | .src_constraints = .{ |
| | 7734 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 7735 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 7736 | .any, |
| | 7737 | }, |
| | 7738 | .patterns = &.{ |
| | 7739 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7740 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7741 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7742 | }, |
| | 7743 | .extra_temps = .{ |
| | 7744 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7745 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7746 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7747 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7748 | .unused, |
| | 7749 | .unused, |
| | 7750 | .unused, |
| | 7751 | .unused, |
| | 7752 | .unused, |
| | 7753 | .unused, |
| | 7754 | .unused, |
| | 7755 | }, |
| | 7756 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7757 | .each = .{ .once = &.{ |
| | 7758 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7759 | .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 7760 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7761 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ }, |
| | 7762 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 7763 | .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| | 7764 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 7765 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, |
| | 7766 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 7767 | } }, |
| | 7768 | }, .{ |
| | 7769 | .required_features = .{ .avx, null, null, null }, |
| | 7770 | .src_constraints = .{ |
| | 7771 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 7772 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 7773 | .any, |
| | 7774 | }, |
| | 7775 | .patterns = &.{ |
| | 7776 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7777 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7778 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7779 | }, |
| | 7780 | .extra_temps = .{ |
| | 7781 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7782 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7783 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7784 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7785 | .unused, |
| | 7786 | .unused, |
| | 7787 | .unused, |
| | 7788 | .unused, |
| | 7789 | .unused, |
| | 7790 | .unused, |
| | 7791 | .unused, |
| | 7792 | }, |
| | 7793 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7794 | .each = .{ .once = &.{ |
| | 7795 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7796 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 7797 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7798 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ }, |
| | 7799 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 7800 | .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| | 7801 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 7802 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, |
| | 7803 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 7804 | } }, |
| | 7805 | }, .{ |
| | 7806 | .required_features = .{ .sse4_2, null, null, null }, |
| | 7807 | .src_constraints = .{ |
| | 7808 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 7809 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 7810 | .any, |
| | 7811 | }, |
| | 7812 | .patterns = &.{ |
| | 7813 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7814 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7815 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7816 | }, |
| | 7817 | .extra_temps = .{ |
| | 7818 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7819 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7820 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7821 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 7822 | .unused, |
| | 7823 | .unused, |
| | 7824 | .unused, |
| | 7825 | .unused, |
| | 7826 | .unused, |
| | 7827 | .unused, |
| | 7828 | .unused, |
| | 7829 | }, |
| | 7830 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7831 | .each = .{ .once = &.{ |
| | 7832 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7833 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 7834 | .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ }, |
| | 7835 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| | 7836 | .{ ._, .p_q, .cmpgt, .tmp3x, .dst0x, ._, ._ }, |
| | 7837 | .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 7838 | .{ ._, .p_q, .cmpeq, .tmp3x, .tmp3x, ._, ._ }, |
| | 7839 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 7840 | .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ }, |
| | 7841 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| | 7842 | .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 7843 | } }, |
| | 7844 | }, .{ |
| | 7845 | .required_features = .{ .avx2, null, null, null }, |
| | 7846 | .src_constraints = .{ |
| | 7847 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 7848 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 7849 | .any, |
| | 7850 | }, |
| | 7851 | .patterns = &.{ |
| | 7852 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7853 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7854 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7855 | }, |
| | 7856 | .extra_temps = .{ |
| | 7857 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7858 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7859 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 7860 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 7861 | .unused, |
| | 7862 | .unused, |
| | 7863 | .unused, |
| | 7864 | .unused, |
| | 7865 | .unused, |
| | 7866 | .unused, |
| | 7867 | .unused, |
| | 7868 | }, |
| | 7869 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7870 | .each = .{ .once = &.{ |
| | 7871 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7872 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 7873 | .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 7874 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .dst0y, ._ }, |
| | 7875 | .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 7876 | .{ ._, .vp_q, .cmpeq, .tmp3y, .tmp3y, .tmp3y, ._ }, |
| | 7877 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 7878 | .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .tmp2y, ._ }, |
| | 7879 | .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 7880 | } }, |
| | 7881 | }, .{ |
| | 7882 | .required_features = .{ .avx2, null, null, null }, |
| | 7883 | .src_constraints = .{ |
| | 7884 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 7885 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 7886 | .any, |
| | 7887 | }, |
| | 7888 | .patterns = &.{ |
| | 7889 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7890 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7891 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7892 | }, |
| | 7893 | .extra_temps = .{ |
| | 7894 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7895 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7896 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7897 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7898 | .unused, |
| | 7899 | .unused, |
| | 7900 | .unused, |
| | 7901 | .unused, |
| | 7902 | .unused, |
| | 7903 | .unused, |
| | 7904 | .unused, |
| | 7905 | }, |
| | 7906 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7907 | .each = .{ .once = &.{ |
| | 7908 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7909 | .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 7910 | .{ ._, .vp_, .xor, .tmp3x, .src0x, .tmp2x, ._ }, |
| | 7911 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7912 | .{ ._, .vp_, .xor, .tmp2x, .dst0x, .tmp2x, ._ }, |
| | 7913 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| | 7914 | .{ ._, .vp_, .@"or", .dst0x, .dst0x, .tmp3x, ._ }, |
| | 7915 | } }, |
| | 7916 | }, .{ |
| | 7917 | .required_features = .{ .avx, null, null, null }, |
| | 7918 | .src_constraints = .{ |
| | 7919 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 7920 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 7921 | .any, |
| | 7922 | }, |
| | 7923 | .patterns = &.{ |
| | 7924 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7925 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7926 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7927 | }, |
| | 7928 | .extra_temps = .{ |
| | 7929 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7930 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7931 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7932 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7933 | .unused, |
| | 7934 | .unused, |
| | 7935 | .unused, |
| | 7936 | .unused, |
| | 7937 | .unused, |
| | 7938 | .unused, |
| | 7939 | .unused, |
| | 7940 | }, |
| | 7941 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 7942 | .each = .{ .once = &.{ |
| | 7943 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7944 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 7945 | .{ ._, .vp_, .xor, .tmp3x, .src0x, .tmp2x, ._ }, |
| | 7946 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 7947 | .{ ._, .vp_, .xor, .tmp2x, .dst0x, .tmp2x, ._ }, |
| | 7948 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| | 7949 | .{ ._, .vp_, .@"or", .dst0x, .dst0x, .tmp3x, ._ }, |
| | 7950 | } }, |
| | 7951 | }, .{ |
| | 7952 | .required_features = .{ .sse4_2, null, null, null }, |
| | 7953 | .src_constraints = .{ |
| | 7954 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 7955 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 7956 | .any, |
| | 7957 | }, |
| | 7958 | .patterns = &.{ |
| | 7959 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 7960 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7961 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 7962 | }, |
| | 7963 | .extra_temps = .{ |
| | 7964 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 7965 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 7966 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7967 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 7968 | .unused, |
| | 7969 | .unused, |
| | 7970 | .unused, |
| | 7971 | .unused, |
| | 7972 | .unused, |
| | 7973 | .unused, |
| | 7974 | .unused, |
| | 7975 | }, |
| | 7976 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 7977 | .each = .{ .once = &.{ |
| | 7978 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 7979 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 7980 | .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ }, |
| | 7981 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| | 7982 | .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ }, |
| | 7983 | .{ ._, .p_, .xor, .tmp2x, .dst0x, ._, ._ }, |
| | 7984 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| | 7985 | .{ ._, .p_, .@"or", .dst0x, .tmp3x, ._, ._ }, |
| | 7986 | } }, |
| | 7987 | }, .{ |
| | 7988 | .required_features = .{ .avx2, null, null, null }, |
| | 7989 | .src_constraints = .{ |
| | 7990 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 7991 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 7992 | .any, |
| | 7993 | }, |
| | 7994 | .patterns = &.{ |
| | 7995 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 7996 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 7997 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 7998 | }, |
| | 7999 | .extra_temps = .{ |
| | 8000 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8001 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 8002 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 8003 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 8004 | .unused, |
| | 8005 | .unused, |
| | 8006 | .unused, |
| | 8007 | .unused, |
| | 8008 | .unused, |
| | 8009 | .unused, |
| | 8010 | .unused, |
| | 8011 | }, |
| | 8012 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8013 | .each = .{ .once = &.{ |
| | 8014 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8015 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 8016 | .{ ._, .vp_, .xor, .tmp3y, .src0y, .tmp2y, ._ }, |
| | 8017 | .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 8018 | .{ ._, .vp_, .xor, .tmp2y, .dst0y, .tmp2y, ._ }, |
| | 8019 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| | 8020 | .{ ._, .vp_, .@"or", .dst0y, .dst0y, .tmp3y, ._ }, |
| | 8021 | } }, |
| | 8022 | }, .{ |
| | 8023 | .required_features = .{ .avx2, null, null, null }, |
| | 8024 | .src_constraints = .{ |
| | 8025 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 8026 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 8027 | .any, |
| | 8028 | }, |
| | 8029 | .patterns = &.{ |
| | 8030 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 8031 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8032 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 8033 | }, |
| | 8034 | .extra_temps = .{ |
| | 8035 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8036 | .{ .type = .vector_2_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 8037 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8038 | .unused, |
| | 8039 | .unused, |
| | 8040 | .unused, |
| | 8041 | .unused, |
| | 8042 | .unused, |
| | 8043 | .unused, |
| | 8044 | .unused, |
| | 8045 | .unused, |
| | 8046 | }, |
| | 8047 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8048 | .each = .{ .once = &.{ |
| | 8049 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8050 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 8051 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 8052 | .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .dst0x, ._ }, |
| | 8053 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .lea(.tmp0x), .tmp2x }, |
| | 8054 | } }, |
| | 8055 | }, .{ |
| | 8056 | .required_features = .{ .avx, null, null, null }, |
| | 8057 | .src_constraints = .{ |
| | 8058 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 8059 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 8060 | .any, |
| | 8061 | }, |
| | 8062 | .patterns = &.{ |
| | 8063 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 8064 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8065 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 8066 | }, |
| | 8067 | .extra_temps = .{ |
| | 8068 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8069 | .{ .type = .vector_2_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 8070 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8071 | .unused, |
| | 8072 | .unused, |
| | 8073 | .unused, |
| | 8074 | .unused, |
| | 8075 | .unused, |
| | 8076 | .unused, |
| | 8077 | .unused, |
| | 8078 | .unused, |
| | 8079 | }, |
| | 8080 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8081 | .each = .{ .once = &.{ |
| | 8082 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8083 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 8084 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 8085 | .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .dst0x, ._ }, |
| | 8086 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .lea(.tmp0x), .tmp2x }, |
| | 8087 | } }, |
| | 8088 | }, .{ |
| | 8089 | .required_features = .{ .sse4_2, null, null, null }, |
| | 8090 | .src_constraints = .{ |
| | 8091 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 8092 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 8093 | .any, |
| | 8094 | }, |
| | 8095 | .patterns = &.{ |
| | 8096 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 8097 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8098 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 8099 | }, |
| | 8100 | .extra_temps = .{ |
| | 8101 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8102 | .{ .type = .vector_2_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 8103 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| | 8104 | .unused, |
| | 8105 | .unused, |
| | 8106 | .unused, |
| | 8107 | .unused, |
| | 8108 | .unused, |
| | 8109 | .unused, |
| | 8110 | .unused, |
| | 8111 | .unused, |
| | 8112 | }, |
| | 8113 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 8114 | .each = .{ .once = &.{ |
| | 8115 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8116 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| | 8117 | .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ }, |
| | 8118 | .{ ._, .p_q, .cmpgt, .tmp2x, .dst0x, ._, ._ }, |
| | 8119 | .{ ._, .p_b, .blendv, .dst0x, .lea(.tmp0x), .tmp2x, ._ }, |
| | 8120 | } }, |
| | 8121 | }, .{ |
| | 8122 | .required_features = .{ .avx2, null, null, null }, |
| | 8123 | .src_constraints = .{ |
| | 8124 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } }, |
| | 8125 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } }, |
| | 8126 | .any, |
| | 8127 | }, |
| | 8128 | .patterns = &.{ |
| | 8129 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 8130 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8131 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 8132 | }, |
| | 8133 | .extra_temps = .{ |
| | 8134 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8135 | .{ .type = .vector_4_u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 8136 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 8137 | .unused, |
| | 8138 | .unused, |
| | 8139 | .unused, |
| | 8140 | .unused, |
| | 8141 | .unused, |
| | 8142 | .unused, |
| | 8143 | .unused, |
| | 8144 | .unused, |
| | 8145 | }, |
| | 8146 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8147 | .each = .{ .once = &.{ |
| | 8148 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8149 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 8150 | .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 8151 | .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .dst0y, ._ }, |
| | 8152 | .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .lea(.tmp0y), .tmp2y }, |
| | 8153 | } }, |
| | 8154 | }, .{ |
| | 8155 | .required_features = .{ .avx2, null, null, null }, |
| | 8156 | .src_constraints = .{ |
| | 8157 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 8158 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 8159 | .any, |
| | 8160 | }, |
| | 8161 | .patterns = &.{ |
| | 8162 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 8163 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8164 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 8165 | }, |
| | 8166 | .extra_temps = .{ |
| | 8167 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8168 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 8169 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8170 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8171 | .unused, |
| | 8172 | .unused, |
| | 8173 | .unused, |
| | 8174 | .unused, |
| | 8175 | .unused, |
| | 8176 | .unused, |
| | 8177 | .unused, |
| | 8178 | }, |
| | 8179 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8180 | .each = .{ .once = &.{ |
| | 8181 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8182 | .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 8183 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 8184 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, |
| | 8185 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 8186 | } }, |
| | 8187 | }, .{ |
| | 8188 | .required_features = .{ .avx, null, null, null }, |
| | 8189 | .src_constraints = .{ |
| | 8190 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 8191 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 8192 | .any, |
| | 8193 | }, |
| | 8194 | .patterns = &.{ |
| | 8195 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 8196 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8197 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 8198 | }, |
| | 8199 | .extra_temps = .{ |
| | 8200 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8201 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 8202 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8203 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8204 | .unused, |
| | 8205 | .unused, |
| | 8206 | .unused, |
| | 8207 | .unused, |
| | 8208 | .unused, |
| | 8209 | .unused, |
| | 8210 | .unused, |
| | 8211 | }, |
| | 8212 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8213 | .each = .{ .once = &.{ |
| | 8214 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8215 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 8216 | .{ ._, .vp_q, .add, .dst0x, .src0x, .src1x, ._ }, |
| | 8217 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, |
| | 8218 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 8219 | } }, |
| | 8220 | }, .{ |
| | 8221 | .required_features = .{ .sse4_2, null, null, null }, |
| | 8222 | .src_constraints = .{ |
| | 8223 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 8224 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 8225 | .any, |
| | 8226 | }, |
| | 8227 | .patterns = &.{ |
| | 8228 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 8229 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8230 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 8231 | }, |
| | 8232 | .extra_temps = .{ |
| | 8233 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8234 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 8235 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 8236 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| | 8237 | .unused, |
| | 8238 | .unused, |
| | 8239 | .unused, |
| | 8240 | .unused, |
| | 8241 | .unused, |
| | 8242 | .unused, |
| | 8243 | .unused, |
| | 8244 | }, |
| | 8245 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 8246 | .each = .{ .once = &.{ |
| | 8247 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8248 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 8249 | .{ ._, .p_q, .add, .dst0x, .src1x, ._, ._ }, |
| | 8250 | .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ }, |
| | 8251 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| | 8252 | .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 8253 | } }, |
| | 8254 | }, .{ |
| | 8255 | .required_features = .{ .avx2, null, null, null }, |
| | 8256 | .src_constraints = .{ |
| | 8257 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 8258 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 8259 | .any, |
| | 8260 | }, |
| | 8261 | .patterns = &.{ |
| | 8262 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 8263 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| | 8264 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 8265 | }, |
| | 8266 | .extra_temps = .{ |
| | 8267 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 8268 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 8269 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 8270 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 8271 | .unused, |
| | 8272 | .unused, |
| | 8273 | .unused, |
| | 8274 | .unused, |
| | 8275 | .unused, |
| | 8276 | .unused, |
| | 8277 | .unused, |
| | 8278 | }, |
| | 8279 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 8280 | .each = .{ .once = &.{ |
| | 8281 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8282 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 8283 | .{ ._, .vp_q, .add, .dst0y, .src0y, .src1y, ._ }, |
| | 8284 | .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .tmp2y, ._ }, |
| | 8285 | .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 8286 | } }, |
| | 8287 | }, .{ |
| | 8288 | .required_features = .{ .avx2, null, null, null }, |
| | 8289 | .src_constraints = .{ |
| | 8290 | .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 8291 | .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 8292 | .any, |
| | 8293 | }, |
| | 8294 | .patterns = &.{ |
| | 8295 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8296 | }, |
| | 8297 | .extra_temps = .{ |
| | 8298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8299 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 8300 | .unused, |
| | 8301 | .unused, |
| | 8302 | .unused, |
| | 8303 | .unused, |
| | 8304 | .unused, |
| | 8305 | .unused, |
| | 8306 | .unused, |
| | 8307 | .unused, |
| | 8308 | .unused, |
| | 8309 | }, |
| | 8310 | .dst_temps = .{ .mem, .unused }, |
| | 8311 | .clobbers = .{ .eflags = true }, |
| | 8312 | .each = .{ .once = &.{ |
| | 8313 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8314 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8315 | .{ ._, .vp_, .@"or", .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 8316 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 8317 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 8318 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8319 | } }, |
| | 8320 | }, .{ |
| | 8321 | .required_features = .{ .avx, null, null, null }, |
| | 8322 | .src_constraints = .{ |
| | 8323 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 8324 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 8325 | .any, |
| | 8326 | }, |
| | 8327 | .patterns = &.{ |
| | 8328 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8329 | }, |
| | 8330 | .extra_temps = .{ |
| | 8331 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8332 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 8333 | .unused, |
| | 8334 | .unused, |
| | 8335 | .unused, |
| | 8336 | .unused, |
| | 8337 | .unused, |
| | 8338 | .unused, |
| | 8339 | .unused, |
| | 8340 | .unused, |
| | 8341 | .unused, |
| | 8342 | }, |
| | 8343 | .dst_temps = .{ .mem, .unused }, |
| | 8344 | .clobbers = .{ .eflags = true }, |
| | 8345 | .each = .{ .once = &.{ |
| | 8346 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8347 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8348 | .{ ._, .vp_, .@"or", .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 8349 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 8350 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8351 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8352 | } }, |
| | 8353 | }, .{ |
| | 8354 | .required_features = .{ .sse2, null, null, null }, |
| | 8355 | .src_constraints = .{ |
| | 8356 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 8357 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 8358 | .any, |
| | 8359 | }, |
| | 8360 | .patterns = &.{ |
| | 8361 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8362 | }, |
| | 8363 | .extra_temps = .{ |
| | 8364 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8365 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 8366 | .unused, |
| | 8367 | .unused, |
| | 8368 | .unused, |
| | 8369 | .unused, |
| | 8370 | .unused, |
| | 8371 | .unused, |
| | 8372 | .unused, |
| | 8373 | .unused, |
| | 8374 | .unused, |
| | 8375 | }, |
| | 8376 | .dst_temps = .{ .mem, .unused }, |
| | 8377 | .clobbers = .{ .eflags = true }, |
| | 8378 | .each = .{ .once = &.{ |
| | 8379 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8380 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8381 | .{ ._, .p_, .@"or", .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8382 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 8383 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8384 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8385 | } }, |
| | 8386 | }, .{ |
| | 8387 | .required_features = .{ .sse, null, null, null }, |
| | 8388 | .src_constraints = .{ |
| | 8389 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 8390 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 8391 | .any, |
| | 8392 | }, |
| | 8393 | .patterns = &.{ |
| | 8394 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8395 | }, |
| | 8396 | .extra_temps = .{ |
| | 8397 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8398 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 8399 | .unused, |
| | 8400 | .unused, |
| | 8401 | .unused, |
| | 8402 | .unused, |
| | 8403 | .unused, |
| | 8404 | .unused, |
| | 8405 | .unused, |
| | 8406 | .unused, |
| | 8407 | .unused, |
| | 8408 | }, |
| | 8409 | .dst_temps = .{ .mem, .unused }, |
| | 8410 | .clobbers = .{ .eflags = true }, |
| | 8411 | .each = .{ .once = &.{ |
| | 8412 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8413 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8414 | .{ ._, ._ps, .@"or", .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8415 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 8416 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8417 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8418 | } }, |
| | 8419 | }, .{ |
| | 8420 | .required_features = .{ .mmx, null, null, null }, |
| | 8421 | .src_constraints = .{ |
| | 8422 | .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 8423 | .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 8424 | .any, |
| | 8425 | }, |
| | 8426 | .patterns = &.{ |
| | 8427 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8428 | }, |
| | 8429 | .extra_temps = .{ |
| | 8430 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8431 | .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } }, |
| | 8432 | .unused, |
| | 8433 | .unused, |
| | 8434 | .unused, |
| | 8435 | .unused, |
| | 8436 | .unused, |
| | 8437 | .unused, |
| | 8438 | .unused, |
| | 8439 | .unused, |
| | 8440 | .unused, |
| | 8441 | }, |
| | 8442 | .dst_temps = .{ .mem, .unused }, |
| | 8443 | .clobbers = .{ .eflags = true }, |
| | 8444 | .each = .{ .once = &.{ |
| | 8445 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8446 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8447 | .{ ._, .p_, .@"or", .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8448 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 8449 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 8450 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8451 | } }, |
| | 8452 | }, .{ |
| | 8453 | .required_features = .{ .avx2, null, null, null }, |
| | 8454 | .src_constraints = .{ |
| | 8455 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 8456 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 8457 | .any, |
| | 8458 | }, |
| | 8459 | .patterns = &.{ |
| | 8460 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8461 | }, |
| | 8462 | .extra_temps = .{ |
| | 8463 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8464 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 8465 | .unused, |
| | 8466 | .unused, |
| | 8467 | .unused, |
| | 8468 | .unused, |
| | 8469 | .unused, |
| | 8470 | .unused, |
| | 8471 | .unused, |
| | 8472 | .unused, |
| | 8473 | .unused, |
| | 8474 | }, |
| | 8475 | .dst_temps = .{ .mem, .unused }, |
| | 8476 | .clobbers = .{ .eflags = true }, |
| | 8477 | .each = .{ .once = &.{ |
| | 8478 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8479 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8480 | .{ ._, .vp_b, .adds, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 8481 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 8482 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 8483 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8484 | } }, |
| | 8485 | }, .{ |
| | 8486 | .required_features = .{ .avx, null, null, null }, |
| | 8487 | .src_constraints = .{ |
| | 8488 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 8489 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 8490 | .any, |
| | 8491 | }, |
| | 8492 | .patterns = &.{ |
| | 8493 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8494 | }, |
| | 8495 | .extra_temps = .{ |
| | 8496 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8497 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8498 | .unused, |
| | 8499 | .unused, |
| | 8500 | .unused, |
| | 8501 | .unused, |
| | 8502 | .unused, |
| | 8503 | .unused, |
| | 8504 | .unused, |
| | 8505 | .unused, |
| | 8506 | .unused, |
| | 8507 | }, |
| | 8508 | .dst_temps = .{ .mem, .unused }, |
| | 8509 | .clobbers = .{ .eflags = true }, |
| | 8510 | .each = .{ .once = &.{ |
| | 8511 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8512 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8513 | .{ ._, .vp_b, .adds, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 8514 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 8515 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8516 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8517 | } }, |
| | 8518 | }, .{ |
| | 8519 | .required_features = .{ .sse2, null, null, null }, |
| | 8520 | .src_constraints = .{ |
| | 8521 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 8522 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 8523 | .any, |
| | 8524 | }, |
| | 8525 | .patterns = &.{ |
| | 8526 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8527 | }, |
| | 8528 | .extra_temps = .{ |
| | 8529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8530 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8531 | .unused, |
| | 8532 | .unused, |
| | 8533 | .unused, |
| | 8534 | .unused, |
| | 8535 | .unused, |
| | 8536 | .unused, |
| | 8537 | .unused, |
| | 8538 | .unused, |
| | 8539 | .unused, |
| | 8540 | }, |
| | 8541 | .dst_temps = .{ .mem, .unused }, |
| | 8542 | .clobbers = .{ .eflags = true }, |
| | 8543 | .each = .{ .once = &.{ |
| | 8544 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8545 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8546 | .{ ._, .p_b, .adds, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8547 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 8548 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8549 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8550 | } }, |
| | 8551 | }, .{ |
| | 8552 | .required_features = .{ .mmx, null, null, null }, |
| | 8553 | .src_constraints = .{ |
| | 8554 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 8555 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 8556 | .any, |
| | 8557 | }, |
| | 8558 | .patterns = &.{ |
| | 8559 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8560 | }, |
| | 8561 | .extra_temps = .{ |
| | 8562 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8563 | .{ .type = .vector_8_i8, .kind = .{ .rc = .mmx } }, |
| | 8564 | .unused, |
| | 8565 | .unused, |
| | 8566 | .unused, |
| | 8567 | .unused, |
| | 8568 | .unused, |
| | 8569 | .unused, |
| | 8570 | .unused, |
| | 8571 | .unused, |
| | 8572 | .unused, |
| | 8573 | }, |
| | 8574 | .dst_temps = .{ .mem, .unused }, |
| | 8575 | .clobbers = .{ .eflags = true }, |
| | 8576 | .each = .{ .once = &.{ |
| | 8577 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8578 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8579 | .{ ._, .p_b, .adds, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8580 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 8581 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 8582 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8583 | } }, |
| | 8584 | }, .{ |
| | 8585 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| | 8586 | .src_constraints = .{ |
| | 8587 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8588 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8589 | .any, |
| | 8590 | }, |
| | 8591 | .patterns = &.{ |
| | 8592 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8593 | }, |
| | 8594 | .extra_temps = .{ |
| | 8595 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8596 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8597 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8598 | .unused, |
| | 8599 | .unused, |
| | 8600 | .unused, |
| | 8601 | .unused, |
| | 8602 | .unused, |
| | 8603 | .unused, |
| | 8604 | .unused, |
| | 8605 | .unused, |
| | 8606 | }, |
| | 8607 | .dst_temps = .{ .mem, .unused }, |
| | 8608 | .clobbers = .{ .eflags = true }, |
| | 8609 | .each = .{ .once = &.{ |
| | 8610 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8611 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8612 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 8613 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 8614 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 8615 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8616 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 8617 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8618 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 8619 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8620 | } }, |
| | 8621 | }, .{ |
| | 8622 | .required_features = .{ .cmov, null, null, null }, |
| | 8623 | .src_constraints = .{ |
| | 8624 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8625 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8626 | .any, |
| | 8627 | }, |
| | 8628 | .patterns = &.{ |
| | 8629 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8630 | }, |
| | 8631 | .extra_temps = .{ |
| | 8632 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8633 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8634 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8635 | .unused, |
| | 8636 | .unused, |
| | 8637 | .unused, |
| | 8638 | .unused, |
| | 8639 | .unused, |
| | 8640 | .unused, |
| | 8641 | .unused, |
| | 8642 | .unused, |
| | 8643 | }, |
| | 8644 | .dst_temps = .{ .mem, .unused }, |
| | 8645 | .clobbers = .{ .eflags = true }, |
| | 8646 | .each = .{ .once = &.{ |
| | 8647 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8648 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8649 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 8650 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 8651 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 8652 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8653 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 8654 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8655 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 8656 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 8657 | } }, |
| | 8658 | }, .{ |
| | 8659 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 8660 | .src_constraints = .{ |
| | 8661 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8662 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8663 | .any, |
| | 8664 | }, |
| | 8665 | .patterns = &.{ |
| | 8666 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8667 | }, |
| | 8668 | .extra_temps = .{ |
| | 8669 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8670 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8671 | .unused, |
| | 8672 | .unused, |
| | 8673 | .unused, |
| | 8674 | .unused, |
| | 8675 | .unused, |
| | 8676 | .unused, |
| | 8677 | .unused, |
| | 8678 | .unused, |
| | 8679 | .unused, |
| | 8680 | }, |
| | 8681 | .dst_temps = .{ .mem, .unused }, |
| | 8682 | .clobbers = .{ .eflags = true }, |
| | 8683 | .each = .{ .once = &.{ |
| | 8684 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8685 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8686 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8687 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 8688 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 8689 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ }, |
| | 8690 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8691 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 8692 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8693 | } }, |
| | 8694 | }, .{ |
| | 8695 | .src_constraints = .{ |
| | 8696 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8697 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 8698 | .any, |
| | 8699 | }, |
| | 8700 | .patterns = &.{ |
| | 8701 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8702 | }, |
| | 8703 | .extra_temps = .{ |
| | 8704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8705 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8706 | .unused, |
| | 8707 | .unused, |
| | 8708 | .unused, |
| | 8709 | .unused, |
| | 8710 | .unused, |
| | 8711 | .unused, |
| | 8712 | .unused, |
| | 8713 | .unused, |
| | 8714 | .unused, |
| | 8715 | }, |
| | 8716 | .dst_temps = .{ .mem, .unused }, |
| | 8717 | .clobbers = .{ .eflags = true }, |
| | 8718 | .each = .{ .once = &.{ |
| | 8719 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8720 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8721 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8722 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 8723 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 8724 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ }, |
| | 8725 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8726 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 8727 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 8728 | } }, |
| | 8729 | }, .{ |
| | 8730 | .required_features = .{ .avx2, null, null, null }, |
| | 8731 | .src_constraints = .{ |
| | 8732 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 8733 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 8734 | .any, |
| | 8735 | }, |
| | 8736 | .patterns = &.{ |
| | 8737 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8738 | }, |
| | 8739 | .extra_temps = .{ |
| | 8740 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8741 | .{ .type = .i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 8742 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 8743 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 8744 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 8745 | .unused, |
| | 8746 | .unused, |
| | 8747 | .unused, |
| | 8748 | .unused, |
| | 8749 | .unused, |
| | 8750 | .unused, |
| | 8751 | }, |
| | 8752 | .dst_temps = .{ .mem, .unused }, |
| | 8753 | .clobbers = .{ .eflags = true }, |
| | 8754 | .each = .{ .once = &.{ |
| | 8755 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8756 | .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 8757 | .{ ._, .vp_b, .broadcast, .tmp3y, .lea(.tmp0b), ._, ._ }, |
| | 8758 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 8759 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8760 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8761 | .{ ._, .vp_b, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 8762 | .{ ._, .vp_b, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 8763 | .{ ._, .vp_b, .mins, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 8764 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 8765 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 8766 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8767 | } }, |
| | 8768 | }, .{ |
| | 8769 | .required_features = .{ .avx, null, null, null }, |
| | 8770 | .src_constraints = .{ |
| | 8771 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 8772 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 8773 | .any, |
| | 8774 | }, |
| | 8775 | .patterns = &.{ |
| | 8776 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8777 | }, |
| | 8778 | .extra_temps = .{ |
| | 8779 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8780 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 8781 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8782 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8783 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8784 | .unused, |
| | 8785 | .unused, |
| | 8786 | .unused, |
| | 8787 | .unused, |
| | 8788 | .unused, |
| | 8789 | .unused, |
| | 8790 | }, |
| | 8791 | .dst_temps = .{ .mem, .unused }, |
| | 8792 | .clobbers = .{ .eflags = true }, |
| | 8793 | .each = .{ .once = &.{ |
| | 8794 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8795 | .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 8796 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 8797 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 8798 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8799 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8800 | .{ ._, .vp_b, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 8801 | .{ ._, .vp_b, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 8802 | .{ ._, .vp_b, .mins, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 8803 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 8804 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8805 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8806 | } }, |
| | 8807 | }, .{ |
| | 8808 | .required_features = .{ .sse4_1, null, null, null }, |
| | 8809 | .src_constraints = .{ |
| | 8810 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 8811 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 8812 | .any, |
| | 8813 | }, |
| | 8814 | .patterns = &.{ |
| | 8815 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8816 | }, |
| | 8817 | .extra_temps = .{ |
| | 8818 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8819 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 8820 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8821 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8822 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8823 | .unused, |
| | 8824 | .unused, |
| | 8825 | .unused, |
| | 8826 | .unused, |
| | 8827 | .unused, |
| | 8828 | .unused, |
| | 8829 | }, |
| | 8830 | .dst_temps = .{ .mem, .unused }, |
| | 8831 | .clobbers = .{ .eflags = true }, |
| | 8832 | .each = .{ .once = &.{ |
| | 8833 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8834 | .{ ._, .p_b, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 8835 | .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 8836 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 8837 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8838 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8839 | .{ ._, .p_b, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8840 | .{ ._, .p_b, .maxs, .tmp4x, .tmp3x, ._, ._ }, |
| | 8841 | .{ ._, .p_b, .mins, .tmp4x, .tmp2x, ._, ._ }, |
| | 8842 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 8843 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8844 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8845 | } }, |
| | 8846 | }, .{ |
| | 8847 | .required_features = .{ .sse2, null, null, null }, |
| | 8848 | .src_constraints = .{ |
| | 8849 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 8850 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 8851 | .any, |
| | 8852 | }, |
| | 8853 | .patterns = &.{ |
| | 8854 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8855 | }, |
| | 8856 | .extra_temps = .{ |
| | 8857 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8858 | .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 8859 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8860 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 8861 | .unused, |
| | 8862 | .unused, |
| | 8863 | .unused, |
| | 8864 | .unused, |
| | 8865 | .unused, |
| | 8866 | .unused, |
| | 8867 | .unused, |
| | 8868 | }, |
| | 8869 | .dst_temps = .{ .mem, .unused }, |
| | 8870 | .clobbers = .{ .eflags = true }, |
| | 8871 | .each = .{ .once = &.{ |
| | 8872 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 8873 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 8874 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8875 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8876 | .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ }, |
| | 8877 | .{ ._, .p_b, .adds, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8878 | .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ }, |
| | 8879 | .{ ._, .p_b, .adds, .tmp3x, .tmp2x, ._, ._ }, |
| | 8880 | .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ }, |
| | 8881 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 8882 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 8883 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8884 | } }, |
| | 8885 | }, .{ |
| | 8886 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| | 8887 | .src_constraints = .{ |
| | 8888 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 8889 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 8890 | .any, |
| | 8891 | }, |
| | 8892 | .patterns = &.{ |
| | 8893 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8894 | }, |
| | 8895 | .extra_temps = .{ |
| | 8896 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8897 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8898 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8899 | .unused, |
| | 8900 | .unused, |
| | 8901 | .unused, |
| | 8902 | .unused, |
| | 8903 | .unused, |
| | 8904 | .unused, |
| | 8905 | .unused, |
| | 8906 | .unused, |
| | 8907 | }, |
| | 8908 | .dst_temps = .{ .mem, .unused }, |
| | 8909 | .clobbers = .{ .eflags = true }, |
| | 8910 | .each = .{ .once = &.{ |
| | 8911 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8912 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8913 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 8914 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 8915 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8916 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 8917 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 8918 | .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 8919 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8920 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 8921 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8922 | } }, |
| | 8923 | }, .{ |
| | 8924 | .required_features = .{ .cmov, null, null, null }, |
| | 8925 | .src_constraints = .{ |
| | 8926 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 8927 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 8928 | .any, |
| | 8929 | }, |
| | 8930 | .patterns = &.{ |
| | 8931 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8932 | }, |
| | 8933 | .extra_temps = .{ |
| | 8934 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8935 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8936 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8937 | .unused, |
| | 8938 | .unused, |
| | 8939 | .unused, |
| | 8940 | .unused, |
| | 8941 | .unused, |
| | 8942 | .unused, |
| | 8943 | .unused, |
| | 8944 | .unused, |
| | 8945 | }, |
| | 8946 | .dst_temps = .{ .mem, .unused }, |
| | 8947 | .clobbers = .{ .eflags = true }, |
| | 8948 | .each = .{ .once = &.{ |
| | 8949 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8950 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8951 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 8952 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 8953 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8954 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 8955 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 8956 | .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 8957 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8958 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 8959 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 8960 | } }, |
| | 8961 | }, .{ |
| | 8962 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 8963 | .src_constraints = .{ |
| | 8964 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 8965 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 8966 | .any, |
| | 8967 | }, |
| | 8968 | .patterns = &.{ |
| | 8969 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 8970 | }, |
| | 8971 | .extra_temps = .{ |
| | 8972 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 8973 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 8974 | .unused, |
| | 8975 | .unused, |
| | 8976 | .unused, |
| | 8977 | .unused, |
| | 8978 | .unused, |
| | 8979 | .unused, |
| | 8980 | .unused, |
| | 8981 | .unused, |
| | 8982 | .unused, |
| | 8983 | }, |
| | 8984 | .dst_temps = .{ .mem, .unused }, |
| | 8985 | .clobbers = .{ .eflags = true }, |
| | 8986 | .each = .{ .once = &.{ |
| | 8987 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 8988 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8989 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 8990 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 8991 | .{ ._, ._pe, .j, .@"1f", ._, ._, ._ }, |
| | 8992 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 8993 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ }, |
| | 8994 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 8995 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 8996 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 8997 | } }, |
| | 8998 | }, .{ |
| | 8999 | .src_constraints = .{ |
| | 9000 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 9001 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 9002 | .any, |
| | 9003 | }, |
| | 9004 | .patterns = &.{ |
| | 9005 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9006 | }, |
| | 9007 | .extra_temps = .{ |
| | 9008 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9009 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 9010 | .unused, |
| | 9011 | .unused, |
| | 9012 | .unused, |
| | 9013 | .unused, |
| | 9014 | .unused, |
| | 9015 | .unused, |
| | 9016 | .unused, |
| | 9017 | .unused, |
| | 9018 | .unused, |
| | 9019 | }, |
| | 9020 | .dst_temps = .{ .mem, .unused }, |
| | 9021 | .clobbers = .{ .eflags = true }, |
| | 9022 | .each = .{ .once = &.{ |
| | 9023 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9024 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9025 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9026 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 9027 | .{ ._, ._pe, .j, .@"1f", ._, ._, ._ }, |
| | 9028 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 9029 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ }, |
| | 9030 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 9031 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 9032 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 9033 | } }, |
| | 9034 | }, .{ |
| | 9035 | .required_features = .{ .avx2, null, null, null }, |
| | 9036 | .src_constraints = .{ |
| | 9037 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } }, |
| | 9038 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 8 } }, |
| | 9039 | .any, |
| | 9040 | }, |
| | 9041 | .patterns = &.{ |
| | 9042 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9043 | }, |
| | 9044 | .extra_temps = .{ |
| | 9045 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9046 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 9047 | .unused, |
| | 9048 | .unused, |
| | 9049 | .unused, |
| | 9050 | .unused, |
| | 9051 | .unused, |
| | 9052 | .unused, |
| | 9053 | .unused, |
| | 9054 | .unused, |
| | 9055 | .unused, |
| | 9056 | }, |
| | 9057 | .dst_temps = .{ .mem, .unused }, |
| | 9058 | .clobbers = .{ .eflags = true }, |
| | 9059 | .each = .{ .once = &.{ |
| | 9060 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9061 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9062 | .{ ._, .vp_b, .addus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 9063 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 9064 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 9065 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9066 | } }, |
| | 9067 | }, .{ |
| | 9068 | .required_features = .{ .avx, null, null, null }, |
| | 9069 | .src_constraints = .{ |
| | 9070 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 9071 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 9072 | .any, |
| | 9073 | }, |
| | 9074 | .patterns = &.{ |
| | 9075 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9076 | }, |
| | 9077 | .extra_temps = .{ |
| | 9078 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9079 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 9080 | .unused, |
| | 9081 | .unused, |
| | 9082 | .unused, |
| | 9083 | .unused, |
| | 9084 | .unused, |
| | 9085 | .unused, |
| | 9086 | .unused, |
| | 9087 | .unused, |
| | 9088 | .unused, |
| | 9089 | }, |
| | 9090 | .dst_temps = .{ .mem, .unused }, |
| | 9091 | .clobbers = .{ .eflags = true }, |
| | 9092 | .each = .{ .once = &.{ |
| | 9093 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9094 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9095 | .{ ._, .vp_b, .addus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 9096 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 9097 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9098 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9099 | } }, |
| | 9100 | }, .{ |
| | 9101 | .required_features = .{ .sse2, null, null, null }, |
| | 9102 | .src_constraints = .{ |
| | 9103 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 9104 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 8 } }, |
| | 9105 | .any, |
| | 9106 | }, |
| | 9107 | .patterns = &.{ |
| | 9108 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9109 | }, |
| | 9110 | .extra_temps = .{ |
| | 9111 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9112 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 9113 | .unused, |
| | 9114 | .unused, |
| | 9115 | .unused, |
| | 9116 | .unused, |
| | 9117 | .unused, |
| | 9118 | .unused, |
| | 9119 | .unused, |
| | 9120 | .unused, |
| | 9121 | .unused, |
| | 9122 | }, |
| | 9123 | .dst_temps = .{ .mem, .unused }, |
| | 9124 | .clobbers = .{ .eflags = true }, |
| | 9125 | .each = .{ .once = &.{ |
| | 9126 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9127 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9128 | .{ ._, .p_b, .addus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9129 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 9130 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9131 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9132 | } }, |
| | 9133 | }, .{ |
| | 9134 | .required_features = .{ .mmx, null, null, null }, |
| | 9135 | .src_constraints = .{ |
| | 9136 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } }, |
| | 9137 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 8 } }, |
| | 9138 | .any, |
| | 9139 | }, |
| | 9140 | .patterns = &.{ |
| | 9141 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9142 | }, |
| | 9143 | .extra_temps = .{ |
| | 9144 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9145 | .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } }, |
| | 9146 | .unused, |
| | 9147 | .unused, |
| | 9148 | .unused, |
| | 9149 | .unused, |
| | 9150 | .unused, |
| | 9151 | .unused, |
| | 9152 | .unused, |
| | 9153 | .unused, |
| | 9154 | .unused, |
| | 9155 | }, |
| | 9156 | .dst_temps = .{ .mem, .unused }, |
| | 9157 | .clobbers = .{ .eflags = true }, |
| | 9158 | .each = .{ .once = &.{ |
| | 9159 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9160 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9161 | .{ ._, .p_b, .addus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9162 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 9163 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 9164 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9165 | } }, |
| | 9166 | }, .{ |
| | 9167 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 9168 | .src_constraints = .{ |
| | 9169 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } }, |
| | 9170 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } }, |
| | 9171 | .any, |
| | 9172 | }, |
| | 9173 | .patterns = &.{ |
| | 9174 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9175 | }, |
| | 9176 | .extra_temps = .{ |
| | 9177 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9178 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9179 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9180 | .unused, |
| | 9181 | .unused, |
| | 9182 | .unused, |
| | 9183 | .unused, |
| | 9184 | .unused, |
| | 9185 | .unused, |
| | 9186 | .unused, |
| | 9187 | .unused, |
| | 9188 | }, |
| | 9189 | .dst_temps = .{ .mem, .unused }, |
| | 9190 | .clobbers = .{ .eflags = true }, |
| | 9191 | .each = .{ .once = &.{ |
| | 9192 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9193 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9194 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9195 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 9196 | .{ ._, ._, .@"or", .tmp1b, .tmp2b, ._, ._ }, |
| | 9197 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 9198 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 9199 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9200 | } }, |
| | 9201 | }, .{ |
| | 9202 | .src_constraints = .{ |
| | 9203 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } }, |
| | 9204 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .byte, .is = 8 } }, |
| | 9205 | .any, |
| | 9206 | }, |
| | 9207 | .patterns = &.{ |
| | 9208 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9209 | }, |
| | 9210 | .extra_temps = .{ |
| | 9211 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9212 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9213 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9214 | .unused, |
| | 9215 | .unused, |
| | 9216 | .unused, |
| | 9217 | .unused, |
| | 9218 | .unused, |
| | 9219 | .unused, |
| | 9220 | .unused, |
| | 9221 | .unused, |
| | 9222 | }, |
| | 9223 | .dst_temps = .{ .mem, .unused }, |
| | 9224 | .clobbers = .{ .eflags = true }, |
| | 9225 | .each = .{ .once = &.{ |
| | 9226 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9227 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9228 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9229 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 9230 | .{ ._, ._, .@"or", .tmp1b, .tmp2b, ._, ._ }, |
| | 9231 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 9232 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 9233 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 9234 | } }, |
| | 9235 | }, .{ |
| | 9236 | .required_features = .{ .avx2, null, null, null }, |
| | 9237 | .src_constraints = .{ |
| | 9238 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 9239 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 9240 | .any, |
| | 9241 | }, |
| | 9242 | .patterns = &.{ |
| | 9243 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9244 | }, |
| | 9245 | .extra_temps = .{ |
| | 9246 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9247 | .{ .type = .u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 9248 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 9249 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 9250 | .unused, |
| | 9251 | .unused, |
| | 9252 | .unused, |
| | 9253 | .unused, |
| | 9254 | .unused, |
| | 9255 | .unused, |
| | 9256 | .unused, |
| | 9257 | }, |
| | 9258 | .dst_temps = .{ .mem, .unused }, |
| | 9259 | .clobbers = .{ .eflags = true }, |
| | 9260 | .each = .{ .once = &.{ |
| | 9261 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9262 | .{ ._, .vp_b, .broadcast, .tmp2y, .lea(.tmp0b), ._, ._ }, |
| | 9263 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9264 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9265 | .{ ._, .vp_b, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 9266 | .{ ._, .vp_b, .minu, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| | 9267 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 9268 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 9269 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9270 | } }, |
| | 9271 | }, .{ |
| | 9272 | .required_features = .{ .avx, null, null, null }, |
| | 9273 | .src_constraints = .{ |
| | 9274 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 9275 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 9276 | .any, |
| | 9277 | }, |
| | 9278 | .patterns = &.{ |
| | 9279 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9280 | }, |
| | 9281 | .extra_temps = .{ |
| | 9282 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9283 | .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 9284 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 9285 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 9286 | .unused, |
| | 9287 | .unused, |
| | 9288 | .unused, |
| | 9289 | .unused, |
| | 9290 | .unused, |
| | 9291 | .unused, |
| | 9292 | .unused, |
| | 9293 | }, |
| | 9294 | .dst_temps = .{ .mem, .unused }, |
| | 9295 | .clobbers = .{ .eflags = true }, |
| | 9296 | .each = .{ .once = &.{ |
| | 9297 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9298 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 9299 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9300 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9301 | .{ ._, .vp_b, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 9302 | .{ ._, .vp_b, .minu, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| | 9303 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 9304 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9305 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9306 | } }, |
| | 9307 | }, .{ |
| | 9308 | .required_features = .{ .sse2, null, null, null }, |
| | 9309 | .src_constraints = .{ |
| | 9310 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 9311 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 9312 | .any, |
| | 9313 | }, |
| | 9314 | .patterns = &.{ |
| | 9315 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9316 | }, |
| | 9317 | .extra_temps = .{ |
| | 9318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9319 | .{ .type = .vector_16_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 9320 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 9321 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 9322 | .unused, |
| | 9323 | .unused, |
| | 9324 | .unused, |
| | 9325 | .unused, |
| | 9326 | .unused, |
| | 9327 | .unused, |
| | 9328 | .unused, |
| | 9329 | }, |
| | 9330 | .dst_temps = .{ .mem, .unused }, |
| | 9331 | .clobbers = .{ .eflags = true }, |
| | 9332 | .each = .{ .once = &.{ |
| | 9333 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9334 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 9335 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9336 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9337 | .{ ._, .p_b, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9338 | .{ ._, .p_b, .minu, .tmp3x, .tmp2x, ._, ._ }, |
| | 9339 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 9340 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9341 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9342 | } }, |
| | 9343 | }, .{ |
| | 9344 | .required_features = .{ .sse, .mmx, null, null }, |
| | 9345 | .src_constraints = .{ |
| | 9346 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 9347 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 9348 | .any, |
| | 9349 | }, |
| | 9350 | .patterns = &.{ |
| | 9351 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9352 | }, |
| | 9353 | .extra_temps = .{ |
| | 9354 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9355 | .{ .type = .vector_8_u8, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .qword } } }, |
| | 9356 | .{ .type = .vector_8_u8, .kind = .{ .rc = .sse } }, |
| | 9357 | .{ .type = .vector_8_u8, .kind = .{ .rc = .sse } }, |
| | 9358 | .unused, |
| | 9359 | .unused, |
| | 9360 | .unused, |
| | 9361 | .unused, |
| | 9362 | .unused, |
| | 9363 | .unused, |
| | 9364 | .unused, |
| | 9365 | }, |
| | 9366 | .dst_temps = .{ .mem, .unused }, |
| | 9367 | .clobbers = .{ .eflags = true }, |
| | 9368 | .each = .{ .once = &.{ |
| | 9369 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9370 | .{ ._, ._q, .mov, .tmp2q, .lea(.tmp0q), ._, ._ }, |
| | 9371 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9372 | .{ .@"0:", ._q, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9373 | .{ ._, .p_b, .add, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9374 | .{ ._, .p_b, .minu, .tmp3q, .tmp2q, ._, ._ }, |
| | 9375 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| | 9376 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 9377 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9378 | } }, |
| | 9379 | }, .{ |
| | 9380 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| | 9381 | .src_constraints = .{ |
| | 9382 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9383 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9384 | .any, |
| | 9385 | }, |
| | 9386 | .patterns = &.{ |
| | 9387 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9388 | }, |
| | 9389 | .extra_temps = .{ |
| | 9390 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9391 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9392 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9393 | .unused, |
| | 9394 | .unused, |
| | 9395 | .unused, |
| | 9396 | .unused, |
| | 9397 | .unused, |
| | 9398 | .unused, |
| | 9399 | .unused, |
| | 9400 | .unused, |
| | 9401 | }, |
| | 9402 | .dst_temps = .{ .mem, .unused }, |
| | 9403 | .clobbers = .{ .eflags = true }, |
| | 9404 | .each = .{ .once = &.{ |
| | 9405 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9406 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 9407 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9408 | .{ ._, ._, .add, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9409 | .{ ._, ._, .cmp, .tmp2b, .tmp1b, ._, ._ }, |
| | 9410 | .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9411 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 9412 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 9413 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9414 | } }, |
| | 9415 | }, .{ |
| | 9416 | .required_features = .{ .cmov, null, null, null }, |
| | 9417 | .src_constraints = .{ |
| | 9418 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9419 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9420 | .any, |
| | 9421 | }, |
| | 9422 | .patterns = &.{ |
| | 9423 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9424 | }, |
| | 9425 | .extra_temps = .{ |
| | 9426 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9427 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9428 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9429 | .unused, |
| | 9430 | .unused, |
| | 9431 | .unused, |
| | 9432 | .unused, |
| | 9433 | .unused, |
| | 9434 | .unused, |
| | 9435 | .unused, |
| | 9436 | .unused, |
| | 9437 | }, |
| | 9438 | .dst_temps = .{ .mem, .unused }, |
| | 9439 | .clobbers = .{ .eflags = true }, |
| | 9440 | .each = .{ .once = &.{ |
| | 9441 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9442 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 9443 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9444 | .{ ._, ._, .add, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9445 | .{ ._, ._, .cmp, .tmp2b, .tmp1b, ._, ._ }, |
| | 9446 | .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9447 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 9448 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 9449 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 9450 | } }, |
| | 9451 | }, .{ |
| | 9452 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 9453 | .src_constraints = .{ |
| | 9454 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9455 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9456 | .any, |
| | 9457 | }, |
| | 9458 | .patterns = &.{ |
| | 9459 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9460 | }, |
| | 9461 | .extra_temps = .{ |
| | 9462 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9463 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9464 | .unused, |
| | 9465 | .unused, |
| | 9466 | .unused, |
| | 9467 | .unused, |
| | 9468 | .unused, |
| | 9469 | .unused, |
| | 9470 | .unused, |
| | 9471 | .unused, |
| | 9472 | .unused, |
| | 9473 | }, |
| | 9474 | .dst_temps = .{ .mem, .unused }, |
| | 9475 | .clobbers = .{ .eflags = true }, |
| | 9476 | .each = .{ .once = &.{ |
| | 9477 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9478 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9479 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9480 | .{ ._, ._, .cmp, .tmp1b, .ua(.src0, .add_umax), ._, ._ }, |
| | 9481 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 9482 | .{ ._, ._, .mov, .tmp1b, .ua(.src0, .add_umax), ._, ._ }, |
| | 9483 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 9484 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 9485 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9486 | } }, |
| | 9487 | }, .{ |
| | 9488 | .src_constraints = .{ |
| | 9489 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9490 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 9491 | .any, |
| | 9492 | }, |
| | 9493 | .patterns = &.{ |
| | 9494 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9495 | }, |
| | 9496 | .extra_temps = .{ |
| | 9497 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9498 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 9499 | .unused, |
| | 9500 | .unused, |
| | 9501 | .unused, |
| | 9502 | .unused, |
| | 9503 | .unused, |
| | 9504 | .unused, |
| | 9505 | .unused, |
| | 9506 | .unused, |
| | 9507 | .unused, |
| | 9508 | }, |
| | 9509 | .dst_temps = .{ .mem, .unused }, |
| | 9510 | .clobbers = .{ .eflags = true }, |
| | 9511 | .each = .{ .once = &.{ |
| | 9512 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9513 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9514 | .{ ._, ._, .add, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9515 | .{ ._, ._, .cmp, .tmp1b, .ua(.src0, .add_umax), ._, ._ }, |
| | 9516 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 9517 | .{ ._, ._, .mov, .tmp1b, .ua(.src0, .add_umax), ._, ._ }, |
| | 9518 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 9519 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 9520 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 9521 | } }, |
| | 9522 | }, .{ |
| | 9523 | .required_features = .{ .avx2, null, null, null }, |
| | 9524 | .src_constraints = .{ |
| | 9525 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 9526 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 9527 | .any, |
| | 9528 | }, |
| | 9529 | .patterns = &.{ |
| | 9530 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9531 | }, |
| | 9532 | .extra_temps = .{ |
| | 9533 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9534 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 9535 | .unused, |
| | 9536 | .unused, |
| | 9537 | .unused, |
| | 9538 | .unused, |
| | 9539 | .unused, |
| | 9540 | .unused, |
| | 9541 | .unused, |
| | 9542 | .unused, |
| | 9543 | .unused, |
| | 9544 | }, |
| | 9545 | .dst_temps = .{ .mem, .unused }, |
| | 9546 | .clobbers = .{ .eflags = true }, |
| | 9547 | .each = .{ .once = &.{ |
| | 9548 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9549 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9550 | .{ ._, .vp_w, .adds, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 9551 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 9552 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 9553 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9554 | } }, |
| | 9555 | }, .{ |
| | 9556 | .required_features = .{ .avx, null, null, null }, |
| | 9557 | .src_constraints = .{ |
| | 9558 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 9559 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 9560 | .any, |
| | 9561 | }, |
| | 9562 | .patterns = &.{ |
| | 9563 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9564 | }, |
| | 9565 | .extra_temps = .{ |
| | 9566 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9567 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9568 | .unused, |
| | 9569 | .unused, |
| | 9570 | .unused, |
| | 9571 | .unused, |
| | 9572 | .unused, |
| | 9573 | .unused, |
| | 9574 | .unused, |
| | 9575 | .unused, |
| | 9576 | .unused, |
| | 9577 | }, |
| | 9578 | .dst_temps = .{ .mem, .unused }, |
| | 9579 | .clobbers = .{ .eflags = true }, |
| | 9580 | .each = .{ .once = &.{ |
| | 9581 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9582 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9583 | .{ ._, .vp_w, .adds, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 9584 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 9585 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9586 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9587 | } }, |
| | 9588 | }, .{ |
| | 9589 | .required_features = .{ .sse2, null, null, null }, |
| | 9590 | .src_constraints = .{ |
| | 9591 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 9592 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 9593 | .any, |
| | 9594 | }, |
| | 9595 | .patterns = &.{ |
| | 9596 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9597 | }, |
| | 9598 | .extra_temps = .{ |
| | 9599 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9600 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9601 | .unused, |
| | 9602 | .unused, |
| | 9603 | .unused, |
| | 9604 | .unused, |
| | 9605 | .unused, |
| | 9606 | .unused, |
| | 9607 | .unused, |
| | 9608 | .unused, |
| | 9609 | .unused, |
| | 9610 | }, |
| | 9611 | .dst_temps = .{ .mem, .unused }, |
| | 9612 | .clobbers = .{ .eflags = true }, |
| | 9613 | .each = .{ .once = &.{ |
| | 9614 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9615 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9616 | .{ ._, .p_w, .adds, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9617 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 9618 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9619 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9620 | } }, |
| | 9621 | }, .{ |
| | 9622 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| | 9623 | .src_constraints = .{ |
| | 9624 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9625 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9626 | .any, |
| | 9627 | }, |
| | 9628 | .patterns = &.{ |
| | 9629 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9630 | }, |
| | 9631 | .extra_temps = .{ |
| | 9632 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9633 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9634 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9635 | .unused, |
| | 9636 | .unused, |
| | 9637 | .unused, |
| | 9638 | .unused, |
| | 9639 | .unused, |
| | 9640 | .unused, |
| | 9641 | .unused, |
| | 9642 | .unused, |
| | 9643 | }, |
| | 9644 | .dst_temps = .{ .mem, .unused }, |
| | 9645 | .clobbers = .{ .eflags = true }, |
| | 9646 | .each = .{ .once = &.{ |
| | 9647 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9648 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9649 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9650 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 9651 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 9652 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9653 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 9654 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9655 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9656 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9657 | } }, |
| | 9658 | }, .{ |
| | 9659 | .required_features = .{ .cmov, null, null, null }, |
| | 9660 | .src_constraints = .{ |
| | 9661 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9662 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9663 | .any, |
| | 9664 | }, |
| | 9665 | .patterns = &.{ |
| | 9666 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9667 | }, |
| | 9668 | .extra_temps = .{ |
| | 9669 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9670 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9671 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9672 | .unused, |
| | 9673 | .unused, |
| | 9674 | .unused, |
| | 9675 | .unused, |
| | 9676 | .unused, |
| | 9677 | .unused, |
| | 9678 | .unused, |
| | 9679 | .unused, |
| | 9680 | }, |
| | 9681 | .dst_temps = .{ .mem, .unused }, |
| | 9682 | .clobbers = .{ .eflags = true }, |
| | 9683 | .each = .{ .once = &.{ |
| | 9684 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9685 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9686 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9687 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 9688 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 9689 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9690 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 9691 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9692 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9694 | } }, |
| | 9695 | }, .{ |
| | 9696 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 9697 | .src_constraints = .{ |
| | 9698 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9699 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9700 | .any, |
| | 9701 | }, |
| | 9702 | .patterns = &.{ |
| | 9703 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9704 | }, |
| | 9705 | .extra_temps = .{ |
| | 9706 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9707 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9708 | .unused, |
| | 9709 | .unused, |
| | 9710 | .unused, |
| | 9711 | .unused, |
| | 9712 | .unused, |
| | 9713 | .unused, |
| | 9714 | .unused, |
| | 9715 | .unused, |
| | 9716 | .unused, |
| | 9717 | }, |
| | 9718 | .dst_temps = .{ .mem, .unused }, |
| | 9719 | .clobbers = .{ .eflags = true }, |
| | 9720 | .each = .{ .once = &.{ |
| | 9721 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9722 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9723 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9724 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 9725 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 9726 | .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ }, |
| | 9727 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9728 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9729 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9730 | } }, |
| | 9731 | }, .{ |
| | 9732 | .src_constraints = .{ |
| | 9733 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9734 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 9735 | .any, |
| | 9736 | }, |
| | 9737 | .patterns = &.{ |
| | 9738 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9739 | }, |
| | 9740 | .extra_temps = .{ |
| | 9741 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9742 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9743 | .unused, |
| | 9744 | .unused, |
| | 9745 | .unused, |
| | 9746 | .unused, |
| | 9747 | .unused, |
| | 9748 | .unused, |
| | 9749 | .unused, |
| | 9750 | .unused, |
| | 9751 | .unused, |
| | 9752 | }, |
| | 9753 | .dst_temps = .{ .mem, .unused }, |
| | 9754 | .clobbers = .{ .eflags = true }, |
| | 9755 | .each = .{ .once = &.{ |
| | 9756 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9757 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9758 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9759 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 9760 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 9761 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 9762 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9763 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9764 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9765 | } }, |
| | 9766 | }, .{ |
| | 9767 | .required_features = .{ .avx2, null, null, null }, |
| | 9768 | .src_constraints = .{ |
| | 9769 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 9770 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 9771 | .any, |
| | 9772 | }, |
| | 9773 | .patterns = &.{ |
| | 9774 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9775 | }, |
| | 9776 | .extra_temps = .{ |
| | 9777 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9778 | .{ .type = .i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 9779 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 9780 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 9781 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 9782 | .unused, |
| | 9783 | .unused, |
| | 9784 | .unused, |
| | 9785 | .unused, |
| | 9786 | .unused, |
| | 9787 | .unused, |
| | 9788 | }, |
| | 9789 | .dst_temps = .{ .mem, .unused }, |
| | 9790 | .clobbers = .{ .eflags = true }, |
| | 9791 | .each = .{ .once = &.{ |
| | 9792 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9793 | .{ ._, .vp_w, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 9794 | .{ ._, .vp_w, .broadcast, .tmp3y, .lea(.tmp0w), ._, ._ }, |
| | 9795 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 9796 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9797 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9798 | .{ ._, .vp_w, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 9799 | .{ ._, .vp_w, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 9800 | .{ ._, .vp_w, .mins, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 9801 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 9802 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 9803 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9804 | } }, |
| | 9805 | }, .{ |
| | 9806 | .required_features = .{ .avx, null, null, null }, |
| | 9807 | .src_constraints = .{ |
| | 9808 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 9809 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 9810 | .any, |
| | 9811 | }, |
| | 9812 | .patterns = &.{ |
| | 9813 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9814 | }, |
| | 9815 | .extra_temps = .{ |
| | 9816 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9817 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 9818 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9819 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9820 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9821 | .unused, |
| | 9822 | .unused, |
| | 9823 | .unused, |
| | 9824 | .unused, |
| | 9825 | .unused, |
| | 9826 | .unused, |
| | 9827 | }, |
| | 9828 | .dst_temps = .{ .mem, .unused }, |
| | 9829 | .clobbers = .{ .eflags = true }, |
| | 9830 | .each = .{ .once = &.{ |
| | 9831 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9832 | .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 9833 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 9834 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 9835 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9836 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9837 | .{ ._, .vp_w, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 9838 | .{ ._, .vp_w, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 9839 | .{ ._, .vp_w, .mins, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 9840 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 9841 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9843 | } }, |
| | 9844 | }, .{ |
| | 9845 | .required_features = .{ .sse2, null, null, null }, |
| | 9846 | .src_constraints = .{ |
| | 9847 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 9848 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 9849 | .any, |
| | 9850 | }, |
| | 9851 | .patterns = &.{ |
| | 9852 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9853 | }, |
| | 9854 | .extra_temps = .{ |
| | 9855 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9856 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 9857 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9858 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9859 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 9860 | .unused, |
| | 9861 | .unused, |
| | 9862 | .unused, |
| | 9863 | .unused, |
| | 9864 | .unused, |
| | 9865 | .unused, |
| | 9866 | }, |
| | 9867 | .dst_temps = .{ .mem, .unused }, |
| | 9868 | .clobbers = .{ .eflags = true }, |
| | 9869 | .each = .{ .once = &.{ |
| | 9870 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 9871 | .{ ._, .p_w, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 9872 | .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 9873 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 9874 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9875 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9876 | .{ ._, .p_w, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9877 | .{ ._, .p_w, .maxs, .tmp4x, .tmp3x, ._, ._ }, |
| | 9878 | .{ ._, .p_w, .mins, .tmp4x, .tmp2x, ._, ._ }, |
| | 9879 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 9880 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 9881 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9882 | } }, |
| | 9883 | }, .{ |
| | 9884 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| | 9885 | .src_constraints = .{ |
| | 9886 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 9887 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 9888 | .any, |
| | 9889 | }, |
| | 9890 | .patterns = &.{ |
| | 9891 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9892 | }, |
| | 9893 | .extra_temps = .{ |
| | 9894 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9895 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9896 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9897 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9898 | .unused, |
| | 9899 | .unused, |
| | 9900 | .unused, |
| | 9901 | .unused, |
| | 9902 | .unused, |
| | 9903 | .unused, |
| | 9904 | .unused, |
| | 9905 | }, |
| | 9906 | .dst_temps = .{ .mem, .unused }, |
| | 9907 | .clobbers = .{ .eflags = true }, |
| | 9908 | .each = .{ .once = &.{ |
| | 9909 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9910 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9911 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9912 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 9913 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9914 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 9915 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 9916 | .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ }, |
| | 9917 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 9918 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9919 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9920 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9921 | } }, |
| | 9922 | }, .{ |
| | 9923 | .required_features = .{ .cmov, null, null, null }, |
| | 9924 | .src_constraints = .{ |
| | 9925 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 9926 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 9927 | .any, |
| | 9928 | }, |
| | 9929 | .patterns = &.{ |
| | 9930 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9931 | }, |
| | 9932 | .extra_temps = .{ |
| | 9933 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9934 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9935 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9936 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9937 | .unused, |
| | 9938 | .unused, |
| | 9939 | .unused, |
| | 9940 | .unused, |
| | 9941 | .unused, |
| | 9942 | .unused, |
| | 9943 | .unused, |
| | 9944 | }, |
| | 9945 | .dst_temps = .{ .mem, .unused }, |
| | 9946 | .clobbers = .{ .eflags = true }, |
| | 9947 | .each = .{ .once = &.{ |
| | 9948 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9949 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9950 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9951 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 9952 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9953 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 9954 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 9955 | .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ }, |
| | 9956 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 9957 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9958 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9959 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9960 | } }, |
| | 9961 | }, .{ |
| | 9962 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 9963 | .src_constraints = .{ |
| | 9964 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 9965 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 9966 | .any, |
| | 9967 | }, |
| | 9968 | .patterns = &.{ |
| | 9969 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 9970 | }, |
| | 9971 | .extra_temps = .{ |
| | 9972 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 9973 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9974 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 9975 | .unused, |
| | 9976 | .unused, |
| | 9977 | .unused, |
| | 9978 | .unused, |
| | 9979 | .unused, |
| | 9980 | .unused, |
| | 9981 | .unused, |
| | 9982 | .unused, |
| | 9983 | }, |
| | 9984 | .dst_temps = .{ .mem, .unused }, |
| | 9985 | .clobbers = .{ .eflags = true }, |
| | 9986 | .each = .{ .once = &.{ |
| | 9987 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 9988 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9989 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 9990 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 9991 | .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ }, |
| | 9992 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 9993 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 9994 | .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ }, |
| | 9995 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 9996 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 9997 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 9998 | } }, |
| | 9999 | }, .{ |
| | 10000 | .src_constraints = .{ |
| | 10001 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 10002 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 10003 | .any, |
| | 10004 | }, |
| | 10005 | .patterns = &.{ |
| | 10006 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10007 | }, |
| | 10008 | .extra_temps = .{ |
| | 10009 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10010 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10011 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10012 | .unused, |
| | 10013 | .unused, |
| | 10014 | .unused, |
| | 10015 | .unused, |
| | 10016 | .unused, |
| | 10017 | .unused, |
| | 10018 | .unused, |
| | 10019 | .unused, |
| | 10020 | }, |
| | 10021 | .dst_temps = .{ .mem, .unused }, |
| | 10022 | .clobbers = .{ .eflags = true }, |
| | 10023 | .each = .{ .once = &.{ |
| | 10024 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10025 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10026 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10027 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10028 | .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ }, |
| | 10029 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 10030 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 10031 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 10032 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10033 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10034 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10035 | } }, |
| | 10036 | }, .{ |
| | 10037 | .required_features = .{ .bmi2, .cmov, .fast_imm16, null }, |
| | 10038 | .src_constraints = .{ |
| | 10039 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10040 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10041 | .any, |
| | 10042 | }, |
| | 10043 | .patterns = &.{ |
| | 10044 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10045 | }, |
| | 10046 | .extra_temps = .{ |
| | 10047 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10048 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10049 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10050 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10051 | .unused, |
| | 10052 | .unused, |
| | 10053 | .unused, |
| | 10054 | .unused, |
| | 10055 | .unused, |
| | 10056 | .unused, |
| | 10057 | .unused, |
| | 10058 | }, |
| | 10059 | .dst_temps = .{ .mem, .unused }, |
| | 10060 | .clobbers = .{ .eflags = true }, |
| | 10061 | .each = .{ .once = &.{ |
| | 10062 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10063 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10064 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10065 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 10066 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10067 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 10068 | .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ }, |
| | 10069 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 10070 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 10071 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10072 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10073 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10074 | } }, |
| | 10075 | }, .{ |
| | 10076 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 10077 | .src_constraints = .{ |
| | 10078 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10079 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10080 | .any, |
| | 10081 | }, |
| | 10082 | .patterns = &.{ |
| | 10083 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10084 | }, |
| | 10085 | .extra_temps = .{ |
| | 10086 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10087 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10088 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10089 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10090 | .unused, |
| | 10091 | .unused, |
| | 10092 | .unused, |
| | 10093 | .unused, |
| | 10094 | .unused, |
| | 10095 | .unused, |
| | 10096 | .unused, |
| | 10097 | }, |
| | 10098 | .dst_temps = .{ .mem, .unused }, |
| | 10099 | .clobbers = .{ .eflags = true }, |
| | 10100 | .each = .{ .once = &.{ |
| | 10101 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10102 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10103 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10104 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 10105 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10106 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 10107 | .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ }, |
| | 10108 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 10109 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 10110 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10111 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10112 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10113 | } }, |
| | 10114 | }, .{ |
| | 10115 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| | 10116 | .src_constraints = .{ |
| | 10117 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10118 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10119 | .any, |
| | 10120 | }, |
| | 10121 | .patterns = &.{ |
| | 10122 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10123 | }, |
| | 10124 | .extra_temps = .{ |
| | 10125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10126 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10127 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10128 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10129 | .unused, |
| | 10130 | .unused, |
| | 10131 | .unused, |
| | 10132 | .unused, |
| | 10133 | .unused, |
| | 10134 | .unused, |
| | 10135 | .unused, |
| | 10136 | }, |
| | 10137 | .dst_temps = .{ .mem, .unused }, |
| | 10138 | .clobbers = .{ .eflags = true }, |
| | 10139 | .each = .{ .once = &.{ |
| | 10140 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10141 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10142 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10143 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 10144 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10145 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 10146 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 10147 | .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 10148 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 10149 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 10150 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10151 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10152 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10153 | } }, |
| | 10154 | }, .{ |
| | 10155 | .required_features = .{ .cmov, null, null, null }, |
| | 10156 | .src_constraints = .{ |
| | 10157 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10158 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10159 | .any, |
| | 10160 | }, |
| | 10161 | .patterns = &.{ |
| | 10162 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10163 | }, |
| | 10164 | .extra_temps = .{ |
| | 10165 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10166 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10167 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10168 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10169 | .unused, |
| | 10170 | .unused, |
| | 10171 | .unused, |
| | 10172 | .unused, |
| | 10173 | .unused, |
| | 10174 | .unused, |
| | 10175 | .unused, |
| | 10176 | }, |
| | 10177 | .dst_temps = .{ .mem, .unused }, |
| | 10178 | .clobbers = .{ .eflags = true }, |
| | 10179 | .each = .{ .once = &.{ |
| | 10180 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10181 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10182 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10183 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 10184 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10185 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 10186 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 10187 | .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 10188 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 10189 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 10190 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10191 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10192 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10193 | } }, |
| | 10194 | }, .{ |
| | 10195 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 10196 | .src_constraints = .{ |
| | 10197 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10198 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10199 | .any, |
| | 10200 | }, |
| | 10201 | .patterns = &.{ |
| | 10202 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10203 | }, |
| | 10204 | .extra_temps = .{ |
| | 10205 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10206 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10207 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10208 | .unused, |
| | 10209 | .unused, |
| | 10210 | .unused, |
| | 10211 | .unused, |
| | 10212 | .unused, |
| | 10213 | .unused, |
| | 10214 | .unused, |
| | 10215 | .unused, |
| | 10216 | }, |
| | 10217 | .dst_temps = .{ .mem, .unused }, |
| | 10218 | .clobbers = .{ .eflags = true }, |
| | 10219 | .each = .{ .once = &.{ |
| | 10220 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10221 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10222 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10223 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10224 | .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 10225 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 10226 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 10227 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 10228 | .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ }, |
| | 10229 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10230 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10231 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10232 | } }, |
| | 10233 | }, .{ |
| | 10234 | .src_constraints = .{ |
| | 10235 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10236 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 10237 | .any, |
| | 10238 | }, |
| | 10239 | .patterns = &.{ |
| | 10240 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10241 | }, |
| | 10242 | .extra_temps = .{ |
| | 10243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10244 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10245 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 10246 | .unused, |
| | 10247 | .unused, |
| | 10248 | .unused, |
| | 10249 | .unused, |
| | 10250 | .unused, |
| | 10251 | .unused, |
| | 10252 | .unused, |
| | 10253 | .unused, |
| | 10254 | }, |
| | 10255 | .dst_temps = .{ .mem, .unused }, |
| | 10256 | .clobbers = .{ .eflags = true }, |
| | 10257 | .each = .{ .once = &.{ |
| | 10258 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10259 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10260 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10261 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10262 | .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 10263 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 10264 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 10265 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 10266 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 10267 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10268 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10269 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10270 | } }, |
| | 10271 | }, .{ |
| | 10272 | .required_features = .{ .mmx, null, null, null }, |
| | 10273 | .src_constraints = .{ |
| | 10274 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } }, |
| | 10275 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } }, |
| | 10276 | .any, |
| | 10277 | }, |
| | 10278 | .patterns = &.{ |
| | 10279 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10280 | }, |
| | 10281 | .extra_temps = .{ |
| | 10282 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10283 | .{ .type = .vector_4_i16, .kind = .{ .rc = .mmx } }, |
| | 10284 | .unused, |
| | 10285 | .unused, |
| | 10286 | .unused, |
| | 10287 | .unused, |
| | 10288 | .unused, |
| | 10289 | .unused, |
| | 10290 | .unused, |
| | 10291 | .unused, |
| | 10292 | .unused, |
| | 10293 | }, |
| | 10294 | .dst_temps = .{ .mem, .unused }, |
| | 10295 | .clobbers = .{ .eflags = true }, |
| | 10296 | .each = .{ .once = &.{ |
| | 10297 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10298 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10299 | .{ ._, .p_w, .addus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10300 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 10301 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 10302 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10303 | } }, |
| | 10304 | }, .{ |
| | 10305 | .required_features = .{ .avx2, null, null, null }, |
| | 10306 | .src_constraints = .{ |
| | 10307 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } }, |
| | 10308 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 16 } }, |
| | 10309 | .any, |
| | 10310 | }, |
| | 10311 | .patterns = &.{ |
| | 10312 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10313 | }, |
| | 10314 | .extra_temps = .{ |
| | 10315 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10316 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| | 10317 | .unused, |
| | 10318 | .unused, |
| | 10319 | .unused, |
| | 10320 | .unused, |
| | 10321 | .unused, |
| | 10322 | .unused, |
| | 10323 | .unused, |
| | 10324 | .unused, |
| | 10325 | .unused, |
| | 10326 | }, |
| | 10327 | .dst_temps = .{ .mem, .unused }, |
| | 10328 | .clobbers = .{ .eflags = true }, |
| | 10329 | .each = .{ .once = &.{ |
| | 10330 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10331 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10332 | .{ ._, .vp_w, .addus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 10333 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 10334 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 10335 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10336 | } }, |
| | 10337 | }, .{ |
| | 10338 | .required_features = .{ .avx, null, null, null }, |
| | 10339 | .src_constraints = .{ |
| | 10340 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 10341 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 10342 | .any, |
| | 10343 | }, |
| | 10344 | .patterns = &.{ |
| | 10345 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10346 | }, |
| | 10347 | .extra_temps = .{ |
| | 10348 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10349 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10350 | .unused, |
| | 10351 | .unused, |
| | 10352 | .unused, |
| | 10353 | .unused, |
| | 10354 | .unused, |
| | 10355 | .unused, |
| | 10356 | .unused, |
| | 10357 | .unused, |
| | 10358 | .unused, |
| | 10359 | }, |
| | 10360 | .dst_temps = .{ .mem, .unused }, |
| | 10361 | .clobbers = .{ .eflags = true }, |
| | 10362 | .each = .{ .once = &.{ |
| | 10363 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10364 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10365 | .{ ._, .vp_w, .addus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 10366 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 10367 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10368 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10369 | } }, |
| | 10370 | }, .{ |
| | 10371 | .required_features = .{ .sse2, null, null, null }, |
| | 10372 | .src_constraints = .{ |
| | 10373 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 10374 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 16 } }, |
| | 10375 | .any, |
| | 10376 | }, |
| | 10377 | .patterns = &.{ |
| | 10378 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10379 | }, |
| | 10380 | .extra_temps = .{ |
| | 10381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10382 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10383 | .unused, |
| | 10384 | .unused, |
| | 10385 | .unused, |
| | 10386 | .unused, |
| | 10387 | .unused, |
| | 10388 | .unused, |
| | 10389 | .unused, |
| | 10390 | .unused, |
| | 10391 | .unused, |
| | 10392 | }, |
| | 10393 | .dst_temps = .{ .mem, .unused }, |
| | 10394 | .clobbers = .{ .eflags = true }, |
| | 10395 | .each = .{ .once = &.{ |
| | 10396 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10397 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10398 | .{ ._, .p_w, .addus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10399 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 10400 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10401 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10402 | } }, |
| | 10403 | }, .{ |
| | 10404 | .required_features = .{ .mmx, null, null, null }, |
| | 10405 | .src_constraints = .{ |
| | 10406 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } }, |
| | 10407 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 16 } }, |
| | 10408 | .any, |
| | 10409 | }, |
| | 10410 | .patterns = &.{ |
| | 10411 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10412 | }, |
| | 10413 | .extra_temps = .{ |
| | 10414 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10415 | .{ .type = .vector_4_u16, .kind = .{ .rc = .mmx } }, |
| | 10416 | .unused, |
| | 10417 | .unused, |
| | 10418 | .unused, |
| | 10419 | .unused, |
| | 10420 | .unused, |
| | 10421 | .unused, |
| | 10422 | .unused, |
| | 10423 | .unused, |
| | 10424 | .unused, |
| | 10425 | }, |
| | 10426 | .dst_temps = .{ .mem, .unused }, |
| | 10427 | .clobbers = .{ .eflags = true }, |
| | 10428 | .each = .{ .once = &.{ |
| | 10429 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10430 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10431 | .{ ._, .p_w, .addus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10432 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 10433 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 10434 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10435 | } }, |
| | 10436 | }, .{ |
| | 10437 | .src_constraints = .{ |
| | 10438 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .word, .is = 16 } }, |
| | 10439 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .word, .is = 16 } }, |
| | 10440 | .any, |
| | 10441 | }, |
| | 10442 | .patterns = &.{ |
| | 10443 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10444 | }, |
| | 10445 | .extra_temps = .{ |
| | 10446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10447 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 10448 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 10449 | .unused, |
| | 10450 | .unused, |
| | 10451 | .unused, |
| | 10452 | .unused, |
| | 10453 | .unused, |
| | 10454 | .unused, |
| | 10455 | .unused, |
| | 10456 | .unused, |
| | 10457 | }, |
| | 10458 | .dst_temps = .{ .mem, .unused }, |
| | 10459 | .clobbers = .{ .eflags = true }, |
| | 10460 | .each = .{ .once = &.{ |
| | 10461 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10462 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10463 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10464 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 10465 | .{ ._, ._, .@"or", .tmp1d, .tmp2d, ._, ._ }, |
| | 10466 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10467 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10468 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10469 | } }, |
| | 10470 | }, .{ |
| | 10471 | .required_features = .{ .avx2, null, null, null }, |
| | 10472 | .src_constraints = .{ |
| | 10473 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 10474 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 10475 | .any, |
| | 10476 | }, |
| | 10477 | .patterns = &.{ |
| | 10478 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10479 | }, |
| | 10480 | .extra_temps = .{ |
| | 10481 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10482 | .{ .type = .u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 10483 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| | 10484 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| | 10485 | .unused, |
| | 10486 | .unused, |
| | 10487 | .unused, |
| | 10488 | .unused, |
| | 10489 | .unused, |
| | 10490 | .unused, |
| | 10491 | .unused, |
| | 10492 | }, |
| | 10493 | .dst_temps = .{ .mem, .unused }, |
| | 10494 | .clobbers = .{ .eflags = true }, |
| | 10495 | .each = .{ .once = &.{ |
| | 10496 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10497 | .{ ._, .vp_w, .broadcast, .tmp2y, .lea(.tmp0w), ._, ._ }, |
| | 10498 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10499 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10500 | .{ ._, .vp_w, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 10501 | .{ ._, .vp_w, .minu, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| | 10502 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 10503 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 10504 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10505 | } }, |
| | 10506 | }, .{ |
| | 10507 | .required_features = .{ .avx, null, null, null }, |
| | 10508 | .src_constraints = .{ |
| | 10509 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 10510 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 10511 | .any, |
| | 10512 | }, |
| | 10513 | .patterns = &.{ |
| | 10514 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10515 | }, |
| | 10516 | .extra_temps = .{ |
| | 10517 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10518 | .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 10519 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10520 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10521 | .unused, |
| | 10522 | .unused, |
| | 10523 | .unused, |
| | 10524 | .unused, |
| | 10525 | .unused, |
| | 10526 | .unused, |
| | 10527 | .unused, |
| | 10528 | }, |
| | 10529 | .dst_temps = .{ .mem, .unused }, |
| | 10530 | .clobbers = .{ .eflags = true }, |
| | 10531 | .each = .{ .once = &.{ |
| | 10532 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10533 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 10534 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10535 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10536 | .{ ._, .vp_w, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 10537 | .{ ._, .vp_w, .minu, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| | 10538 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 10539 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10540 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10541 | } }, |
| | 10542 | }, .{ |
| | 10543 | .required_features = .{ .sse4_1, null, null, null }, |
| | 10544 | .src_constraints = .{ |
| | 10545 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 10546 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 10547 | .any, |
| | 10548 | }, |
| | 10549 | .patterns = &.{ |
| | 10550 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10551 | }, |
| | 10552 | .extra_temps = .{ |
| | 10553 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10554 | .{ .type = .vector_8_u16, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 10555 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10556 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10557 | .unused, |
| | 10558 | .unused, |
| | 10559 | .unused, |
| | 10560 | .unused, |
| | 10561 | .unused, |
| | 10562 | .unused, |
| | 10563 | .unused, |
| | 10564 | }, |
| | 10565 | .dst_temps = .{ .mem, .unused }, |
| | 10566 | .clobbers = .{ .eflags = true }, |
| | 10567 | .each = .{ .once = &.{ |
| | 10568 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10569 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 10570 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10571 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10572 | .{ ._, .p_w, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10573 | .{ ._, .p_w, .minu, .tmp3x, .tmp2x, ._, ._ }, |
| | 10574 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 10575 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10576 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10577 | } }, |
| | 10578 | }, .{ |
| | 10579 | .required_features = .{ .sse2, null, null, null }, |
| | 10580 | .src_constraints = .{ |
| | 10581 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 10582 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 10583 | .any, |
| | 10584 | }, |
| | 10585 | .patterns = &.{ |
| | 10586 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10587 | }, |
| | 10588 | .extra_temps = .{ |
| | 10589 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10590 | .{ .type = .vector_8_u16, .kind = .{ .umax_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 10591 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10592 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 10593 | .unused, |
| | 10594 | .unused, |
| | 10595 | .unused, |
| | 10596 | .unused, |
| | 10597 | .unused, |
| | 10598 | .unused, |
| | 10599 | .unused, |
| | 10600 | }, |
| | 10601 | .dst_temps = .{ .mem, .unused }, |
| | 10602 | .clobbers = .{ .eflags = true }, |
| | 10603 | .each = .{ .once = &.{ |
| | 10604 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10605 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 10606 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10607 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10608 | .{ ._, .p_w, .add, .tmp3x, .tmp2x, ._, ._ }, |
| | 10609 | .{ ._, .p_w, .addus, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10610 | .{ ._, .p_w, .sub, .tmp3x, .tmp2x, ._, ._ }, |
| | 10611 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 10612 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10613 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10614 | } }, |
| | 10615 | }, .{ |
| | 10616 | .required_features = .{ .cmov, null, null, null }, |
| | 10617 | .src_constraints = .{ |
| | 10618 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 10619 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 10620 | .any, |
| | 10621 | }, |
| | 10622 | .patterns = &.{ |
| | 10623 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10624 | }, |
| | 10625 | .extra_temps = .{ |
| | 10626 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10627 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 10628 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 10629 | .unused, |
| | 10630 | .unused, |
| | 10631 | .unused, |
| | 10632 | .unused, |
| | 10633 | .unused, |
| | 10634 | .unused, |
| | 10635 | .unused, |
| | 10636 | .unused, |
| | 10637 | }, |
| | 10638 | .dst_temps = .{ .mem, .unused }, |
| | 10639 | .clobbers = .{ .eflags = true }, |
| | 10640 | .each = .{ .once = &.{ |
| | 10641 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10642 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 10643 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10644 | .{ ._, ._, .add, .tmp2w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10645 | .{ ._, ._, .cmp, .tmp2d, .tmp1d, ._, ._ }, |
| | 10646 | .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10647 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| | 10648 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10649 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10650 | } }, |
| | 10651 | }, .{ |
| | 10652 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 10653 | .src_constraints = .{ |
| | 10654 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 10655 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 10656 | .any, |
| | 10657 | }, |
| | 10658 | .patterns = &.{ |
| | 10659 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10660 | }, |
| | 10661 | .extra_temps = .{ |
| | 10662 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10663 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 10664 | .unused, |
| | 10665 | .unused, |
| | 10666 | .unused, |
| | 10667 | .unused, |
| | 10668 | .unused, |
| | 10669 | .unused, |
| | 10670 | .unused, |
| | 10671 | .unused, |
| | 10672 | .unused, |
| | 10673 | }, |
| | 10674 | .dst_temps = .{ .mem, .unused }, |
| | 10675 | .clobbers = .{ .eflags = true }, |
| | 10676 | .each = .{ .once = &.{ |
| | 10677 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10678 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10679 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10680 | .{ ._, ._, .cmp, .tmp1w, .ua(.src0, .add_umax), ._, ._ }, |
| | 10681 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 10682 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 10683 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10684 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10685 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10686 | } }, |
| | 10687 | }, .{ |
| | 10688 | .src_constraints = .{ |
| | 10689 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 10690 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 10691 | .any, |
| | 10692 | }, |
| | 10693 | .patterns = &.{ |
| | 10694 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10695 | }, |
| | 10696 | .extra_temps = .{ |
| | 10697 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10698 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 10699 | .unused, |
| | 10700 | .unused, |
| | 10701 | .unused, |
| | 10702 | .unused, |
| | 10703 | .unused, |
| | 10704 | .unused, |
| | 10705 | .unused, |
| | 10706 | .unused, |
| | 10707 | .unused, |
| | 10708 | }, |
| | 10709 | .dst_temps = .{ .mem, .unused }, |
| | 10710 | .clobbers = .{ .eflags = true }, |
| | 10711 | .each = .{ .once = &.{ |
| | 10712 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10713 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10714 | .{ ._, ._, .add, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10715 | .{ ._, ._, .cmp, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 10716 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 10717 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 10718 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 10719 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 10720 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10721 | } }, |
| | 10722 | }, .{ |
| | 10723 | .required_features = .{ .avx2, null, null, null }, |
| | 10724 | .src_constraints = .{ |
| | 10725 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 10726 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 10727 | .any, |
| | 10728 | }, |
| | 10729 | .patterns = &.{ |
| | 10730 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10731 | }, |
| | 10732 | .extra_temps = .{ |
| | 10733 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10734 | .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 10735 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10736 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10737 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10738 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10739 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10740 | .unused, |
| | 10741 | .unused, |
| | 10742 | .unused, |
| | 10743 | .unused, |
| | 10744 | }, |
| | 10745 | .dst_temps = .{ .mem, .unused }, |
| | 10746 | .clobbers = .{ .eflags = true }, |
| | 10747 | .each = .{ .once = &.{ |
| | 10748 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10749 | .{ ._, .vp_d, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ }, |
| | 10750 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10751 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10752 | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10753 | .{ ._, .vp_d, .add, .tmp5y, .tmp3y, .tmp4y, ._ }, |
| | 10754 | .{ ._, .vp_d, .sra, .tmp6y, .tmp3y, .ui(31), ._ }, |
| | 10755 | .{ ._, .vp_d, .cmpgt, .tmp3y, .tmp5y, .tmp3y, ._ }, |
| | 10756 | .{ ._, .vp_, .xor, .tmp6y, .tmp6y, .tmp2y, ._ }, |
| | 10757 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ }, |
| | 10758 | .{ ._, .v_ps, .blendv, .tmp3y, .tmp6y, .tmp5y, .tmp3y }, |
| | 10759 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 10760 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 10761 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10762 | } }, |
| | 10763 | }, .{ |
| | 10764 | .required_features = .{ .avx, null, null, null }, |
| | 10765 | .src_constraints = .{ |
| | 10766 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 10767 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 10768 | .any, |
| | 10769 | }, |
| | 10770 | .patterns = &.{ |
| | 10771 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10772 | }, |
| | 10773 | .extra_temps = .{ |
| | 10774 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10775 | .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 10776 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10777 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10778 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10779 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10780 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10781 | .unused, |
| | 10782 | .unused, |
| | 10783 | .unused, |
| | 10784 | .unused, |
| | 10785 | }, |
| | 10786 | .dst_temps = .{ .mem, .unused }, |
| | 10787 | .clobbers = .{ .eflags = true }, |
| | 10788 | .each = .{ .once = &.{ |
| | 10789 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10790 | .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ }, |
| | 10791 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10792 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10793 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10794 | .{ ._, .vp_d, .add, .tmp5x, .tmp3x, .tmp4x, ._ }, |
| | 10795 | .{ ._, .vp_d, .sra, .tmp6x, .tmp3x, .ui(31), ._ }, |
| | 10796 | .{ ._, .vp_d, .cmpgt, .tmp3x, .tmp5x, .tmp3x, ._ }, |
| | 10797 | .{ ._, .vp_, .xor, .tmp6x, .tmp6x, .tmp2x, ._ }, |
| | 10798 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ }, |
| | 10799 | .{ ._, .v_ps, .blendv, .tmp3x, .tmp6x, .tmp5x, .tmp3x }, |
| | 10800 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 10801 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10802 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10803 | } }, |
| | 10804 | }, .{ |
| | 10805 | .required_features = .{ .sse4_1, null, null, null }, |
| | 10806 | .src_constraints = .{ |
| | 10807 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 10808 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 10809 | .any, |
| | 10810 | }, |
| | 10811 | .patterns = &.{ |
| | 10812 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10813 | }, |
| | 10814 | .extra_temps = .{ |
| | 10815 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10816 | .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 10817 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10818 | .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } }, |
| | 10819 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10820 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10821 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10822 | .unused, |
| | 10823 | .unused, |
| | 10824 | .unused, |
| | 10825 | .unused, |
| | 10826 | }, |
| | 10827 | .dst_temps = .{ .mem, .unused }, |
| | 10828 | .clobbers = .{ .eflags = true }, |
| | 10829 | .each = .{ .once = &.{ |
| | 10830 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10831 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 10832 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10833 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10834 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10835 | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| | 10836 | .{ ._, .p_d, .add, .tmp5x, .tmp4x, ._, ._ }, |
| | 10837 | .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ }, |
| | 10838 | .{ ._, .p_d, .sra, .tmp6x, .ui(31), ._, ._ }, |
| | 10839 | .{ ._, .p_d, .cmpgt, .tmp3x, .tmp5x, ._, ._ }, |
| | 10840 | .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ }, |
| | 10841 | .{ ._, .p_, .xor, .tmp3x, .tmp4x, ._, ._ }, |
| | 10842 | .{ ._, ._ps, .blendv, .tmp5x, .tmp6x, .tmp3x, ._ }, |
| | 10843 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ }, |
| | 10844 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10845 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10846 | } }, |
| | 10847 | }, .{ |
| | 10848 | .required_features = .{ .cmov, null, null, null }, |
| | 10849 | .src_constraints = .{ |
| | 10850 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 10851 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 10852 | .any, |
| | 10853 | }, |
| | 10854 | .patterns = &.{ |
| | 10855 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10856 | }, |
| | 10857 | .extra_temps = .{ |
| | 10858 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10859 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 10860 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 10861 | .unused, |
| | 10862 | .unused, |
| | 10863 | .unused, |
| | 10864 | .unused, |
| | 10865 | .unused, |
| | 10866 | .unused, |
| | 10867 | .unused, |
| | 10868 | .unused, |
| | 10869 | }, |
| | 10870 | .dst_temps = .{ .mem, .unused }, |
| | 10871 | .clobbers = .{ .eflags = true }, |
| | 10872 | .each = .{ .once = &.{ |
| | 10873 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10874 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10875 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 10876 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 10877 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 10878 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10879 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 10880 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 10881 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 10882 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10883 | } }, |
| | 10884 | }, .{ |
| | 10885 | .src_constraints = .{ |
| | 10886 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 10887 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 10888 | .any, |
| | 10889 | }, |
| | 10890 | .patterns = &.{ |
| | 10891 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10892 | }, |
| | 10893 | .extra_temps = .{ |
| | 10894 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10895 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 10896 | .unused, |
| | 10897 | .unused, |
| | 10898 | .unused, |
| | 10899 | .unused, |
| | 10900 | .unused, |
| | 10901 | .unused, |
| | 10902 | .unused, |
| | 10903 | .unused, |
| | 10904 | .unused, |
| | 10905 | }, |
| | 10906 | .dst_temps = .{ .mem, .unused }, |
| | 10907 | .clobbers = .{ .eflags = true }, |
| | 10908 | .each = .{ .once = &.{ |
| | 10909 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10910 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10911 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10912 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 10913 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 10914 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smin), ._, ._ }, |
| | 10915 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 10916 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 10917 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10918 | } }, |
| | 10919 | }, .{ |
| | 10920 | .required_features = .{ .avx2, null, null, null }, |
| | 10921 | .src_constraints = .{ |
| | 10922 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 10923 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 10924 | .any, |
| | 10925 | }, |
| | 10926 | .patterns = &.{ |
| | 10927 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10928 | }, |
| | 10929 | .extra_temps = .{ |
| | 10930 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10931 | .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 10932 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10933 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10934 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 10935 | .unused, |
| | 10936 | .unused, |
| | 10937 | .unused, |
| | 10938 | .unused, |
| | 10939 | .unused, |
| | 10940 | .unused, |
| | 10941 | }, |
| | 10942 | .dst_temps = .{ .mem, .unused }, |
| | 10943 | .clobbers = .{ .eflags = true }, |
| | 10944 | .each = .{ .once = &.{ |
| | 10945 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10946 | .{ ._, .vp_d, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 10947 | .{ ._, .vp_d, .broadcast, .tmp3y, .lea(.tmp0d), ._, ._ }, |
| | 10948 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 10949 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10950 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10951 | .{ ._, .vp_d, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 10952 | .{ ._, .vp_d, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 10953 | .{ ._, .vp_d, .mins, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 10954 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 10955 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 10956 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10957 | } }, |
| | 10958 | }, .{ |
| | 10959 | .required_features = .{ .avx, null, null, null }, |
| | 10960 | .src_constraints = .{ |
| | 10961 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 10962 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 10963 | .any, |
| | 10964 | }, |
| | 10965 | .patterns = &.{ |
| | 10966 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 10967 | }, |
| | 10968 | .extra_temps = .{ |
| | 10969 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 10970 | .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 10971 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10972 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10973 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 10974 | .unused, |
| | 10975 | .unused, |
| | 10976 | .unused, |
| | 10977 | .unused, |
| | 10978 | .unused, |
| | 10979 | .unused, |
| | 10980 | }, |
| | 10981 | .dst_temps = .{ .mem, .unused }, |
| | 10982 | .clobbers = .{ .eflags = true }, |
| | 10983 | .each = .{ .once = &.{ |
| | 10984 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 10985 | .{ ._, .vp_d, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 10986 | .{ ._, .v_ss, .broadcast, .tmp3x, .lea(.tmp0d), ._, ._ }, |
| | 10987 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 10988 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 10989 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 10990 | .{ ._, .vp_d, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 10991 | .{ ._, .vp_d, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 10992 | .{ ._, .vp_d, .mins, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 10993 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 10994 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 10995 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 10996 | } }, |
| | 10997 | }, .{ |
| | 10998 | .required_features = .{ .sse4_1, null, null, null }, |
| | 10999 | .src_constraints = .{ |
| | 11000 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 11001 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 11002 | .any, |
| | 11003 | }, |
| | 11004 | .patterns = &.{ |
| | 11005 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11006 | }, |
| | 11007 | .extra_temps = .{ |
| | 11008 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11009 | .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 11010 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 11011 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 11012 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 11013 | .unused, |
| | 11014 | .unused, |
| | 11015 | .unused, |
| | 11016 | .unused, |
| | 11017 | .unused, |
| | 11018 | .unused, |
| | 11019 | }, |
| | 11020 | .dst_temps = .{ .mem, .unused }, |
| | 11021 | .clobbers = .{ .eflags = true }, |
| | 11022 | .each = .{ .once = &.{ |
| | 11023 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11024 | .{ ._, .p_d, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 11025 | .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 11026 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 11027 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11028 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11029 | .{ ._, .p_d, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11030 | .{ ._, .p_d, .maxs, .tmp4x, .tmp3x, ._, ._ }, |
| | 11031 | .{ ._, .p_d, .mins, .tmp4x, .tmp2x, ._, ._ }, |
| | 11032 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 11033 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11034 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11035 | } }, |
| | 11036 | }, .{ |
| | 11037 | .required_features = .{ .cmov, null, null, null }, |
| | 11038 | .src_constraints = .{ |
| | 11039 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 11040 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 11041 | .any, |
| | 11042 | }, |
| | 11043 | .patterns = &.{ |
| | 11044 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11045 | }, |
| | 11046 | .extra_temps = .{ |
| | 11047 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11048 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11049 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11050 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11051 | .unused, |
| | 11052 | .unused, |
| | 11053 | .unused, |
| | 11054 | .unused, |
| | 11055 | .unused, |
| | 11056 | .unused, |
| | 11057 | .unused, |
| | 11058 | }, |
| | 11059 | .dst_temps = .{ .mem, .unused }, |
| | 11060 | .clobbers = .{ .eflags = true }, |
| | 11061 | .each = .{ .once = &.{ |
| | 11062 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11063 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11064 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 11065 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 11066 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11067 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 11068 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 11069 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 11070 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 11071 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11072 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11073 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11074 | } }, |
| | 11075 | }, .{ |
| | 11076 | .src_constraints = .{ |
| | 11077 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 11078 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 11079 | .any, |
| | 11080 | }, |
| | 11081 | .patterns = &.{ |
| | 11082 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11083 | }, |
| | 11084 | .extra_temps = .{ |
| | 11085 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11086 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11087 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11088 | .unused, |
| | 11089 | .unused, |
| | 11090 | .unused, |
| | 11091 | .unused, |
| | 11092 | .unused, |
| | 11093 | .unused, |
| | 11094 | .unused, |
| | 11095 | .unused, |
| | 11096 | }, |
| | 11097 | .dst_temps = .{ .mem, .unused }, |
| | 11098 | .clobbers = .{ .eflags = true }, |
| | 11099 | .each = .{ .once = &.{ |
| | 11100 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11101 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11102 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11103 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 11104 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 11105 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 11106 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 11107 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 11108 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11109 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11110 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11111 | } }, |
| | 11112 | }, .{ |
| | 11113 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 11114 | .src_constraints = .{ |
| | 11115 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 11116 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 11117 | .any, |
| | 11118 | }, |
| | 11119 | .patterns = &.{ |
| | 11120 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11121 | }, |
| | 11122 | .extra_temps = .{ |
| | 11123 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11124 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11125 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11126 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11127 | .unused, |
| | 11128 | .unused, |
| | 11129 | .unused, |
| | 11130 | .unused, |
| | 11131 | .unused, |
| | 11132 | .unused, |
| | 11133 | .unused, |
| | 11134 | }, |
| | 11135 | .dst_temps = .{ .mem, .unused }, |
| | 11136 | .clobbers = .{ .eflags = true }, |
| | 11137 | .each = .{ .once = &.{ |
| | 11138 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11139 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11140 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 11141 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 11142 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11143 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 11144 | .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ }, |
| | 11145 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 11146 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 11147 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11148 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11149 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11150 | } }, |
| | 11151 | }, .{ |
| | 11152 | .required_features = .{ .cmov, null, null, null }, |
| | 11153 | .src_constraints = .{ |
| | 11154 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 11155 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 11156 | .any, |
| | 11157 | }, |
| | 11158 | .patterns = &.{ |
| | 11159 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11160 | }, |
| | 11161 | .extra_temps = .{ |
| | 11162 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11163 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11164 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11165 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11166 | .unused, |
| | 11167 | .unused, |
| | 11168 | .unused, |
| | 11169 | .unused, |
| | 11170 | .unused, |
| | 11171 | .unused, |
| | 11172 | .unused, |
| | 11173 | }, |
| | 11174 | .dst_temps = .{ .mem, .unused }, |
| | 11175 | .clobbers = .{ .eflags = true }, |
| | 11176 | .each = .{ .once = &.{ |
| | 11177 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11178 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11179 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 11180 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 11181 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11182 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 11183 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 11184 | .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 11185 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 11186 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 11187 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11188 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11189 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11190 | } }, |
| | 11191 | }, .{ |
| | 11192 | .src_constraints = .{ |
| | 11193 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 11194 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 11195 | .any, |
| | 11196 | }, |
| | 11197 | .patterns = &.{ |
| | 11198 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11199 | }, |
| | 11200 | .extra_temps = .{ |
| | 11201 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11202 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11203 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 11204 | .unused, |
| | 11205 | .unused, |
| | 11206 | .unused, |
| | 11207 | .unused, |
| | 11208 | .unused, |
| | 11209 | .unused, |
| | 11210 | .unused, |
| | 11211 | .unused, |
| | 11212 | }, |
| | 11213 | .dst_temps = .{ .mem, .unused }, |
| | 11214 | .clobbers = .{ .eflags = true }, |
| | 11215 | .each = .{ .once = &.{ |
| | 11216 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11217 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11218 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11219 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 11220 | .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 11221 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 11222 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 11223 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 11224 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 11225 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11226 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11227 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11228 | } }, |
| | 11229 | }, .{ |
| | 11230 | .required_features = .{ .avx2, null, null, null }, |
| | 11231 | .src_constraints = .{ |
| | 11232 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } }, |
| | 11233 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 32 } }, |
| | 11234 | .any, |
| | 11235 | }, |
| | 11236 | .patterns = &.{ |
| | 11237 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11238 | }, |
| | 11239 | .extra_temps = .{ |
| | 11240 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11241 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 11242 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 11243 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 11244 | .unused, |
| | 11245 | .unused, |
| | 11246 | .unused, |
| | 11247 | .unused, |
| | 11248 | .unused, |
| | 11249 | .unused, |
| | 11250 | .unused, |
| | 11251 | }, |
| | 11252 | .dst_temps = .{ .mem, .unused }, |
| | 11253 | .clobbers = .{ .eflags = true }, |
| | 11254 | .each = .{ .once = &.{ |
| | 11255 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11256 | .{ ._, .vp_d, .cmpeq, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| | 11257 | .{ .@"0:", .v_dqa, .mov, .tmp2y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11258 | .{ ._, .vp_, .xor, .tmp3y, .tmp2y, .tmp1y, ._ }, |
| | 11259 | .{ ._, .vp_d, .minu, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 11260 | .{ ._, .vp_d, .add, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 11261 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| | 11262 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 11263 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11264 | } }, |
| | 11265 | }, .{ |
| | 11266 | .required_features = .{ .avx, null, null, null }, |
| | 11267 | .src_constraints = .{ |
| | 11268 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 11269 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 11270 | .any, |
| | 11271 | }, |
| | 11272 | .patterns = &.{ |
| | 11273 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11274 | }, |
| | 11275 | .extra_temps = .{ |
| | 11276 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11277 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11278 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11279 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11280 | .unused, |
| | 11281 | .unused, |
| | 11282 | .unused, |
| | 11283 | .unused, |
| | 11284 | .unused, |
| | 11285 | .unused, |
| | 11286 | .unused, |
| | 11287 | }, |
| | 11288 | .dst_temps = .{ .mem, .unused }, |
| | 11289 | .clobbers = .{ .eflags = true }, |
| | 11290 | .each = .{ .once = &.{ |
| | 11291 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11292 | .{ ._, .vp_d, .cmpeq, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| | 11293 | .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11294 | .{ ._, .vp_, .xor, .tmp3x, .tmp2x, .tmp1x, ._ }, |
| | 11295 | .{ ._, .vp_d, .minu, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 11296 | .{ ._, .vp_d, .add, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 11297 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| | 11298 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11299 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11300 | } }, |
| | 11301 | }, .{ |
| | 11302 | .required_features = .{ .sse4_1, null, null, null }, |
| | 11303 | .src_constraints = .{ |
| | 11304 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 11305 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 32 } }, |
| | 11306 | .any, |
| | 11307 | }, |
| | 11308 | .patterns = &.{ |
| | 11309 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11310 | }, |
| | 11311 | .extra_temps = .{ |
| | 11312 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11313 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11314 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11315 | .unused, |
| | 11316 | .unused, |
| | 11317 | .unused, |
| | 11318 | .unused, |
| | 11319 | .unused, |
| | 11320 | .unused, |
| | 11321 | .unused, |
| | 11322 | .unused, |
| | 11323 | }, |
| | 11324 | .dst_temps = .{ .mem, .unused }, |
| | 11325 | .clobbers = .{ .eflags = true }, |
| | 11326 | .each = .{ .once = &.{ |
| | 11327 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11328 | .{ .@"0:", .p_d, .cmpeq, .tmp1x, .tmp1x, ._, ._ }, |
| | 11329 | .{ ._, ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11330 | .{ ._, .p_, .xor, .tmp1x, .tmp2x, ._, ._ }, |
| | 11331 | .{ ._, .p_d, .minu, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11332 | .{ ._, .p_d, .add, .tmp1x, .tmp2x, ._, ._ }, |
| | 11333 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 11334 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11335 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11336 | } }, |
| | 11337 | }, .{ |
| | 11338 | .src_constraints = .{ |
| | 11339 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .dword, .is = 32 } }, |
| | 11340 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .dword, .is = 32 } }, |
| | 11341 | .any, |
| | 11342 | }, |
| | 11343 | .patterns = &.{ |
| | 11344 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11345 | }, |
| | 11346 | .extra_temps = .{ |
| | 11347 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11348 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 11349 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 11350 | .unused, |
| | 11351 | .unused, |
| | 11352 | .unused, |
| | 11353 | .unused, |
| | 11354 | .unused, |
| | 11355 | .unused, |
| | 11356 | .unused, |
| | 11357 | .unused, |
| | 11358 | }, |
| | 11359 | .dst_temps = .{ .mem, .unused }, |
| | 11360 | .clobbers = .{ .eflags = true }, |
| | 11361 | .each = .{ .once = &.{ |
| | 11362 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11363 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11364 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11365 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 11366 | .{ ._, ._, .@"or", .tmp1d, .tmp2d, ._, ._ }, |
| | 11367 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11368 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11369 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11370 | } }, |
| | 11371 | }, .{ |
| | 11372 | .required_features = .{ .avx2, null, null, null }, |
| | 11373 | .src_constraints = .{ |
| | 11374 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 11375 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 11376 | .any, |
| | 11377 | }, |
| | 11378 | .patterns = &.{ |
| | 11379 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11380 | }, |
| | 11381 | .extra_temps = .{ |
| | 11382 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11383 | .{ .type = .u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11384 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 11385 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 11386 | .unused, |
| | 11387 | .unused, |
| | 11388 | .unused, |
| | 11389 | .unused, |
| | 11390 | .unused, |
| | 11391 | .unused, |
| | 11392 | .unused, |
| | 11393 | }, |
| | 11394 | .dst_temps = .{ .mem, .unused }, |
| | 11395 | .clobbers = .{ .eflags = true }, |
| | 11396 | .each = .{ .once = &.{ |
| | 11397 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11398 | .{ ._, .vp_d, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ }, |
| | 11399 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11400 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11401 | .{ ._, .vp_d, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 11402 | .{ ._, .vp_d, .minu, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| | 11403 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 11404 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 11405 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11406 | } }, |
| | 11407 | }, .{ |
| | 11408 | .required_features = .{ .avx, null, null, null }, |
| | 11409 | .src_constraints = .{ |
| | 11410 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 11411 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 11412 | .any, |
| | 11413 | }, |
| | 11414 | .patterns = &.{ |
| | 11415 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11416 | }, |
| | 11417 | .extra_temps = .{ |
| | 11418 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11419 | .{ .type = .u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11420 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11421 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11422 | .unused, |
| | 11423 | .unused, |
| | 11424 | .unused, |
| | 11425 | .unused, |
| | 11426 | .unused, |
| | 11427 | .unused, |
| | 11428 | .unused, |
| | 11429 | }, |
| | 11430 | .dst_temps = .{ .mem, .unused }, |
| | 11431 | .clobbers = .{ .eflags = true }, |
| | 11432 | .each = .{ .once = &.{ |
| | 11433 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11434 | .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ }, |
| | 11435 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11436 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11437 | .{ ._, .vp_d, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 11438 | .{ ._, .vp_d, .minu, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| | 11439 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 11440 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11441 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11442 | } }, |
| | 11443 | }, .{ |
| | 11444 | .required_features = .{ .sse4_1, null, null, null }, |
| | 11445 | .src_constraints = .{ |
| | 11446 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 11447 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 11448 | .any, |
| | 11449 | }, |
| | 11450 | .patterns = &.{ |
| | 11451 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11452 | }, |
| | 11453 | .extra_temps = .{ |
| | 11454 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11455 | .{ .type = .vector_4_u32, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 11456 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11457 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 11458 | .unused, |
| | 11459 | .unused, |
| | 11460 | .unused, |
| | 11461 | .unused, |
| | 11462 | .unused, |
| | 11463 | .unused, |
| | 11464 | .unused, |
| | 11465 | }, |
| | 11466 | .dst_temps = .{ .mem, .unused }, |
| | 11467 | .clobbers = .{ .eflags = true }, |
| | 11468 | .each = .{ .once = &.{ |
| | 11469 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11470 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 11471 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11472 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11473 | .{ ._, .p_d, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11474 | .{ ._, .p_d, .minu, .tmp3x, .tmp2x, ._, ._ }, |
| | 11475 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 11476 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11477 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11478 | } }, |
| | 11479 | }, .{ |
| | 11480 | .required_features = .{ .cmov, null, null, null }, |
| | 11481 | .src_constraints = .{ |
| | 11482 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 11483 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 11484 | .any, |
| | 11485 | }, |
| | 11486 | .patterns = &.{ |
| | 11487 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11488 | }, |
| | 11489 | .extra_temps = .{ |
| | 11490 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11491 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 11492 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 11493 | .unused, |
| | 11494 | .unused, |
| | 11495 | .unused, |
| | 11496 | .unused, |
| | 11497 | .unused, |
| | 11498 | .unused, |
| | 11499 | .unused, |
| | 11500 | .unused, |
| | 11501 | }, |
| | 11502 | .dst_temps = .{ .mem, .unused }, |
| | 11503 | .clobbers = .{ .eflags = true }, |
| | 11504 | .each = .{ .once = &.{ |
| | 11505 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11506 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 11507 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11508 | .{ ._, ._, .add, .tmp2d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11509 | .{ ._, ._, .cmp, .tmp2d, .tmp1d, ._, ._ }, |
| | 11510 | .{ ._, ._a, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 11511 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| | 11512 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11513 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11514 | } }, |
| | 11515 | }, .{ |
| | 11516 | .src_constraints = .{ |
| | 11517 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 11518 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 11519 | .any, |
| | 11520 | }, |
| | 11521 | .patterns = &.{ |
| | 11522 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11523 | }, |
| | 11524 | .extra_temps = .{ |
| | 11525 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11526 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 11527 | .unused, |
| | 11528 | .unused, |
| | 11529 | .unused, |
| | 11530 | .unused, |
| | 11531 | .unused, |
| | 11532 | .unused, |
| | 11533 | .unused, |
| | 11534 | .unused, |
| | 11535 | .unused, |
| | 11536 | }, |
| | 11537 | .dst_temps = .{ .mem, .unused }, |
| | 11538 | .clobbers = .{ .eflags = true }, |
| | 11539 | .each = .{ .once = &.{ |
| | 11540 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11541 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11542 | .{ ._, ._, .add, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11543 | .{ ._, ._, .cmp, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 11544 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 11545 | .{ ._, ._, .mov, .tmp1d, .ua(.src0, .add_umax), ._, ._ }, |
| | 11546 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 11547 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 11548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11549 | } }, |
| | 11550 | }, .{ |
| | 11551 | .required_features = .{ .avx2, null, null, null }, |
| | 11552 | .src_constraints = .{ |
| | 11553 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 11554 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 11555 | .any, |
| | 11556 | }, |
| | 11557 | .patterns = &.{ |
| | 11558 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11559 | }, |
| | 11560 | .extra_temps = .{ |
| | 11561 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11562 | .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11563 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11564 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11565 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11566 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11567 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11568 | .unused, |
| | 11569 | .unused, |
| | 11570 | .unused, |
| | 11571 | .unused, |
| | 11572 | }, |
| | 11573 | .dst_temps = .{ .mem, .unused }, |
| | 11574 | .clobbers = .{ .eflags = true }, |
| | 11575 | .each = .{ .once = &.{ |
| | 11576 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11577 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 11578 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11579 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11580 | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11581 | .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp5y, ._ }, |
| | 11582 | .{ ._, .vp_q, .add, .tmp6y, .tmp3y, .tmp4y, ._ }, |
| | 11583 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp5y, .tmp3y, ._ }, |
| | 11584 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp6y, .tmp3y, ._ }, |
| | 11585 | .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp2y, ._ }, |
| | 11586 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ }, |
| | 11587 | .{ ._, .v_pd, .blendv, .tmp5y, .tmp5y, .tmp6y, .tmp3y }, |
| | 11588 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp5y, ._, ._ }, |
| | 11589 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 11590 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11591 | } }, |
| | 11592 | }, .{ |
| | 11593 | .required_features = .{ .avx, null, null, null }, |
| | 11594 | .src_constraints = .{ |
| | 11595 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 11596 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 11597 | .any, |
| | 11598 | }, |
| | 11599 | .patterns = &.{ |
| | 11600 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11601 | }, |
| | 11602 | .extra_temps = .{ |
| | 11603 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11604 | .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11605 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11606 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11607 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11608 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11609 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11610 | .unused, |
| | 11611 | .unused, |
| | 11612 | .unused, |
| | 11613 | .unused, |
| | 11614 | }, |
| | 11615 | .dst_temps = .{ .mem, .unused }, |
| | 11616 | .clobbers = .{ .eflags = true }, |
| | 11617 | .each = .{ .once = &.{ |
| | 11618 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11619 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 11620 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11621 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11622 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11623 | .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp5x, ._ }, |
| | 11624 | .{ ._, .vp_q, .add, .tmp6x, .tmp3x, .tmp4x, ._ }, |
| | 11625 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp5x, .tmp3x, ._ }, |
| | 11626 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp6x, .tmp3x, ._ }, |
| | 11627 | .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp2x, ._ }, |
| | 11628 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ }, |
| | 11629 | .{ ._, .v_pd, .blendv, .tmp5x, .tmp5x, .tmp6x, .tmp3x }, |
| | 11630 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ }, |
| | 11631 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11632 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11633 | } }, |
| | 11634 | }, .{ |
| | 11635 | .required_features = .{ .sse4_2, null, null, null }, |
| | 11636 | .src_constraints = .{ |
| | 11637 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 11638 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 11639 | .any, |
| | 11640 | }, |
| | 11641 | .patterns = &.{ |
| | 11642 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11643 | }, |
| | 11644 | .extra_temps = .{ |
| | 11645 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11646 | .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11647 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11648 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11649 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11650 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11651 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11652 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 11653 | .unused, |
| | 11654 | .unused, |
| | 11655 | .unused, |
| | 11656 | }, |
| | 11657 | .dst_temps = .{ .mem, .unused }, |
| | 11658 | .clobbers = .{ .eflags = true }, |
| | 11659 | .each = .{ .once = &.{ |
| | 11660 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11661 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 11662 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11663 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11664 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11665 | .{ ._, .p_, .xor, .tmp5x, .tmp5x, ._, ._ }, |
| | 11666 | .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ }, |
| | 11667 | .{ ._, .p_q, .add, .tmp6x, .tmp4x, ._, ._ }, |
| | 11668 | .{ ._, .p_q, .cmpgt, .tmp5x, .tmp3x, ._, ._ }, |
| | 11669 | .{ ._, ._dqa, .mov, .tmp7x, .tmp6x, ._, ._ }, |
| | 11670 | .{ ._, .p_q, .cmpgt, .tmp7x, .tmp3x, ._, ._ }, |
| | 11671 | .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ }, |
| | 11672 | .{ ._, .p_, .xor, .tmp7x, .tmp4x, ._, ._ }, |
| | 11673 | .{ ._, ._pd, .blendv, .tmp5x, .tmp6x, .tmp7x, ._ }, |
| | 11674 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ }, |
| | 11675 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11676 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11677 | } }, |
| | 11678 | }, .{ |
| | 11679 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 11680 | .src_constraints = .{ |
| | 11681 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 11682 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 11683 | .any, |
| | 11684 | }, |
| | 11685 | .patterns = &.{ |
| | 11686 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11687 | }, |
| | 11688 | .extra_temps = .{ |
| | 11689 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11690 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11691 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11692 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11693 | .unused, |
| | 11694 | .unused, |
| | 11695 | .unused, |
| | 11696 | .unused, |
| | 11697 | .unused, |
| | 11698 | .unused, |
| | 11699 | .unused, |
| | 11700 | }, |
| | 11701 | .dst_temps = .{ .mem, .unused }, |
| | 11702 | .clobbers = .{ .eflags = true }, |
| | 11703 | .each = .{ .once = &.{ |
| | 11704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11705 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 11706 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11707 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 11708 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 11709 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 11710 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11711 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 11712 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 11713 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 11714 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11715 | } }, |
| | 11716 | }, .{ |
| | 11717 | .required_features = .{ .@"64bit", null, null, null }, |
| | 11718 | .src_constraints = .{ |
| | 11719 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 11720 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 11721 | .any, |
| | 11722 | }, |
| | 11723 | .patterns = &.{ |
| | 11724 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11725 | }, |
| | 11726 | .extra_temps = .{ |
| | 11727 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11728 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11729 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11730 | .unused, |
| | 11731 | .unused, |
| | 11732 | .unused, |
| | 11733 | .unused, |
| | 11734 | .unused, |
| | 11735 | .unused, |
| | 11736 | .unused, |
| | 11737 | .unused, |
| | 11738 | }, |
| | 11739 | .dst_temps = .{ .mem, .unused }, |
| | 11740 | .clobbers = .{ .eflags = true }, |
| | 11741 | .each = .{ .once = &.{ |
| | 11742 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11743 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ }, |
| | 11744 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11745 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11746 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 11747 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 11748 | .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ }, |
| | 11749 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 11750 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 11751 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11752 | } }, |
| | 11753 | }, .{ |
| | 11754 | .required_features = .{ .avx2, null, null, null }, |
| | 11755 | .src_constraints = .{ |
| | 11756 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 11757 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 11758 | .any, |
| | 11759 | }, |
| | 11760 | .patterns = &.{ |
| | 11761 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11762 | }, |
| | 11763 | .extra_temps = .{ |
| | 11764 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11765 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11766 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11767 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11768 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11769 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 11770 | .unused, |
| | 11771 | .unused, |
| | 11772 | .unused, |
| | 11773 | .unused, |
| | 11774 | .unused, |
| | 11775 | }, |
| | 11776 | .dst_temps = .{ .mem, .unused }, |
| | 11777 | .clobbers = .{ .eflags = true }, |
| | 11778 | .each = .{ .once = &.{ |
| | 11779 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11780 | .{ ._, .vp_q, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 11781 | .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp0q), ._, ._ }, |
| | 11782 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 11783 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11784 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11785 | .{ ._, .vp_q, .add, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 11786 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp3y, .tmp4y, ._ }, |
| | 11787 | .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp3y, .tmp5y }, |
| | 11788 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .tmp2y, ._ }, |
| | 11789 | .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp2y, .tmp5y }, |
| | 11790 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 11791 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 11792 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11793 | } }, |
| | 11794 | }, .{ |
| | 11795 | .required_features = .{ .avx, null, null, null }, |
| | 11796 | .src_constraints = .{ |
| | 11797 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 11798 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 11799 | .any, |
| | 11800 | }, |
| | 11801 | .patterns = &.{ |
| | 11802 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11803 | }, |
| | 11804 | .extra_temps = .{ |
| | 11805 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11806 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11807 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11808 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11809 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11810 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11811 | .unused, |
| | 11812 | .unused, |
| | 11813 | .unused, |
| | 11814 | .unused, |
| | 11815 | .unused, |
| | 11816 | }, |
| | 11817 | .dst_temps = .{ .mem, .unused }, |
| | 11818 | .clobbers = .{ .eflags = true }, |
| | 11819 | .each = .{ .once = &.{ |
| | 11820 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11821 | .{ ._, .vp_q, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 11822 | .{ ._, .v_, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ }, |
| | 11823 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 11824 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11825 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11826 | .{ ._, .vp_q, .add, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 11827 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp3x, .tmp4x, ._ }, |
| | 11828 | .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp3x, .tmp5x }, |
| | 11829 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .tmp2x, ._ }, |
| | 11830 | .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp2x, .tmp5x }, |
| | 11831 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 11832 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11833 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11834 | } }, |
| | 11835 | }, .{ |
| | 11836 | .required_features = .{ .sse4_2, null, null, null }, |
| | 11837 | .src_constraints = .{ |
| | 11838 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 11839 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 11840 | .any, |
| | 11841 | }, |
| | 11842 | .patterns = &.{ |
| | 11843 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11844 | }, |
| | 11845 | .extra_temps = .{ |
| | 11846 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11847 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 11848 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11849 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11850 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 11851 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 11852 | .unused, |
| | 11853 | .unused, |
| | 11854 | .unused, |
| | 11855 | .unused, |
| | 11856 | .unused, |
| | 11857 | }, |
| | 11858 | .dst_temps = .{ .mem, .unused }, |
| | 11859 | .clobbers = .{ .eflags = true }, |
| | 11860 | .each = .{ .once = &.{ |
| | 11861 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 11862 | .{ ._, .p_q, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 11863 | .{ ._, ._, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ }, |
| | 11864 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 11865 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11866 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11867 | .{ ._, .p_q, .add, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11868 | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| | 11869 | .{ ._, .p_q, .cmpgt, .tmp5x, .tmp4x, ._, ._ }, |
| | 11870 | .{ ._, .p_b, .blendv, .tmp4x, .tmp3x, .tmp5x, ._ }, |
| | 11871 | .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, |
| | 11872 | .{ ._, .p_q, .cmpgt, .tmp5x, .tmp2x, ._, ._ }, |
| | 11873 | .{ ._, .p_b, .blendv, .tmp4x, .tmp2x, .tmp5x, ._ }, |
| | 11874 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 11875 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 11876 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11877 | } }, |
| | 11878 | }, .{ |
| | 11879 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 11880 | .src_constraints = .{ |
| | 11881 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 11882 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 11883 | .any, |
| | 11884 | }, |
| | 11885 | .patterns = &.{ |
| | 11886 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11887 | }, |
| | 11888 | .extra_temps = .{ |
| | 11889 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11890 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11891 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11892 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11893 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11894 | .unused, |
| | 11895 | .unused, |
| | 11896 | .unused, |
| | 11897 | .unused, |
| | 11898 | .unused, |
| | 11899 | .unused, |
| | 11900 | }, |
| | 11901 | .dst_temps = .{ .mem, .unused }, |
| | 11902 | .clobbers = .{ .eflags = true }, |
| | 11903 | .each = .{ .once = &.{ |
| | 11904 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11905 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 11906 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11907 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 11908 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 11909 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11910 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 11911 | .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ }, |
| | 11912 | .{ ._, ._, .add, .tmp4q, .tmp4q, ._, ._ }, |
| | 11913 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 11914 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 11915 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 11916 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11917 | } }, |
| | 11918 | }, .{ |
| | 11919 | .required_features = .{ .@"64bit", null, null, null }, |
| | 11920 | .src_constraints = .{ |
| | 11921 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 11922 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 11923 | .any, |
| | 11924 | }, |
| | 11925 | .patterns = &.{ |
| | 11926 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11927 | }, |
| | 11928 | .extra_temps = .{ |
| | 11929 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11930 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11931 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11932 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11933 | .unused, |
| | 11934 | .unused, |
| | 11935 | .unused, |
| | 11936 | .unused, |
| | 11937 | .unused, |
| | 11938 | .unused, |
| | 11939 | .unused, |
| | 11940 | }, |
| | 11941 | .dst_temps = .{ .mem, .unused }, |
| | 11942 | .clobbers = .{ .eflags = true }, |
| | 11943 | .each = .{ .once = &.{ |
| | 11944 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11945 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 11946 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11947 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11948 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 11949 | .{ ._, ._, .add, .tmp3q, .tmp3q, ._, ._ }, |
| | 11950 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 11951 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 11952 | .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ }, |
| | 11953 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 11954 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 11955 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11956 | } }, |
| | 11957 | }, .{ |
| | 11958 | .required_features = .{ .@"64bit", .bmi2, .cmov, null }, |
| | 11959 | .src_constraints = .{ |
| | 11960 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 11961 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 11962 | .any, |
| | 11963 | }, |
| | 11964 | .patterns = &.{ |
| | 11965 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 11966 | }, |
| | 11967 | .extra_temps = .{ |
| | 11968 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 11969 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11970 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11971 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11972 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 11973 | .unused, |
| | 11974 | .unused, |
| | 11975 | .unused, |
| | 11976 | .unused, |
| | 11977 | .unused, |
| | 11978 | .unused, |
| | 11979 | }, |
| | 11980 | .dst_temps = .{ .mem, .unused }, |
| | 11981 | .clobbers = .{ .eflags = true }, |
| | 11982 | .each = .{ .once = &.{ |
| | 11983 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 11984 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 11985 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11986 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 11987 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 11988 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 11989 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 11990 | .{ ._, ._rx, .ro, .tmp4q, .tmp2q, .sia(-31, .src0, .add_bit_size_rem_64), ._ }, |
| | 11991 | .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ }, |
| | 11992 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 11993 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 11994 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 11995 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 11996 | } }, |
| | 11997 | }, .{ |
| | 11998 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 11999 | .src_constraints = .{ |
| | 12000 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 12001 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 12002 | .any, |
| | 12003 | }, |
| | 12004 | .patterns = &.{ |
| | 12005 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12006 | }, |
| | 12007 | .extra_temps = .{ |
| | 12008 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12009 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12010 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12011 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12012 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12013 | .unused, |
| | 12014 | .unused, |
| | 12015 | .unused, |
| | 12016 | .unused, |
| | 12017 | .unused, |
| | 12018 | .unused, |
| | 12019 | }, |
| | 12020 | .dst_temps = .{ .mem, .unused }, |
| | 12021 | .clobbers = .{ .eflags = true }, |
| | 12022 | .each = .{ .once = &.{ |
| | 12023 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12024 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 12025 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12026 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 12027 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 12028 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12029 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 12030 | .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ }, |
| | 12031 | .{ ._, ._r, .sa, .tmp4q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ }, |
| | 12032 | .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ }, |
| | 12033 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 12034 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 12035 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 12036 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12037 | } }, |
| | 12038 | }, .{ |
| | 12039 | .required_features = .{ .@"64bit", null, null, null }, |
| | 12040 | .src_constraints = .{ |
| | 12041 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 12042 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 12043 | .any, |
| | 12044 | }, |
| | 12045 | .patterns = &.{ |
| | 12046 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12047 | }, |
| | 12048 | .extra_temps = .{ |
| | 12049 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12050 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12051 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12052 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 12053 | .unused, |
| | 12054 | .unused, |
| | 12055 | .unused, |
| | 12056 | .unused, |
| | 12057 | .unused, |
| | 12058 | .unused, |
| | 12059 | .unused, |
| | 12060 | }, |
| | 12061 | .dst_temps = .{ .mem, .unused }, |
| | 12062 | .clobbers = .{ .eflags = true }, |
| | 12063 | .each = .{ .once = &.{ |
| | 12064 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12065 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 12066 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12067 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12068 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 12069 | .{ ._, ._r, .sa, .tmp3q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ }, |
| | 12070 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 12071 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 12072 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 12073 | .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ }, |
| | 12074 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 12075 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 12076 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12077 | } }, |
| | 12078 | }, .{ |
| | 12079 | .required_features = .{ .avx2, null, null, null }, |
| | 12080 | .src_constraints = .{ |
| | 12081 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 12082 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 12083 | .any, |
| | 12084 | }, |
| | 12085 | .patterns = &.{ |
| | 12086 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12087 | }, |
| | 12088 | .extra_temps = .{ |
| | 12089 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12090 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 12091 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12092 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12093 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12094 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12095 | .unused, |
| | 12096 | .unused, |
| | 12097 | .unused, |
| | 12098 | .unused, |
| | 12099 | .unused, |
| | 12100 | }, |
| | 12101 | .dst_temps = .{ .mem, .unused }, |
| | 12102 | .clobbers = .{ .eflags = true }, |
| | 12103 | .each = .{ .once = &.{ |
| | 12104 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 12105 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 12106 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12107 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12108 | .{ ._, .vp_, .xor, .tmp4y, .tmp3y, .tmp2y, ._ }, |
| | 12109 | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 12110 | .{ ._, .vp_, .xor, .tmp5y, .tmp3y, .tmp2y, ._ }, |
| | 12111 | .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp4y, .tmp5y, ._ }, |
| | 12112 | .{ ._, .vp_, .@"or", .tmp3y, .tmp3y, .tmp4y, ._ }, |
| | 12113 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 12114 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 12115 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12116 | } }, |
| | 12117 | }, .{ |
| | 12118 | .required_features = .{ .avx, null, null, null }, |
| | 12119 | .src_constraints = .{ |
| | 12120 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 12121 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 12122 | .any, |
| | 12123 | }, |
| | 12124 | .patterns = &.{ |
| | 12125 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12126 | }, |
| | 12127 | .extra_temps = .{ |
| | 12128 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12129 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 12130 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12131 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12132 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12133 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12134 | .unused, |
| | 12135 | .unused, |
| | 12136 | .unused, |
| | 12137 | .unused, |
| | 12138 | .unused, |
| | 12139 | }, |
| | 12140 | .dst_temps = .{ .mem, .unused }, |
| | 12141 | .clobbers = .{ .eflags = true }, |
| | 12142 | .each = .{ .once = &.{ |
| | 12143 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 12144 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 12145 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12146 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12147 | .{ ._, .vp_, .xor, .tmp4x, .tmp3x, .tmp2x, ._ }, |
| | 12148 | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 12149 | .{ ._, .vp_, .xor, .tmp5x, .tmp3x, .tmp2x, ._ }, |
| | 12150 | .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp4x, .tmp5x, ._ }, |
| | 12151 | .{ ._, .vp_, .@"or", .tmp3x, .tmp3x, .tmp4x, ._ }, |
| | 12152 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 12153 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 12154 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12155 | } }, |
| | 12156 | }, .{ |
| | 12157 | .required_features = .{ .sse4_2, null, null, null }, |
| | 12158 | .src_constraints = .{ |
| | 12159 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 12160 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 12161 | .any, |
| | 12162 | }, |
| | 12163 | .patterns = &.{ |
| | 12164 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12165 | }, |
| | 12166 | .extra_temps = .{ |
| | 12167 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12168 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 12169 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12170 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12171 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12172 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12173 | .unused, |
| | 12174 | .unused, |
| | 12175 | .unused, |
| | 12176 | .unused, |
| | 12177 | .unused, |
| | 12178 | }, |
| | 12179 | .dst_temps = .{ .mem, .unused }, |
| | 12180 | .clobbers = .{ .eflags = true }, |
| | 12181 | .each = .{ .once = &.{ |
| | 12182 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 12183 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 12184 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12185 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12186 | .{ ._, ._dqa, .mov, .tmp4x, .tmp2x, ._, ._ }, |
| | 12187 | .{ ._, .p_, .xor, .tmp4x, .tmp3x, ._, ._ }, |
| | 12188 | .{ ._, .p_q, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12189 | .{ ._, ._dqa, .mov, .tmp5x, .tmp2x, ._, ._ }, |
| | 12190 | .{ ._, .p_, .xor, .tmp5x, .tmp3x, ._, ._ }, |
| | 12191 | .{ ._, .p_q, .cmpgt, .tmp4x, .tmp5x, ._, ._ }, |
| | 12192 | .{ ._, .p_, .@"or", .tmp3x, .tmp4x, ._, ._ }, |
| | 12193 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 12194 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 12195 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12196 | } }, |
| | 12197 | }, .{ |
| | 12198 | .required_features = .{ .@"64bit", null, null, null }, |
| | 12199 | .src_constraints = .{ |
| | 12200 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } }, |
| | 12201 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } }, |
| | 12202 | .any, |
| | 12203 | }, |
| | 12204 | .patterns = &.{ |
| | 12205 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12206 | }, |
| | 12207 | .extra_temps = .{ |
| | 12208 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12209 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 12210 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 12211 | .unused, |
| | 12212 | .unused, |
| | 12213 | .unused, |
| | 12214 | .unused, |
| | 12215 | .unused, |
| | 12216 | .unused, |
| | 12217 | .unused, |
| | 12218 | .unused, |
| | 12219 | }, |
| | 12220 | .dst_temps = .{ .mem, .unused }, |
| | 12221 | .clobbers = .{ .eflags = true }, |
| | 12222 | .each = .{ .once = &.{ |
| | 12223 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12224 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12225 | .{ ._, ._, .add, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12226 | .{ ._, ._, .sbb, .tmp2q, .tmp2q, ._, ._ }, |
| | 12227 | .{ ._, ._, .@"or", .tmp1q, .tmp2q, ._, ._ }, |
| | 12228 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 12229 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 12230 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12231 | } }, |
| | 12232 | }, .{ |
| | 12233 | .required_features = .{ .avx2, null, null, null }, |
| | 12234 | .src_constraints = .{ |
| | 12235 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } }, |
| | 12236 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 63 } }, |
| | 12237 | .any, |
| | 12238 | }, |
| | 12239 | .patterns = &.{ |
| | 12240 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12241 | }, |
| | 12242 | .extra_temps = .{ |
| | 12243 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12244 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 12245 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12246 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12247 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 12248 | .unused, |
| | 12249 | .unused, |
| | 12250 | .unused, |
| | 12251 | .unused, |
| | 12252 | .unused, |
| | 12253 | .unused, |
| | 12254 | }, |
| | 12255 | .dst_temps = .{ .mem, .unused }, |
| | 12256 | .clobbers = .{ .eflags = true }, |
| | 12257 | .each = .{ .once = &.{ |
| | 12258 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 12259 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 12260 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12261 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12262 | .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp4y, ._ }, |
| | 12263 | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 12264 | .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 12265 | .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp2y, .tmp4y }, |
| | 12266 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 12267 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 12268 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12269 | } }, |
| | 12270 | }, .{ |
| | 12271 | .required_features = .{ .avx, null, null, null }, |
| | 12272 | .src_constraints = .{ |
| | 12273 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 12274 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 12275 | .any, |
| | 12276 | }, |
| | 12277 | .patterns = &.{ |
| | 12278 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 12279 | }, |
| | 12280 | .extra_temps = .{ |
| | 12281 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12282 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 12283 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12284 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12285 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 12286 | .unused, |
| | 12287 | .unused, |
| | 12288 | .unused, |
| | 12289 | .unused, |
| | 12290 | .unused, |
| | 12291 | .unused, |
| | 12292 | }, |
| | 12293 | .dst_temps = .{ .mem, .unused }, |
| | 12294 | .clobbers = .{ .eflags = true }, |
| | 12295 | .each = .{ .once = &.{ |
| | 12296 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 12297 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 12298 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12299 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12300 | .{ ._, .vp_, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, |
| | 12301 | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 12302 | .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 12303 | .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp2x, .tmp4x }, |
| | 12304 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 12305 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 12306 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 12307 | } }, |
| | 12308 | }, .{ |
| | 12309 | .required_features = .{ .sse4_2, null, null, null }, |
| | 12310 | .src_constraints = .{ |
| | 12311 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 12312 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 63 } }, |
| | 12313 | .any, |
| | 12314 | }, |
| | 12315 | .patterns = &.{ |
| | 12316 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5644 | }, | 12317 | }, |
| 5645 | .extra_temps = .{ | 12318 | .extra_temps = .{ |
| 5646 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 12319 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5647 | .unused, | 12320 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5648 | .unused, | 12321 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5649 | .unused, | 12322 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5650 | .unused, | 12323 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 5651 | .unused, | 12324 | .unused, |
| 5652 | .unused, | 12325 | .unused, |
| 5653 | .unused, | 12326 | .unused, |
| ... | @@ -5655,33 +12328,37 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5655,33 +12328,37 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5655 | .unused, | 12328 | .unused, |
| 5656 | .unused, | 12329 | .unused, |
| 5657 | }, | 12330 | }, |
| 5658 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 12331 | .dst_temps = .{ .mem, .unused }, |
| 5659 | .clobbers = .{ .eflags = true }, | 12332 | .clobbers = .{ .eflags = true }, |
| 5660 | .each = .{ .once = &.{ | 12333 | .each = .{ .once = &.{ |
| 5661 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | 12334 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5662 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, | 12335 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 5663 | .{ ._, ._, .add, .tmp0q, .tmp0q, ._, ._ }, | 12336 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5664 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, | 12337 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5665 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, | 12338 | .{ ._, .p_, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 5666 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ }, | 12339 | .{ ._, .p_q, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5667 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, | 12340 | .{ ._, .p_q, .cmpgt, .tmp4x, .tmp3x, ._, ._ }, |
| | 12341 | .{ ._, .p_b, .blendv, .tmp3x, .tmp2x, .tmp4x, ._ }, |
| | 12342 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 12343 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 12344 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5668 | } }, | 12345 | } }, |
| 5669 | }, .{ | 12346 | }, .{ |
| 5670 | .required_features = .{ .@"64bit", .cmov, null, null }, | 12347 | .required_features = .{ .avx2, null, null, null }, |
| 5671 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, | 12348 | .src_constraints = .{ |
| | 12349 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 12350 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 12351 | .any, |
| | 12352 | }, |
| 5672 | .patterns = &.{ | 12353 | .patterns = &.{ |
| 5673 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | 12354 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5674 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5675 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | | |
| 5676 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5677 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | | |
| 5678 | }, | 12355 | }, |
| 5679 | .extra_temps = .{ | 12356 | .extra_temps = .{ |
| 5680 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 12357 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5681 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 12358 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5682 | .unused, | 12359 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5683 | .unused, | 12360 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5684 | .unused, | 12361 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| 5685 | .unused, | 12362 | .unused, |
| 5686 | .unused, | 12363 | .unused, |
| 5687 | .unused, | 12364 | .unused, |
| ... | @@ -5689,35 +12366,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5689,35 +12366,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5689 | .unused, | 12366 | .unused, |
| 5690 | .unused, | 12367 | .unused, |
| 5691 | }, | 12368 | }, |
| 5692 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 12369 | .dst_temps = .{ .mem, .unused }, |
| 5693 | .clobbers = .{ .eflags = true }, | 12370 | .clobbers = .{ .eflags = true }, |
| 5694 | .each = .{ .once = &.{ | 12371 | .each = .{ .once = &.{ |
| 5695 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, | 12372 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5696 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 12373 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| 5697 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | 12374 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5698 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, | 12375 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5699 | .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ }, | 12376 | .{ ._, .vp_q, .add, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| 5700 | .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ }, | 12377 | .{ ._, .vp_q, .cmpgt, .tmp4y, .tmp3y, .tmp2y, ._ }, |
| 5701 | .{ ._, ._r, .sh, .tmp1q, .sia(-31, .src0, .add_bit_size), ._, ._ }, | 12378 | .{ ._, .vp_b, .blendv, .tmp3y, .tmp3y, .tmp2y, .tmp4y }, |
| 5702 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, | 12379 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| 5703 | .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ }, | 12380 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 12381 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5704 | } }, | 12382 | } }, |
| 5705 | }, .{ | 12383 | }, .{ |
| 5706 | .required_features = .{ .@"64bit", null, null, null }, | 12384 | .required_features = .{ .avx, null, null, null }, |
| 5707 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, | 12385 | .src_constraints = .{ |
| | 12386 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 12387 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 12388 | .any, |
| | 12389 | }, |
| 5708 | .patterns = &.{ | 12390 | .patterns = &.{ |
| 5709 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | 12391 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5710 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5711 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | | |
| 5712 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5713 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | | |
| 5714 | }, | 12392 | }, |
| 5715 | .extra_temps = .{ | 12393 | .extra_temps = .{ |
| 5716 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 12394 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5717 | .unused, | 12395 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5718 | .unused, | 12396 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5719 | .unused, | 12397 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5720 | .unused, | 12398 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5721 | .unused, | 12399 | .unused, |
| 5722 | .unused, | 12400 | .unused, |
| 5723 | .unused, | 12401 | .unused, |
| ... | @@ -5725,34 +12403,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5725,34 +12403,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5725 | .unused, | 12403 | .unused, |
| 5726 | .unused, | 12404 | .unused, |
| 5727 | }, | 12405 | }, |
| 5728 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 12406 | .dst_temps = .{ .mem, .unused }, |
| 5729 | .clobbers = .{ .eflags = true }, | 12407 | .clobbers = .{ .eflags = true }, |
| 5730 | .each = .{ .once = &.{ | 12408 | .each = .{ .once = &.{ |
| 5731 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | 12409 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5732 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, | 12410 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 5733 | .{ ._, ._r, .sh, .tmp0q, .sia(-31, .src0, .add_bit_size), ._, ._ }, | 12411 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5734 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, | 12412 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5735 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, | 12413 | .{ ._, .vp_q, .add, .tmp3x, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| 5736 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, | 12414 | .{ ._, .vp_q, .cmpgt, .tmp4x, .tmp3x, .tmp2x, ._ }, |
| 5737 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ }, | 12415 | .{ ._, .vp_b, .blendv, .tmp3x, .tmp3x, .tmp2x, .tmp4x }, |
| 5738 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, | 12416 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 12417 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 12418 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5739 | } }, | 12419 | } }, |
| 5740 | }, .{ | 12420 | }, .{ |
| 5741 | .required_features = .{ .@"64bit", null, null, null }, | 12421 | .required_features = .{ .sse4_2, null, null, null }, |
| 5742 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, | 12422 | .src_constraints = .{ |
| | 12423 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 12424 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 12425 | .any, |
| | 12426 | }, |
| 5743 | .patterns = &.{ | 12427 | .patterns = &.{ |
| 5744 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | 12428 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5745 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5746 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | | |
| 5747 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5748 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | | |
| 5749 | }, | 12429 | }, |
| 5750 | .extra_temps = .{ | 12430 | .extra_temps = .{ |
| 5751 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 12431 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5752 | .unused, | 12432 | .{ .type = .u64, .kind = .{ .umax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| 5753 | .unused, | 12433 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5754 | .unused, | 12434 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| 5755 | .unused, | 12435 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| 5756 | .unused, | 12436 | .unused, |
| 5757 | .unused, | 12437 | .unused, |
| 5758 | .unused, | 12438 | .unused, |
| ... | @@ -5760,27 +12440,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5760,27 +12440,35 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5760 | .unused, | 12440 | .unused, |
| 5761 | .unused, | 12441 | .unused, |
| 5762 | }, | 12442 | }, |
| 5763 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 12443 | .dst_temps = .{ .mem, .unused }, |
| 5764 | .clobbers = .{ .eflags = true }, | 12444 | .clobbers = .{ .eflags = true }, |
| 5765 | .each = .{ .once = &.{ | 12445 | .each = .{ .once = &.{ |
| 5766 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | 12446 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 5767 | .{ ._, ._, .sbb, .tmp0q, .tmp0q, ._, ._ }, | 12447 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| 5768 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, | 12448 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 12449 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12450 | .{ ._, .p_q, .add, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12451 | .{ ._, ._dqa, .mov, .tmp4x, .tmp3x, ._, ._ }, |
| | 12452 | .{ ._, .p_q, .cmpgt, .tmp4x, .tmp2x, ._, ._ }, |
| | 12453 | .{ ._, .p_b, .blendv, .tmp3x, .tmp2x, .tmp4x, ._ }, |
| | 12454 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 12455 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 12456 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5769 | } }, | 12457 | } }, |
| 5770 | }, .{ | 12458 | }, .{ |
| 5771 | .required_features = .{ .@"64bit", .cmov, null, null }, | 12459 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5772 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, | 12460 | .src_constraints = .{ |
| | 12461 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 12462 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 12463 | .any, |
| | 12464 | }, |
| 5773 | .patterns = &.{ | 12465 | .patterns = &.{ |
| 5774 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | 12466 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5775 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5776 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | | |
| 5777 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5778 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | | |
| 5779 | }, | 12467 | }, |
| 5780 | .extra_temps = .{ | 12468 | .extra_temps = .{ |
| | 12469 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12470 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5781 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 12471 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5782 | .unused, | | |
| 5783 | .unused, | | |
| 5784 | .unused, | 12472 | .unused, |
| 5785 | .unused, | 12473 | .unused, |
| 5786 | .unused, | 12474 | .unused, |
| ... | @@ -5790,25 +12478,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5790,25 +12478,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5790 | .unused, | 12478 | .unused, |
| 5791 | .unused, | 12479 | .unused, |
| 5792 | }, | 12480 | }, |
| 5793 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 12481 | .dst_temps = .{ .mem, .unused }, |
| 5794 | .clobbers = .{ .eflags = true }, | 12482 | .clobbers = .{ .eflags = true }, |
| 5795 | .each = .{ .once = &.{ | 12483 | .each = .{ .once = &.{ |
| 5796 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | 12484 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5797 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, | 12485 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| 5798 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, | 12486 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5799 | .{ ._, ._a, .cmov, .dst0q, .tmp0q, ._, ._ }, | 12487 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12488 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, |
| | 12489 | .{ ._, ._a, .cmov, .tmp2q, .tmp1q, ._, ._ }, |
| | 12490 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 12491 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 12492 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5800 | } }, | 12493 | } }, |
| 5801 | }, .{ | 12494 | }, .{ |
| 5802 | .required_features = .{ .@"64bit", null, null, null }, | 12495 | .required_features = .{ .@"64bit", null, null, null }, |
| 5803 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, | 12496 | .src_constraints = .{ |
| | 12497 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 12498 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 12499 | .any, |
| | 12500 | }, |
| 5804 | .patterns = &.{ | 12501 | .patterns = &.{ |
| 5805 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | 12502 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5806 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5807 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | | |
| 5808 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5809 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | | |
| 5810 | }, | 12503 | }, |
| 5811 | .extra_temps = .{ | 12504 | .extra_temps = .{ |
| | 12505 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12506 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5812 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, | 12507 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5813 | .unused, | 12508 | .unused, |
| 5814 | .unused, | 12509 | .unused, |
| ... | @@ -5818,47 +12513,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5818,47 +12513,36 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5818 | .unused, | 12513 | .unused, |
| 5819 | .unused, | 12514 | .unused, |
| 5820 | .unused, | 12515 | .unused, |
| 5821 | .unused, | | |
| 5822 | .unused, | | |
| 5823 | }, | | |
| 5824 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | | |
| 5825 | .clobbers = .{ .eflags = true }, | | |
| 5826 | .each = .{ .once = &.{ | | |
| 5827 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | | |
| 5828 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, | | |
| 5829 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, | | |
| 5830 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, | | |
| 5831 | .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ }, | | |
| 5832 | } }, | | |
| 5833 | }, .{ | | |
| 5834 | .required_features = .{ .@"64bit", null, null, null }, | | |
| 5835 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, | | |
| 5836 | .patterns = &.{ | | |
| 5837 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, | | |
| 5838 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5839 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, | | |
| 5840 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, | | |
| 5841 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, | | |
| 5842 | }, | 12516 | }, |
| 5843 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 12517 | .dst_temps = .{ .mem, .unused }, |
| 5844 | .clobbers = .{ .eflags = true }, | 12518 | .clobbers = .{ .eflags = true }, |
| 5845 | .each = .{ .once = &.{ | 12519 | .each = .{ .once = &.{ |
| 5846 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, | 12520 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5847 | .{ ._, ._, .cmp, .dst0q, .ua(.src0, .add_umax), ._, ._ }, | 12521 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| 5848 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, | 12522 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 5849 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, | 12523 | .{ ._, ._, .add, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 12524 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, |
| | 12525 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 12526 | .{ ._, ._, .mov, .tmp2q, .tmp1q, ._, ._ }, |
| | 12527 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 12528 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 12529 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5850 | } }, | 12530 | } }, |
| 5851 | }, .{ | 12531 | }, .{ |
| 5852 | .required_features = .{ .@"64bit", null, null, null }, | 12532 | .required_features = .{ .@"64bit", null, null, null }, |
| 5853 | .src_constraints = .{ | 12533 | .src_constraints = .{ |
| 5854 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, | 12534 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 5855 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, | 12535 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 5856 | .any, | 12536 | .any, |
| 5857 | }, | 12537 | }, |
| 5858 | .patterns = &.{ | 12538 | .patterns = &.{ |
| 5859 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12539 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5860 | }, | 12540 | }, |
| 5861 | .extra_temps = .{ | 12541 | .extra_temps = .{ |
| | 12542 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12543 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12544 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12545 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 5862 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12546 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5863 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12547 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 5864 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12548 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| ... | @@ -5866,82 +12550,94 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5866,82 +12550,94 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5866 | .unused, | 12550 | .unused, |
| 5867 | .unused, | 12551 | .unused, |
| 5868 | .unused, | 12552 | .unused, |
| 5869 | .unused, | | |
| 5870 | .unused, | | |
| 5871 | .unused, | | |
| 5872 | .unused, | | |
| 5873 | }, | 12553 | }, |
| 5874 | .dst_temps = .{ .mem, .unused }, | 12554 | .dst_temps = .{ .mem, .unused }, |
| 5875 | .clobbers = .{ .eflags = true }, | 12555 | .clobbers = .{ .eflags = true }, |
| 5876 | .each = .{ .once = &.{ | 12556 | .each = .{ .once = &.{ |
| 5877 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 12557 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5878 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 12558 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5879 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 12559 | .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 5880 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 12560 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 5881 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, | 12561 | .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 5882 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 12562 | .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ }, |
| 5883 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 12563 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| 5884 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, | 12564 | .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| 5885 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, | 12565 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| 5886 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, | 12566 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| 5887 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 12567 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 5888 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 12568 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| 5889 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, | 12569 | .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ }, |
| | 12570 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 12571 | .{ ._, ._, .lea, .tmp4p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, |
| | 12572 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 12573 | .{ ._, ._, .mov, .tmp6d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 5890 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12574 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 5891 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, | 12575 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, |
| 5892 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, | 12576 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, |
| 5893 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, | 12577 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| | 12578 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12579 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5894 | } }, | 12580 | } }, |
| 5895 | }, .{ | 12581 | }, .{ |
| 5896 | .required_features = .{ .@"64bit", null, null, null }, | 12582 | .required_features = .{ .@"64bit", null, null, null }, |
| 5897 | .src_constraints = .{ | 12583 | .src_constraints = .{ |
| 5898 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, | 12584 | .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 5899 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, | 12585 | .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 5900 | .any, | 12586 | .any, |
| 5901 | }, | 12587 | }, |
| 5902 | .patterns = &.{ | 12588 | .patterns = &.{ |
| 5903 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12589 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5904 | }, | 12590 | }, |
| 5905 | .extra_temps = .{ | 12591 | .extra_temps = .{ |
| 5906 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12592 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5907 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 12593 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 12594 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12595 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12596 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12597 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5908 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12598 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5909 | .unused, | 12599 | .unused, |
| 5910 | .unused, | 12600 | .unused, |
| 5911 | .unused, | 12601 | .unused, |
| 5912 | .unused, | 12602 | .unused, |
| 5913 | .unused, | | |
| 5914 | .unused, | | |
| 5915 | .unused, | | |
| 5916 | .unused, | | |
| 5917 | }, | 12603 | }, |
| 5918 | .dst_temps = .{ .mem, .unused }, | 12604 | .dst_temps = .{ .mem, .unused }, |
| 5919 | .clobbers = .{ .eflags = true }, | 12605 | .clobbers = .{ .eflags = true }, |
| 5920 | .each = .{ .once = &.{ | 12606 | .each = .{ .once = &.{ |
| 5921 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 12607 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5922 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | | |
| 5923 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, | | |
| 5924 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, | | |
| 5925 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ }, | | |
| 5926 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | | |
| 5927 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 5928 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, | | |
| 5929 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | | |
| 5930 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, | 12608 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| 5931 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 12609 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 12610 | .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 12611 | .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 12612 | .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 12613 | .{ ._, ._, .mov, .tmp5p, .sa(.src0, .sub_elem_size_div_8), ._, ._ }, |
| | 12614 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 12615 | .{ ._, ._, .adc, .tmp6q, .leasi(.tmp3q, .@"8", .tmp5), ._, ._ }, |
| | 12616 | .{ ._, ._, .mov, .leasi(.tmp4q, .@"8", .tmp5), .tmp6q, ._, ._ }, |
| | 12617 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 12618 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 12619 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 12620 | .{ ._, ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size), ._, ._ }, |
| | 12621 | .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| 5932 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12622 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 12623 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12624 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5933 | } }, | 12625 | } }, |
| 5934 | }, .{ | 12626 | }, .{ |
| 5935 | .required_features = .{ .@"64bit", null, null, null }, | 12627 | .required_features = .{ .@"64bit", null, null, null }, |
| 5936 | .src_constraints = .{ | 12628 | .src_constraints = .{ |
| 5937 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, | 12629 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 5938 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, | 12630 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 5939 | .any, | 12631 | .any, |
| 5940 | }, | 12632 | }, |
| 5941 | .patterns = &.{ | 12633 | .patterns = &.{ |
| 5942 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12634 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5943 | }, | 12635 | }, |
| 5944 | .extra_temps = .{ | 12636 | .extra_temps = .{ |
| | 12637 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12638 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12639 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12640 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 5945 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12641 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5946 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12642 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 5947 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12643 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| ... | @@ -5949,85 +12645,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -5949,85 +12645,97 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 5949 | .unused, | 12645 | .unused, |
| 5950 | .unused, | 12646 | .unused, |
| 5951 | .unused, | 12647 | .unused, |
| 5952 | .unused, | | |
| 5953 | .unused, | | |
| 5954 | .unused, | | |
| 5955 | .unused, | | |
| 5956 | }, | 12648 | }, |
| 5957 | .dst_temps = .{ .mem, .unused }, | 12649 | .dst_temps = .{ .mem, .unused }, |
| 5958 | .clobbers = .{ .eflags = true }, | 12650 | .clobbers = .{ .eflags = true }, |
| 5959 | .each = .{ .once = &.{ | 12651 | .each = .{ .once = &.{ |
| 5960 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, | 12652 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 5961 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 12653 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5962 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, | 12654 | .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ }, |
| 5963 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, | 12655 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ }, |
| 5964 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -16), .tmp1q, ._, ._ }, | 12656 | .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ }, |
| 5965 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 12657 | .{ ._, ._, .mov, .tmp4p, .sia(2, .src0, .sub_elem_size_div_8), ._, ._ }, |
| 5966 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 12658 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| 5967 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, | 12659 | .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| 5968 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, | 12660 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| 5969 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, | 12661 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| 5970 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 12662 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 5971 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 12663 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| 5972 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, | 12664 | .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ }, |
| | 12665 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 12666 | .{ ._, ._, .lea, .tmp4p, .leaad(.tmp3, .sub_src0_elem_size, 16), ._, ._ }, |
| | 12667 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 12668 | .{ ._, ._, .mov, .tmp6d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| 5973 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12669 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 5974 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, | 12670 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, |
| 5975 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, | 12671 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, |
| 5976 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, | 12672 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| 5977 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 12673 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 5978 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, | 12674 | .{ ._, ._, .mov, .lead(.tmp3q, 8), .tmp5q, ._, ._ }, |
| | 12675 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12676 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 5979 | } }, | 12677 | } }, |
| 5980 | }, .{ | 12678 | }, .{ |
| 5981 | .required_features = .{ .@"64bit", null, null, null }, | 12679 | .required_features = .{ .@"64bit", null, null, null }, |
| 5982 | .src_constraints = .{ | 12680 | .src_constraints = .{ |
| 5983 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, | 12681 | .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5984 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, | 12682 | .{ .scalar_exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5985 | .any, | 12683 | .any, |
| 5986 | }, | 12684 | }, |
| 5987 | .patterns = &.{ | 12685 | .patterns = &.{ |
| 5988 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12686 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5989 | }, | 12687 | }, |
| 5990 | .extra_temps = .{ | 12688 | .extra_temps = .{ |
| 5991 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12689 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 5992 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 12690 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 12691 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12692 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12693 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12694 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5993 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12695 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5994 | .unused, | 12696 | .unused, |
| 5995 | .unused, | 12697 | .unused, |
| 5996 | .unused, | 12698 | .unused, |
| 5997 | .unused, | 12699 | .unused, |
| 5998 | .unused, | | |
| 5999 | .unused, | | |
| 6000 | .unused, | | |
| 6001 | .unused, | | |
| 6002 | }, | 12700 | }, |
| 6003 | .dst_temps = .{ .mem, .unused }, | 12701 | .dst_temps = .{ .mem, .unused }, |
| 6004 | .clobbers = .{ .eflags = true }, | 12702 | .clobbers = .{ .eflags = true }, |
| 6005 | .each = .{ .once = &.{ | 12703 | .each = .{ .once = &.{ |
| 6006 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 12704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6007 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | | |
| 6008 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | | |
| 6009 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | | |
| 6010 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, | | |
| 6011 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | | |
| 6012 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | | |
| 6013 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, | | |
| 6014 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | | |
| 6015 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, | 12705 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| 6016 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, | 12706 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 12707 | .{ .@"0:", ._, .lea, .tmp2p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 12708 | .{ ._, ._, .lea, .tmp3p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 12709 | .{ ._, ._, .lea, .tmp4p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 12710 | .{ ._, ._, .mov, .tmp5p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ }, |
| | 12711 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 12712 | .{ ._, ._, .adc, .tmp6q, .leasi(.tmp3q, .@"8", .tmp5), ._, ._ }, |
| | 12713 | .{ ._, ._, .mov, .leasi(.tmp4q, .@"8", .tmp5), .tmp6q, ._, ._ }, |
| | 12714 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 12715 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 12716 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 12717 | .{ ._, ._, .lea, .tmp5p, .leaad(.tmp4, .sub_src0_elem_size, 8), ._, ._ }, |
| | 12718 | .{ ._, ._, .mov, .tmp6d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 6017 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12719 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6018 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, | 12720 | .{ .@"1:", ._, .mov, .lea(.tmp4q), .si(0), ._, ._ }, |
| | 12721 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12722 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6019 | } }, | 12723 | } }, |
| 6020 | }, .{ | 12724 | }, .{ |
| 6021 | .required_features = .{ .@"64bit", null, null, null }, | 12725 | .required_features = .{ .@"64bit", null, null, null }, |
| 6022 | .src_constraints = .{ | 12726 | .src_constraints = .{ |
| 6023 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, | 12727 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 6024 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, | 12728 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 6025 | .any, | 12729 | .any, |
| 6026 | }, | 12730 | }, |
| 6027 | .patterns = &.{ | 12731 | .patterns = &.{ |
| 6028 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12732 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6029 | }, | 12733 | }, |
| 6030 | .extra_temps = .{ | 12734 | .extra_temps = .{ |
| | 12735 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12736 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12737 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12738 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 6031 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12739 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6032 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12740 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 6033 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12741 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| ... | @@ -6035,88 +12743,100 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6035,88 +12743,100 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6035 | .unused, | 12743 | .unused, |
| 6036 | .unused, | 12744 | .unused, |
| 6037 | .unused, | 12745 | .unused, |
| 6038 | .unused, | | |
| 6039 | .unused, | | |
| 6040 | .unused, | | |
| 6041 | .unused, | | |
| 6042 | }, | 12746 | }, |
| 6043 | .dst_temps = .{ .mem, .unused }, | 12747 | .dst_temps = .{ .mem, .unused }, |
| 6044 | .clobbers = .{ .eflags = true }, | 12748 | .clobbers = .{ .eflags = true }, |
| 6045 | .each = .{ .once = &.{ | 12749 | .each = .{ .once = &.{ |
| 6046 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 12750 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6047 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 12751 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6048 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 12752 | .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 6049 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 12753 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 6050 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, | 12754 | .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 6051 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 12755 | .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ }, |
| 6052 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 12756 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| 6053 | .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, | 12757 | .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| 6054 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, | 12758 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| 6055 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, | 12759 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| 6056 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 12760 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 6057 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 12761 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| 6058 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, | 12762 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, |
| | 12763 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 12764 | .{ ._, ._, .lea, .tmp4p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, |
| | 12765 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 12766 | .{ ._, ._, .mov, .tmp6d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| 6059 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12767 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6060 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, | 12768 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, |
| 6061 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, | 12769 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, |
| 6062 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, | 12770 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, |
| 6063 | .{ .@"0:", ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 12771 | .{ .@"1:", ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 6064 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, | 12772 | .{ ._, ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| | 12773 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12774 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6065 | } }, | 12775 | } }, |
| 6066 | }, .{ | 12776 | }, .{ |
| 6067 | .required_features = .{ .@"64bit", null, null, null }, | 12777 | .required_features = .{ .@"64bit", null, null, null }, |
| 6068 | .src_constraints = .{ | 12778 | .src_constraints = .{ |
| 6069 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, | 12779 | .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 6070 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, | 12780 | .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 6071 | .any, | 12781 | .any, |
| 6072 | }, | 12782 | }, |
| 6073 | .patterns = &.{ | 12783 | .patterns = &.{ |
| 6074 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12784 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6075 | }, | 12785 | }, |
| 6076 | .extra_temps = .{ | 12786 | .extra_temps = .{ |
| 6077 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12787 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12788 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 6078 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 12789 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 12790 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12791 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12792 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12793 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6079 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12794 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6080 | .unused, | 12795 | .unused, |
| 6081 | .unused, | 12796 | .unused, |
| 6082 | .unused, | 12797 | .unused, |
| 6083 | .unused, | | |
| 6084 | .unused, | | |
| 6085 | .unused, | | |
| 6086 | .unused, | | |
| 6087 | .unused, | | |
| 6088 | }, | 12798 | }, |
| 6089 | .dst_temps = .{ .mem, .unused }, | 12799 | .dst_temps = .{ .mem, .unused }, |
| 6090 | .clobbers = .{ .eflags = true }, | 12800 | .clobbers = .{ .eflags = true }, |
| 6091 | .each = .{ .once = &.{ | 12801 | .each = .{ .once = &.{ |
| 6092 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, | 12802 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6093 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, | 12803 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 12804 | .{ ._, ._, .mov, .tmp2q, .si(-1), ._, ._ }, |
| 6094 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 12805 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6095 | .{ .@"0:", ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 12806 | .{ .@"0:", ._, .lea, .tmp3p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 6096 | .{ ._, ._, .adc, .tmp2q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, | 12807 | .{ ._, ._, .lea, .tmp4p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 6097 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp2q, ._, ._ }, | 12808 | .{ ._, ._, .lea, .tmp5p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| 6098 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 12809 | .{ ._, ._, .mov, .tmp6p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ }, |
| 6099 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 12810 | .{ .@"1:", ._, .mov, .tmp7q, .leasi(.tmp3q, .@"8", .tmp6), ._, ._ }, |
| 6100 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, | 12811 | .{ ._, ._, .adc, .tmp7q, .leasi(.tmp4q, .@"8", .tmp6), ._, ._ }, |
| 6101 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, | 12812 | .{ ._, ._, .mov, .leasi(.tmp5q, .@"8", .tmp6), .tmp7q, ._, ._ }, |
| 6102 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, | 12813 | .{ ._, ._c, .in, .tmp6p, ._, ._, ._ }, |
| 6103 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 12814 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 6104 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, | 12815 | .{ ._, ._, .cmp, .tmp7q, .tmp1q, ._, ._ }, |
| 6105 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, | 12816 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 12817 | .{ ._, ._, .mov, .lead(.tmp5q, -8), .tmp1q, ._, ._ }, |
| | 12818 | .{ ._, ._, .lea, .tmp6p, .leaad(.tmp5, .sub_src0_elem_size, 8), ._, ._ }, |
| | 12819 | .{ ._, ._, .mov, .tmp7d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| 6106 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12820 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6107 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, | 12821 | .{ .@"1:", ._, .mov, .lea(.tmp5q), .si(0), ._, ._ }, |
| | 12822 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12823 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6108 | } }, | 12824 | } }, |
| 6109 | }, .{ | 12825 | }, .{ |
| 6110 | .required_features = .{ .@"64bit", null, null, null }, | 12826 | .required_features = .{ .@"64bit", null, null, null }, |
| 6111 | .src_constraints = .{ | 12827 | .src_constraints = .{ |
| 6112 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, | 12828 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 6113 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, | 12829 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 6114 | .any, | 12830 | .any, |
| 6115 | }, | 12831 | }, |
| 6116 | .patterns = &.{ | 12832 | .patterns = &.{ |
| 6117 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12833 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6118 | }, | 12834 | }, |
| 6119 | .extra_temps = .{ | 12835 | .extra_temps = .{ |
| | 12836 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12837 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12838 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12839 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 6120 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12840 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6121 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12841 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 6122 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12842 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| ... | @@ -6124,73 +12844,81 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6124,73 +12844,81 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6124 | .unused, | 12844 | .unused, |
| 6125 | .unused, | 12845 | .unused, |
| 6126 | .unused, | 12846 | .unused, |
| 6127 | .unused, | | |
| 6128 | .unused, | | |
| 6129 | .unused, | | |
| 6130 | .unused, | | |
| 6131 | }, | 12847 | }, |
| 6132 | .dst_temps = .{ .mem, .unused }, | 12848 | .dst_temps = .{ .mem, .unused }, |
| 6133 | .clobbers = .{ .eflags = true }, | 12849 | .clobbers = .{ .eflags = true }, |
| 6134 | .each = .{ .once = &.{ | 12850 | .each = .{ .once = &.{ |
| 6135 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 12851 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6136 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 12852 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6137 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, | 12853 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| 6138 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, | 12854 | .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| 6139 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ }, | 12855 | .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| 6140 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 12856 | .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_8), ._, ._ }, |
| 6141 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 12857 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| 6142 | .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, | 12858 | .{ ._, ._, .adc, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| 6143 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, | 12859 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| 6144 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, | 12860 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| 6145 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 12861 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 6146 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 12862 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| 6147 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, | 12863 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, |
| | 12864 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 12865 | .{ ._, ._, .lea, .tmp4p, .leaa(.tmp3, .sub_src0_elem_size), ._, ._ }, |
| | 12866 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 12867 | .{ ._, ._, .mov, .tmp6d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 6148 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12868 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6149 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, | 12869 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, |
| 6150 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, | 12870 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, |
| 6151 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, | 12871 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, |
| | 12872 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12873 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6152 | } }, | 12874 | } }, |
| 6153 | }, .{ | 12875 | }, .{ |
| 6154 | .required_features = .{ .@"64bit", null, null, null }, | 12876 | .required_features = .{ .@"64bit", null, null, null }, |
| 6155 | .src_constraints = .{ | 12877 | .src_constraints = .{ |
| 6156 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, | 12878 | .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 6157 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, | 12879 | .{ .scalar_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 6158 | .any, | 12880 | .any, |
| 6159 | }, | 12881 | }, |
| 6160 | .patterns = &.{ | 12882 | .patterns = &.{ |
| 6161 | .{ .src = .{ .to_mem, .to_mem, .none } }, | 12883 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6162 | }, | 12884 | }, |
| 6163 | .extra_temps = .{ | 12885 | .extra_temps = .{ |
| 6164 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | 12886 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12887 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 6165 | .{ .type = .u64, .kind = .{ .reg = .rax } }, | 12888 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 12889 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12890 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12891 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 12892 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6166 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12893 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6167 | .unused, | 12894 | .unused, |
| 6168 | .unused, | 12895 | .unused, |
| 6169 | .unused, | 12896 | .unused, |
| 6170 | .unused, | | |
| 6171 | .unused, | | |
| 6172 | .unused, | | |
| 6173 | .unused, | | |
| 6174 | .unused, | | |
| 6175 | }, | 12897 | }, |
| 6176 | .dst_temps = .{ .mem, .unused }, | 12898 | .dst_temps = .{ .mem, .unused }, |
| 6177 | .clobbers = .{ .eflags = true }, | 12899 | .clobbers = .{ .eflags = true }, |
| 6178 | .each = .{ .once = &.{ | 12900 | .each = .{ .once = &.{ |
| 6179 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, | 12901 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6180 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, | 12902 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| | 12903 | .{ ._, ._, .mov, .tmp2q, .si(-1), ._, ._ }, |
| 6181 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, | 12904 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6182 | .{ .@"0:", ._, .mov, .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, | 12905 | .{ .@"0:", ._, .lea, .tmp3p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| 6183 | .{ ._, ._, .adc, .tmp2q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, | 12906 | .{ ._, ._, .lea, .tmp4p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| 6184 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp2q, ._, ._ }, | 12907 | .{ ._, ._, .lea, .tmp5p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| 6185 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, | 12908 | .{ ._, ._, .mov, .tmp6p, .sa(.src0, .sub_elem_size_div_8), ._, ._ }, |
| 6186 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, | 12909 | .{ .@"1:", ._, .mov, .tmp7q, .leasi(.tmp3q, .@"8", .tmp6), ._, ._ }, |
| 6187 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, | 12910 | .{ ._, ._, .adc, .tmp7q, .leasi(.tmp4q, .@"8", .tmp6), ._, ._ }, |
| 6188 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, | 12911 | .{ ._, ._, .mov, .leasi(.tmp5q, .@"8", .tmp6), .tmp7q, ._, ._ }, |
| 6189 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, | 12912 | .{ ._, ._c, .in, .tmp6p, ._, ._, ._ }, |
| 6190 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 12913 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| 6191 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, | 12914 | .{ ._, ._, .cmp, .tmp7q, .tmp1q, ._, ._ }, |
| 6192 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, | 12915 | .{ ._, ._na, .j, .@"1f", ._, ._, ._ }, |
| | 12916 | .{ ._, ._, .lea, .tmp6p, .leaa(.tmp5, .sub_src0_elem_size), ._, ._ }, |
| | 12917 | .{ ._, ._, .mov, .tmp7d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 6193 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12918 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 12919 | .{ ._, ._, .mov, .lead(.tmp5q, -8), .tmp1q, ._, ._ }, |
| | 12920 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 12921 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 6194 | } }, | 12922 | } }, |
| 6195 | } }) catch |err| switch (err) { | 12923 | } }) catch |err| switch (err) { |
| 6196 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 12924 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| ... | @@ -6404,6 +13132,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6404,6 +13132,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6404 | .unused, | 13132 | .unused, |
| 6405 | }, | 13133 | }, |
| 6406 | .dst_temps = .{ .mem, .unused }, | 13134 | .dst_temps = .{ .mem, .unused }, |
| | 13135 | .clobbers = .{ .eflags = true }, |
| 6407 | .each = .{ .once = &.{ | 13136 | .each = .{ .once = &.{ |
| 6408 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13137 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6409 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 13138 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6436,6 +13165,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6436,6 +13165,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6436 | .unused, | 13165 | .unused, |
| 6437 | }, | 13166 | }, |
| 6438 | .dst_temps = .{ .mem, .unused }, | 13167 | .dst_temps = .{ .mem, .unused }, |
| | 13168 | .clobbers = .{ .eflags = true }, |
| 6439 | .each = .{ .once = &.{ | 13169 | .each = .{ .once = &.{ |
| 6440 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13170 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6441 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13171 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6468,6 +13198,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6468,6 +13198,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6468 | .unused, | 13198 | .unused, |
| 6469 | }, | 13199 | }, |
| 6470 | .dst_temps = .{ .mem, .unused }, | 13200 | .dst_temps = .{ .mem, .unused }, |
| | 13201 | .clobbers = .{ .eflags = true }, |
| 6471 | .each = .{ .once = &.{ | 13202 | .each = .{ .once = &.{ |
| 6472 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13203 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6473 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13204 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6500,6 +13231,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6500,6 +13231,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6500 | .unused, | 13231 | .unused, |
| 6501 | }, | 13232 | }, |
| 6502 | .dst_temps = .{ .mem, .unused }, | 13233 | .dst_temps = .{ .mem, .unused }, |
| | 13234 | .clobbers = .{ .eflags = true }, |
| 6503 | .each = .{ .once = &.{ | 13235 | .each = .{ .once = &.{ |
| 6504 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13236 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6505 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 13237 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6531,6 +13263,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6531,6 +13263,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6531 | .unused, | 13263 | .unused, |
| 6532 | }, | 13264 | }, |
| 6533 | .dst_temps = .{ .mem, .unused }, | 13265 | .dst_temps = .{ .mem, .unused }, |
| | 13266 | .clobbers = .{ .eflags = true }, |
| 6534 | .each = .{ .once = &.{ | 13267 | .each = .{ .once = &.{ |
| 6535 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13268 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6536 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, | 13269 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6608,6 +13341,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6608,6 +13341,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6608 | .unused, | 13341 | .unused, |
| 6609 | }, | 13342 | }, |
| 6610 | .dst_temps = .{ .mem, .unused }, | 13343 | .dst_temps = .{ .mem, .unused }, |
| | 13344 | .clobbers = .{ .eflags = true }, |
| 6611 | .each = .{ .once = &.{ | 13345 | .each = .{ .once = &.{ |
| 6612 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13346 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6613 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 13347 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6640,6 +13374,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6640,6 +13374,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6640 | .unused, | 13374 | .unused, |
| 6641 | }, | 13375 | }, |
| 6642 | .dst_temps = .{ .mem, .unused }, | 13376 | .dst_temps = .{ .mem, .unused }, |
| | 13377 | .clobbers = .{ .eflags = true }, |
| 6643 | .each = .{ .once = &.{ | 13378 | .each = .{ .once = &.{ |
| 6644 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13379 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6645 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13380 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6672,6 +13407,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6672,6 +13407,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6672 | .unused, | 13407 | .unused, |
| 6673 | }, | 13408 | }, |
| 6674 | .dst_temps = .{ .mem, .unused }, | 13409 | .dst_temps = .{ .mem, .unused }, |
| | 13410 | .clobbers = .{ .eflags = true }, |
| 6675 | .each = .{ .once = &.{ | 13411 | .each = .{ .once = &.{ |
| 6676 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13412 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6677 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13413 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6703,6 +13439,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6703,6 +13439,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6703 | .unused, | 13439 | .unused, |
| 6704 | }, | 13440 | }, |
| 6705 | .dst_temps = .{ .mem, .unused }, | 13441 | .dst_temps = .{ .mem, .unused }, |
| | 13442 | .clobbers = .{ .eflags = true }, |
| 6706 | .each = .{ .once = &.{ | 13443 | .each = .{ .once = &.{ |
| 6707 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13444 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6708 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, | 13445 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6780,6 +13517,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6780,6 +13517,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6780 | .unused, | 13517 | .unused, |
| 6781 | }, | 13518 | }, |
| 6782 | .dst_temps = .{ .mem, .unused }, | 13519 | .dst_temps = .{ .mem, .unused }, |
| | 13520 | .clobbers = .{ .eflags = true }, |
| 6783 | .each = .{ .once = &.{ | 13521 | .each = .{ .once = &.{ |
| 6784 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13522 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6785 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 13523 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6812,6 +13550,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6812,6 +13550,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6812 | .unused, | 13550 | .unused, |
| 6813 | }, | 13551 | }, |
| 6814 | .dst_temps = .{ .mem, .unused }, | 13552 | .dst_temps = .{ .mem, .unused }, |
| | 13553 | .clobbers = .{ .eflags = true }, |
| 6815 | .each = .{ .once = &.{ | 13554 | .each = .{ .once = &.{ |
| 6816 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13555 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6817 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13556 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6844,6 +13583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6844,6 +13583,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6844 | .unused, | 13583 | .unused, |
| 6845 | }, | 13584 | }, |
| 6846 | .dst_temps = .{ .mem, .unused }, | 13585 | .dst_temps = .{ .mem, .unused }, |
| | 13586 | .clobbers = .{ .eflags = true }, |
| 6847 | .each = .{ .once = &.{ | 13587 | .each = .{ .once = &.{ |
| 6848 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13588 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6849 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13589 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6875,6 +13615,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6875,6 +13615,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6875 | .unused, | 13615 | .unused, |
| 6876 | }, | 13616 | }, |
| 6877 | .dst_temps = .{ .mem, .unused }, | 13617 | .dst_temps = .{ .mem, .unused }, |
| | 13618 | .clobbers = .{ .eflags = true }, |
| 6878 | .each = .{ .once = &.{ | 13619 | .each = .{ .once = &.{ |
| 6879 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13620 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6880 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, | 13621 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6952,6 +13693,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6952,6 +13693,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6952 | .unused, | 13693 | .unused, |
| 6953 | }, | 13694 | }, |
| 6954 | .dst_temps = .{ .mem, .unused }, | 13695 | .dst_temps = .{ .mem, .unused }, |
| | 13696 | .clobbers = .{ .eflags = true }, |
| 6955 | .each = .{ .once = &.{ | 13697 | .each = .{ .once = &.{ |
| 6956 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13698 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6957 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, | 13699 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -6984,6 +13726,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6984,6 +13726,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6984 | .unused, | 13726 | .unused, |
| 6985 | }, | 13727 | }, |
| 6986 | .dst_temps = .{ .mem, .unused }, | 13728 | .dst_temps = .{ .mem, .unused }, |
| | 13729 | .clobbers = .{ .eflags = true }, |
| 6987 | .each = .{ .once = &.{ | 13730 | .each = .{ .once = &.{ |
| 6988 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13731 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 6989 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13732 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -7016,6 +13759,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7016,6 +13759,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7016 | .unused, | 13759 | .unused, |
| 7017 | }, | 13760 | }, |
| 7018 | .dst_temps = .{ .mem, .unused }, | 13761 | .dst_temps = .{ .mem, .unused }, |
| | 13762 | .clobbers = .{ .eflags = true }, |
| 7019 | .each = .{ .once = &.{ | 13763 | .each = .{ .once = &.{ |
| 7020 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13764 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7021 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, | 13765 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -7048,6 +13792,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7048,6 +13792,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7048 | .unused, | 13792 | .unused, |
| 7049 | }, | 13793 | }, |
| 7050 | .dst_temps = .{ .mem, .unused }, | 13794 | .dst_temps = .{ .mem, .unused }, |
| | 13795 | .clobbers = .{ .eflags = true }, |
| 7051 | .each = .{ .once = &.{ | 13796 | .each = .{ .once = &.{ |
| 7052 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13797 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7053 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, | 13798 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| ... | @@ -7080,6 +13825,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7080,6 +13825,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7080 | .unused, | 13825 | .unused, |
| 7081 | }, | 13826 | }, |
| 7082 | .dst_temps = .{ .mem, .unused }, | 13827 | .dst_temps = .{ .mem, .unused }, |
| | 13828 | .clobbers = .{ .eflags = true }, |
| 7083 | .each = .{ .once = &.{ | 13829 | .each = .{ .once = &.{ |
| 7084 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13830 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7085 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, | 13831 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| ... | @@ -7118,6 +13864,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7118,6 +13864,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7118 | .unused, | 13864 | .unused, |
| 7119 | }, | 13865 | }, |
| 7120 | .dst_temps = .{ .mem, .unused }, | 13866 | .dst_temps = .{ .mem, .unused }, |
| | 13867 | .clobbers = .{ .eflags = true }, |
| 7121 | .each = .{ .once = &.{ | 13868 | .each = .{ .once = &.{ |
| 7122 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 13869 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7123 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, | 13870 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| ... | @@ -7900,6 +14647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7900,6 +14647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7900 | .unused, | 14647 | .unused, |
| 7901 | }, | 14648 | }, |
| 7902 | .dst_temps = .{ .mem, .unused }, | 14649 | .dst_temps = .{ .mem, .unused }, |
| | 14650 | .clobbers = .{ .eflags = true }, |
| 7903 | .each = .{ .once = &.{ | 14651 | .each = .{ .once = &.{ |
| 7904 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 14652 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 7905 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 14653 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -10484,6 +17232,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10484,6 +17232,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10484 | .unused, | 17232 | .unused, |
| 10485 | }, | 17233 | }, |
| 10486 | .dst_temps = .{ .mem, .unused }, | 17234 | .dst_temps = .{ .mem, .unused }, |
| | 17235 | .clobbers = .{ .eflags = true }, |
| 10487 | .each = .{ .once = &.{ | 17236 | .each = .{ .once = &.{ |
| 10488 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 17237 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 10489 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 17238 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -10577,6 +17326,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10577,6 +17326,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10577 | .unused, | 17326 | .unused, |
| 10578 | }, | 17327 | }, |
| 10579 | .dst_temps = .{ .mem, .unused }, | 17328 | .dst_temps = .{ .mem, .unused }, |
| | 17329 | .clobbers = .{ .eflags = true }, |
| 10580 | .each = .{ .once = &.{ | 17330 | .each = .{ .once = &.{ |
| 10581 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 17331 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 10582 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 17332 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -13174,6 +19924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13174,6 +19924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13174 | .unused, | 19924 | .unused, |
| 13175 | }, | 19925 | }, |
| 13176 | .dst_temps = .{ .mem, .unused }, | 19926 | .dst_temps = .{ .mem, .unused }, |
| | 19927 | .clobbers = .{ .eflags = true }, |
| 13177 | .each = .{ .once = &.{ | 19928 | .each = .{ .once = &.{ |
| 13178 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 19929 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 13179 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 19930 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -13267,6 +20018,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -13267,6 +20018,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 13267 | .unused, | 20018 | .unused, |
| 13268 | }, | 20019 | }, |
| 13269 | .dst_temps = .{ .mem, .unused }, | 20020 | .dst_temps = .{ .mem, .unused }, |
| | 20021 | .clobbers = .{ .eflags = true }, |
| 13270 | .each = .{ .once = &.{ | 20022 | .each = .{ .once = &.{ |
| 13271 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 20023 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 13272 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 20024 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -14084,6 +20836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14084,6 +20836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14084 | .unused, | 20836 | .unused, |
| 14085 | }, | 20837 | }, |
| 14086 | .dst_temps = .{ .mem, .unused }, | 20838 | .dst_temps = .{ .mem, .unused }, |
| | 20839 | .clobbers = .{ .eflags = true }, |
| 14087 | .each = .{ .once = &.{ | 20840 | .each = .{ .once = &.{ |
| 14088 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 20841 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 14089 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 20842 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -14205,6 +20958,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14205,6 +20958,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14205 | .unused, | 20958 | .unused, |
| 14206 | }, | 20959 | }, |
| 14207 | .dst_temps = .{ .mem, .unused }, | 20960 | .dst_temps = .{ .mem, .unused }, |
| | 20961 | .clobbers = .{ .eflags = true }, |
| 14208 | .each = .{ .once = &.{ | 20962 | .each = .{ .once = &.{ |
| 14209 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, | 20963 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 14210 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, | 20964 | .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| ... | @@ -121246,8 +128000,10 @@ const Select = struct { | ... | @@ -121246,8 +128000,10 @@ const Select = struct { |
| 121246 | mem_of_type: Select.Operand.Ref, | 128000 | mem_of_type: Select.Operand.Ref, |
| 121247 | smin_mem: ConstSpec, | 128001 | smin_mem: ConstSpec, |
| 121248 | smax_mem: ConstSpec, | 128002 | smax_mem: ConstSpec, |
| | 128003 | slimit_delta_mem: ConstSpec, |
| 121249 | umin_mem: ConstSpec, | 128004 | umin_mem: ConstSpec, |
| 121250 | umax_mem: ConstSpec, | 128005 | umax_mem: ConstSpec, |
| | 128006 | umax_delta_mem: ConstSpec, |
| 121251 | @"0x1p63_mem": ConstSpec, | 128007 | @"0x1p63_mem": ConstSpec, |
| 121252 | f64_0x1p52_0x1p84_mem, | 128008 | f64_0x1p52_0x1p84_mem, |
| 121253 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, | 128009 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, |
| ... | @@ -121356,7 +128112,14 @@ const Select = struct { | ... | @@ -121356,7 +128112,14 @@ const Select = struct { |
| 121356 | }, | 128112 | }, |
| 121357 | .mem => .{ try cg.tempAllocMem(spec.type), true }, | 128113 | .mem => .{ try cg.tempAllocMem(spec.type), true }, |
| 121358 | .mem_of_type => |ref| .{ try cg.tempAllocMem(ref.typeOf(s)), true }, | 128114 | .mem_of_type => |ref| .{ try cg.tempAllocMem(ref.typeOf(s)), true }, |
| 121359 | .smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => |const_spec| { | 128115 | .smin_mem, |
| | 128116 | .smax_mem, |
| | 128117 | .slimit_delta_mem, |
| | 128118 | .umin_mem, |
| | 128119 | .umax_mem, |
| | 128120 | .umax_delta_mem, |
| | 128121 | .@"0x1p63_mem", |
| | 128122 | => |const_spec| { |
| 121360 | const zcu = pt.zcu; | 128123 | const zcu = pt.zcu; |
| 121361 | const ip = &zcu.intern_pool; | 128124 | const ip = &zcu.intern_pool; |
| 121362 | const ty = if (const_spec.ref == .none) spec.type else const_spec.ref.typeOf(s); | 128125 | const ty = if (const_spec.ref == .none) spec.type else const_spec.ref.typeOf(s); |
| ... | @@ -121369,40 +128132,47 @@ const Select = struct { | ... | @@ -121369,40 +128132,47 @@ const Select = struct { |
| 121369 | else => @intCast(@divExact(@divExact(vectorize_to.bitSize(cg.target), 8), scalar_ty.abiSize(pt.zcu))), | 128132 | else => @intCast(@divExact(@divExact(vectorize_to.bitSize(cg.target), 8), scalar_ty.abiSize(pt.zcu))), |
| 121370 | } else vector_len; | 128133 | } else vector_len; |
| 121371 | const res_scalar_ty, const res_scalar_val: Value = res_scalar: switch (scalar_ty.toIntern()) { | 128134 | const res_scalar_ty, const res_scalar_val: Value = res_scalar: switch (scalar_ty.toIntern()) { |
| 121372 | .bool_type => .{ | 128135 | .bool_type => .{ scalar_ty, .fromInterned(switch (spec.kind) { |
| 121373 | scalar_ty, | 128136 | else => unreachable, |
| 121374 | .fromInterned(switch (spec.kind) { | 128137 | .smin_mem, .umax_mem => .bool_true, |
| 121375 | else => unreachable, | 128138 | .smax_mem, .umin_mem => .bool_false, |
| 121376 | .smin_mem, .umax_mem => .bool_true, | 128139 | }) }, |
| 121377 | .smax_mem, .umin_mem => .bool_false, | | |
| 121378 | }), | | |
| 121379 | }, | | |
| 121380 | else => { | 128140 | else => { |
| 121381 | const scalar_info: std.builtin.Type.Int = cg.intInfo(scalar_ty) orelse .{ | 128141 | const scalar_info: std.builtin.Type.Int = cg.intInfo(scalar_ty) orelse .{ |
| 121382 | .signedness = .signed, | 128142 | .signedness = .signed, |
| 121383 | .bits = cg.floatBits(scalar_ty).?, | 128143 | .bits = cg.floatBits(scalar_ty).?, |
| 121384 | }; | 128144 | }; |
| 121385 | const scalar_signedness = const_spec.to_signedness orelse scalar_info.signedness; | 128145 | const res_scalar_info: std.builtin.Type.Int = .{ |
| 121386 | const scalar_int_ty = try pt.intType(scalar_signedness, scalar_info.bits); | 128146 | .signedness = const_spec.to_signedness orelse scalar_info.signedness, |
| | 128147 | .bits = switch (spec.kind) { |
| | 128148 | else => scalar_info.bits, |
| | 128149 | .slimit_delta_mem, .umax_delta_mem => cg.intInfo(spec.type.scalarType(zcu)).?.bits, |
| | 128150 | }, |
| | 128151 | }; |
| | 128152 | const res_scalar_ty = try pt.intType(res_scalar_info.signedness, res_scalar_info.bits); |
| 121387 | | 128153 | |
| 121388 | if (scalar_info.bits <= 64) { | 128154 | if (res_scalar_info.bits <= 64) { |
| 121389 | const int_val: i64 = switch (spec.kind) { | 128155 | const int_val: i64 = switch (spec.kind) { |
| 121390 | else => unreachable, | 128156 | else => unreachable, |
| 121391 | .smin_mem => std.math.minInt(i64), | 128157 | .smin_mem => std.math.minInt(i64), |
| 121392 | .smax_mem => std.math.maxInt(i64), | 128158 | .smax_mem => std.math.maxInt(i64), |
| | 128159 | .slimit_delta_mem => std.math.maxInt(i64) - |
| | 128160 | (@as(i64, std.math.maxInt(i64)) >> @intCast(res_scalar_info.bits - scalar_info.bits)), |
| 121393 | .umin_mem => 0, | 128161 | .umin_mem => 0, |
| 121394 | .umax_mem => -1, | 128162 | .umax_mem => -1, |
| 121395 | .@"0x1p63_mem" => switch (scalar_info.bits) { | 128163 | .umax_delta_mem => @bitCast(std.math.maxInt(u64) - |
| | 128164 | (@as(u64, std.math.maxInt(u64)) >> @intCast(res_scalar_info.bits - scalar_info.bits))), |
| | 128165 | .@"0x1p63_mem" => switch (res_scalar_info.bits) { |
| 121396 | else => unreachable, | 128166 | else => unreachable, |
| 121397 | 16 => @as(i64, @as(i16, @bitCast(@as(f16, 0x1p63)))) << 64 - 16, | 128167 | 16 => @as(i64, @as(i16, @bitCast(@as(f16, 0x1p63)))) << 64 - 16, |
| 121398 | 32 => @as(i64, @as(i32, @bitCast(@as(f32, 0x1p63)))) << 64 - 32, | 128168 | 32 => @as(i64, @as(i32, @bitCast(@as(f32, 0x1p63)))) << 64 - 32, |
| 121399 | 64 => @as(i64, @as(i64, @bitCast(@as(f64, 0x1p63)))) << 64 - 64, | 128169 | 64 => @as(i64, @as(i64, @bitCast(@as(f64, 0x1p63)))) << 64 - 64, |
| 121400 | }, | 128170 | }, |
| 121401 | }; | 128171 | }; |
| 121402 | const shift: u6 = @intCast(64 - scalar_info.bits); | 128172 | const shift: u6 = @intCast(64 - res_scalar_info.bits); |
| 121403 | break :res_scalar .{ scalar_int_ty, switch (scalar_signedness) { | 128173 | break :res_scalar .{ res_scalar_ty, switch (res_scalar_info.signedness) { |
| 121404 | .signed => try pt.intValue_i64(scalar_int_ty, int_val >> shift), | 128174 | .signed => try pt.intValue_i64(res_scalar_ty, int_val >> shift), |
| 121405 | .unsigned => try pt.intValue_u64(scalar_int_ty, @as(u64, @bitCast(int_val)) >> shift), | 128175 | .unsigned => try pt.intValue_u64(res_scalar_ty, @as(u64, @bitCast(int_val)) >> shift), |
| 121406 | } }; | 128176 | } }; |
| 121407 | } | 128177 | } |
| 121408 | | 128178 | |
| ... | @@ -121410,18 +128180,18 @@ const Select = struct { | ... | @@ -121410,18 +128180,18 @@ const Select = struct { |
| 121410 | var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) = | 128180 | var stack align(@max(@alignOf(ExpectedContents), @alignOf(std.heap.StackFallbackAllocator(0)))) = |
| 121411 | std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa); | 128181 | std.heap.stackFallback(@sizeOf(ExpectedContents), cg.gpa); |
| 121412 | const allocator = stack.get(); | 128182 | const allocator = stack.get(); |
| 121413 | var big_int: std.math.big.int.Mutable = .{ | 128183 | var res_big_int: std.math.big.int.Mutable = .{ |
| 121414 | .limbs = try allocator.alloc( | 128184 | .limbs = try allocator.alloc( |
| 121415 | std.math.big.Limb, | 128185 | std.math.big.Limb, |
| 121416 | std.math.big.int.calcTwosCompLimbCount(scalar_info.bits), | 128186 | std.math.big.int.calcTwosCompLimbCount(res_scalar_info.bits), |
| 121417 | ), | 128187 | ), |
| 121418 | .len = undefined, | 128188 | .len = undefined, |
| 121419 | .positive = undefined, | 128189 | .positive = undefined, |
| 121420 | }; | 128190 | }; |
| 121421 | defer allocator.free(big_int.limbs); | 128191 | defer allocator.free(res_big_int.limbs); |
| 121422 | switch (spec.kind) { | 128192 | switch (spec.kind) { |
| 121423 | else => unreachable, | 128193 | else => unreachable, |
| 121424 | .smin_mem, .smax_mem, .umin_mem, .umax_mem => big_int.setTwosCompIntLimit(switch (spec.kind) { | 128194 | .smin_mem, .smax_mem, .umin_mem, .umax_mem => res_big_int.setTwosCompIntLimit(switch (spec.kind) { |
| 121425 | else => unreachable, | 128195 | else => unreachable, |
| 121426 | .smin_mem, .umin_mem => .min, | 128196 | .smin_mem, .umin_mem => .min, |
| 121427 | .smax_mem, .umax_mem => .max, | 128197 | .smax_mem, .umax_mem => .max, |
| ... | @@ -121429,15 +128199,34 @@ const Select = struct { | ... | @@ -121429,15 +128199,34 @@ const Select = struct { |
| 121429 | else => unreachable, | 128199 | else => unreachable, |
| 121430 | .smin_mem, .smax_mem => .signed, | 128200 | .smin_mem, .smax_mem => .signed, |
| 121431 | .umin_mem, .umax_mem => .unsigned, | 128201 | .umin_mem, .umax_mem => .unsigned, |
| 121432 | }, scalar_info.bits), | 128202 | }, res_scalar_info.bits), |
| 121433 | .@"0x1p63_mem" => switch (scalar_info.bits) { | 128203 | .slimit_delta_mem, .umax_delta_mem => { |
| | 128204 | var big_int: std.math.big.int.Mutable = .{ |
| | 128205 | .limbs = try allocator.alloc( |
| | 128206 | std.math.big.Limb, |
| | 128207 | std.math.big.int.calcTwosCompLimbCount(scalar_info.bits), |
| | 128208 | ), |
| | 128209 | .len = undefined, |
| | 128210 | .positive = undefined, |
| | 128211 | }; |
| | 128212 | defer allocator.free(big_int.limbs); |
| | 128213 | const signedness: std.builtin.Signedness = switch (spec.kind) { |
| | 128214 | else => unreachable, |
| | 128215 | .slimit_delta_mem => .signed, |
| | 128216 | .umax_delta_mem => .unsigned, |
| | 128217 | }; |
| | 128218 | big_int.setTwosCompIntLimit(.max, signedness, scalar_info.bits); |
| | 128219 | res_big_int.setTwosCompIntLimit(.max, signedness, res_scalar_info.bits); |
| | 128220 | res_big_int.sub(res_big_int.toConst(), big_int.toConst()); |
| | 128221 | }, |
| | 128222 | .@"0x1p63_mem" => switch (res_scalar_info.bits) { |
| 121434 | else => unreachable, | 128223 | else => unreachable, |
| 121435 | 80 => big_int.set(@as(u80, @bitCast(@as(f80, 0x1p63)))), | 128224 | 80 => res_big_int.set(@as(u80, @bitCast(@as(f80, 0x1p63)))), |
| 121436 | 128 => big_int.set(@as(u128, @bitCast(@as(f128, 0x1p63)))), | 128225 | 128 => res_big_int.set(@as(u128, @bitCast(@as(f128, 0x1p63)))), |
| 121437 | }, | 128226 | }, |
| 121438 | } | 128227 | } |
| 121439 | big_int.truncate(big_int.toConst(), scalar_signedness, scalar_info.bits); | 128228 | res_big_int.truncate(res_big_int.toConst(), res_scalar_info.signedness, res_scalar_info.bits); |
| 121440 | break :res_scalar .{ scalar_int_ty, try pt.intValue_big(scalar_int_ty, big_int.toConst()) }; | 128229 | break :res_scalar .{ res_scalar_ty, try pt.intValue_big(res_scalar_ty, res_big_int.toConst()) }; |
| 121441 | }, | 128230 | }, |
| 121442 | }; | 128231 | }; |
| 121443 | const res_val: Value = if (res_vector_len) |len| .fromInterned(try pt.intern(.{ .aggregate = .{ | 128232 | const res_val: Value = if (res_vector_len) |len| .fromInterned(try pt.intern(.{ .aggregate = .{ |
Jacob Young <jacobly@ziglang.org> 2025-05-12 06:46:38-04:00
lib