| ... | ... | @@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2414 | 2414 | } |
| 2415 | 2415 | |
| 2416 | 2416 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2417 | | @setEvalBranchQuota(9_800); |
| 2417 | @setEvalBranchQuota(11_900); |
| 2418 | 2418 | const pt = cg.pt; |
| 2419 | 2419 | const zcu = pt.zcu; |
| 2420 | 2420 | const ip = &zcu.intern_pool; |
| ... | ... | @@ -23900,8 +23900,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23900 | 23900 | .any, |
| 23901 | 23901 | }, |
| 23902 | 23902 | .patterns = &.{ |
| 23903 | | .{ .src = .{ .to_sse, .mem, .none } }, |
| 23904 | 23903 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 23904 | }, |
| 23905 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 23906 | .ref = .src0, |
| 23907 | .rc = .sse, |
| 23908 | .info = .{ .kind = .all, .scalar = .dword }, |
| 23909 | } }}, |
| 23910 | .each = .{ .once = &.{ |
| 23911 | .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1d, .vp(switch (cc) { |
| 23912 | else => unreachable, |
| 23913 | .l => .gt, |
| 23914 | .le => .ge, |
| 23915 | }) }, |
| 23916 | } }, |
| 23917 | }, .{ |
| 23918 | .required_features = .{ .avx, null, null, null }, |
| 23919 | .src_constraints = .{ |
| 23920 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 23921 | .{ .scalar_float = .{ .of = .dword, .is = .dword } }, |
| 23922 | .any, |
| 23923 | }, |
| 23924 | .patterns = &.{ |
| 23925 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 23905 | 23926 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 23906 | 23927 | }, |
| 23907 | 23928 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | ... | @@ -23925,7 +23946,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23925 | 23946 | }, |
| 23926 | 23947 | .patterns = &.{ |
| 23927 | 23948 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 23928 | | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 23929 | 23949 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 23930 | 23950 | }, |
| 23931 | 23951 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | ... | @@ -23947,8 +23967,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23947 | 23967 | .any, |
| 23948 | 23968 | }, |
| 23949 | 23969 | .patterns = &.{ |
| 23950 | | .{ .src = .{ .to_sse, .mem, .none } }, |
| 23951 | 23970 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 23971 | }, |
| 23972 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 23973 | .ref = .src0, |
| 23974 | .rc = .sse, |
| 23975 | .info = .{ .kind = .all, .scalar = .dword }, |
| 23976 | } }}, |
| 23977 | .each = .{ .once = &.{ |
| 23978 | .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 23979 | else => unreachable, |
| 23980 | .l => .gt, |
| 23981 | .le => .ge, |
| 23982 | }) }, |
| 23983 | } }, |
| 23984 | }, .{ |
| 23985 | .required_features = .{ .avx, null, null, null }, |
| 23986 | .src_constraints = .{ |
| 23987 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 23988 | .{ .scalar_float = .{ .of = .xword, .is = .dword } }, |
| 23989 | .any, |
| 23990 | }, |
| 23991 | .patterns = &.{ |
| 23992 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 23952 | 23993 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 23953 | 23994 | }, |
| 23954 | 23995 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | ... | @@ -23972,7 +24013,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23972 | 24013 | }, |
| 23973 | 24014 | .patterns = &.{ |
| 23974 | 24015 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 23975 | | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 23976 | 24016 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 23977 | 24017 | }, |
| 23978 | 24018 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | ... | @@ -23994,8 +24034,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23994 | 24034 | .any, |
| 23995 | 24035 | }, |
| 23996 | 24036 | .patterns = &.{ |
| 23997 | | .{ .src = .{ .to_sse, .mem, .none } }, |
| 23998 | 24037 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 24038 | }, |
| 24039 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 24040 | .ref = .src0, |
| 24041 | .rc = .sse, |
| 24042 | .info = .{ .kind = .all, .scalar = .dword }, |
| 24043 | } }}, |
| 24044 | .each = .{ .once = &.{ |
| 24045 | .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { |
| 24046 | else => unreachable, |
| 24047 | .l => .gt, |
| 24048 | .le => .ge, |
| 24049 | }) }, |
| 24050 | } }, |
| 24051 | }, .{ |
| 24052 | .required_features = .{ .avx, null, null, null }, |
| 24053 | .src_constraints = .{ |
| 24054 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 24055 | .{ .scalar_float = .{ .of = .yword, .is = .dword } }, |
| 24056 | .any, |
| 24057 | }, |
| 24058 | .patterns = &.{ |
| 24059 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 23999 | 24060 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24000 | 24061 | }, |
| 24001 | 24062 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | ... | @@ -24018,8 +24079,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24018 | 24079 | .any, |
| 24019 | 24080 | }, |
| 24020 | 24081 | .patterns = &.{ |
| 24021 | | .{ .src = .{ .to_sse, .mem, .none } }, |
| 24022 | 24082 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 24083 | }, |
| 24084 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 24085 | .ref = .src0, |
| 24086 | .rc = .sse, |
| 24087 | .info = .{ .kind = .all, .scalar = .qword }, |
| 24088 | } }}, |
| 24089 | .each = .{ .once = &.{ |
| 24090 | .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1q, .vp(switch (cc) { |
| 24091 | else => unreachable, |
| 24092 | .l => .gt, |
| 24093 | .le => .ge, |
| 24094 | }) }, |
| 24095 | } }, |
| 24096 | }, .{ |
| 24097 | .required_features = .{ .avx, null, null, null }, |
| 24098 | .src_constraints = .{ |
| 24099 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 24100 | .{ .scalar_float = .{ .of = .qword, .is = .qword } }, |
| 24101 | .any, |
| 24102 | }, |
| 24103 | .patterns = &.{ |
| 24104 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 24023 | 24105 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24024 | 24106 | }, |
| 24025 | 24107 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | ... | @@ -24043,7 +24125,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24043 | 24125 | }, |
| 24044 | 24126 | .patterns = &.{ |
| 24045 | 24127 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 24046 | | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 24047 | 24128 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 24048 | 24129 | }, |
| 24049 | 24130 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | ... | @@ -24065,8 +24146,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24065 | 24146 | .any, |
| 24066 | 24147 | }, |
| 24067 | 24148 | .patterns = &.{ |
| 24068 | | .{ .src = .{ .to_sse, .mem, .none } }, |
| 24069 | 24149 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 24150 | }, |
| 24151 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 24152 | .ref = .src0, |
| 24153 | .rc = .sse, |
| 24154 | .info = .{ .kind = .all, .scalar = .qword }, |
| 24155 | } }}, |
| 24156 | .each = .{ .once = &.{ |
| 24157 | .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { |
| 24158 | else => unreachable, |
| 24159 | .l => .gt, |
| 24160 | .le => .ge, |
| 24161 | }) }, |
| 24162 | } }, |
| 24163 | }, .{ |
| 24164 | .required_features = .{ .avx, null, null, null }, |
| 24165 | .src_constraints = .{ |
| 24166 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 24167 | .{ .scalar_float = .{ .of = .xword, .is = .qword } }, |
| 24168 | .any, |
| 24169 | }, |
| 24170 | .patterns = &.{ |
| 24171 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 24070 | 24172 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24071 | 24173 | }, |
| 24072 | 24174 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | ... | @@ -24090,7 +24192,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24090 | 24192 | }, |
| 24091 | 24193 | .patterns = &.{ |
| 24092 | 24194 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 24093 | | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 24094 | 24195 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 24095 | 24196 | }, |
| 24096 | 24197 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | ... | @@ -24112,8 +24213,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24112 | 24213 | .any, |
| 24113 | 24214 | }, |
| 24114 | 24215 | .patterns = &.{ |
| 24115 | | .{ .src = .{ .to_sse, .mem, .none } }, |
| 24116 | 24216 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 24217 | }, |
| 24218 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| 24219 | .ref = .src0, |
| 24220 | .rc = .sse, |
| 24221 | .info = .{ .kind = .all, .scalar = .qword }, |
| 24222 | } }}, |
| 24223 | .each = .{ .once = &.{ |
| 24224 | .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { |
| 24225 | else => unreachable, |
| 24226 | .l => .gt, |
| 24227 | .le => .ge, |
| 24228 | }) }, |
| 24229 | } }, |
| 24230 | }, .{ |
| 24231 | .required_features = .{ .avx, null, null, null }, |
| 24232 | .src_constraints = .{ |
| 24233 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 24234 | .{ .scalar_float = .{ .of = .yword, .is = .qword } }, |
| 24235 | .any, |
| 24236 | }, |
| 24237 | .patterns = &.{ |
| 24238 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 24117 | 24239 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24118 | 24240 | }, |
| 24119 | 24241 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | ... | @@ -26088,306 +26210,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26088 | 26210 | })) { |
| 26089 | 26211 | else => unreachable, |
| 26090 | 26212 | inline .e, .ne => |cc| comptime &.{ .{ |
| 26091 | | .required_features = .{ .avx2, null, null, null }, |
| 26092 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 26093 | | .patterns = &.{ |
| 26094 | | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 26095 | | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 26096 | | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 26097 | | }, |
| 26098 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26099 | | .kind = .all, |
| 26100 | | .inverted = switch (cc) { |
| 26101 | | else => unreachable, |
| 26102 | | .e => false, |
| 26103 | | .ne => true, |
| 26104 | | }, |
| 26105 | | .scalar = .byte, |
| 26106 | | } } }}, |
| 26107 | | .each = .{ .once = &.{ |
| 26108 | | .{ ._, .vp_b, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26109 | | } }, |
| 26110 | | }, .{ |
| 26111 | | .required_features = .{ .avx2, null, null, null }, |
| 26112 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 26113 | | .patterns = &.{ |
| 26114 | | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 26115 | | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 26116 | | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 26117 | | }, |
| 26118 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26119 | | .kind = .all, |
| 26120 | | .inverted = switch (cc) { |
| 26121 | | else => unreachable, |
| 26122 | | .e => false, |
| 26123 | | .ne => true, |
| 26124 | | }, |
| 26125 | | .scalar = .word, |
| 26126 | | } } }}, |
| 26127 | | .each = .{ .once = &.{ |
| 26128 | | .{ ._, .vp_w, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26129 | | } }, |
| 26130 | | }, .{ |
| 26131 | | .required_features = .{ .avx2, null, null, null }, |
| 26132 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 26133 | | .patterns = &.{ |
| 26134 | | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 26135 | | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 26136 | | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 26137 | | }, |
| 26138 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26139 | | .kind = .all, |
| 26140 | | .inverted = switch (cc) { |
| 26141 | | else => unreachable, |
| 26142 | | .e => false, |
| 26143 | | .ne => true, |
| 26144 | | }, |
| 26145 | | .scalar = .dword, |
| 26146 | | } } }}, |
| 26147 | | .each = .{ .once = &.{ |
| 26148 | | .{ ._, .vp_d, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26149 | | } }, |
| 26150 | | }, .{ |
| 26151 | | .required_features = .{ .avx2, null, null, null }, |
| 26152 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 26153 | | .patterns = &.{ |
| 26154 | | .{ .src = .{ .to_ymm, .mem, .none } }, |
| 26155 | | .{ .src = .{ .mem, .to_ymm, .none }, .commute = .{ 0, 1 } }, |
| 26156 | | .{ .src = .{ .to_ymm, .to_ymm, .none } }, |
| 26157 | | }, |
| 26158 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26159 | | .kind = .all, |
| 26160 | | .inverted = switch (cc) { |
| 26161 | | else => unreachable, |
| 26162 | | .e => false, |
| 26163 | | .ne => true, |
| 26164 | | }, |
| 26165 | | .scalar = .qword, |
| 26166 | | } } }}, |
| 26167 | | .each = .{ .once = &.{ |
| 26168 | | .{ ._, .vp_q, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26169 | | } }, |
| 26170 | | }, .{ |
| 26171 | | .required_features = .{ .avx, null, null, null }, |
| 26172 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 26173 | | .patterns = &.{ |
| 26174 | | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 26175 | | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26176 | | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 26177 | | }, |
| 26178 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26179 | | .kind = .all, |
| 26180 | | .inverted = switch (cc) { |
| 26181 | | else => unreachable, |
| 26182 | | .e => false, |
| 26183 | | .ne => true, |
| 26184 | | }, |
| 26185 | | .scalar = .byte, |
| 26186 | | } } }}, |
| 26187 | | .each = .{ .once = &.{ |
| 26188 | | .{ ._, .vp_b, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26189 | | } }, |
| 26190 | | }, .{ |
| 26191 | | .required_features = .{ .avx, null, null, null }, |
| 26192 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 26193 | | .patterns = &.{ |
| 26194 | | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 26195 | | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26196 | | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 26197 | | }, |
| 26198 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26199 | | .kind = .all, |
| 26200 | | .inverted = switch (cc) { |
| 26201 | | else => unreachable, |
| 26202 | | .e => false, |
| 26203 | | .ne => true, |
| 26204 | | }, |
| 26205 | | .scalar = .word, |
| 26206 | | } } }}, |
| 26207 | | .each = .{ .once = &.{ |
| 26208 | | .{ ._, .vp_w, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26209 | | } }, |
| 26210 | | }, .{ |
| 26211 | | .required_features = .{ .avx, null, null, null }, |
| 26212 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 26213 | | .patterns = &.{ |
| 26214 | | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 26215 | | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26216 | | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 26217 | | }, |
| 26218 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26219 | | .kind = .all, |
| 26220 | | .inverted = switch (cc) { |
| 26221 | | else => unreachable, |
| 26222 | | .e => false, |
| 26223 | | .ne => true, |
| 26224 | | }, |
| 26225 | | .scalar = .dword, |
| 26226 | | } } }}, |
| 26227 | | .each = .{ .once = &.{ |
| 26228 | | .{ ._, .vp_d, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26229 | | } }, |
| 26230 | | }, .{ |
| 26231 | | .required_features = .{ .avx, null, null, null }, |
| 26232 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 26233 | | .patterns = &.{ |
| 26234 | | .{ .src = .{ .to_xmm, .mem, .none } }, |
| 26235 | | .{ .src = .{ .mem, .to_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26236 | | .{ .src = .{ .to_xmm, .to_xmm, .none } }, |
| 26237 | | }, |
| 26238 | | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26239 | | .kind = .all, |
| 26240 | | .inverted = switch (cc) { |
| 26241 | | else => unreachable, |
| 26242 | | .e => false, |
| 26243 | | .ne => true, |
| 26244 | | }, |
| 26245 | | .scalar = .qword, |
| 26246 | | } } }}, |
| 26247 | | .each = .{ .once = &.{ |
| 26248 | | .{ ._, .vp_q, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26249 | | } }, |
| 26250 | | }, .{ |
| 26251 | | .required_features = .{ .sse2, null, null, null }, |
| 26252 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 26253 | | .patterns = &.{ |
| 26254 | | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 26255 | | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26256 | | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 26257 | | }, |
| 26258 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26259 | | .kind = .all, |
| 26260 | | .inverted = switch (cc) { |
| 26261 | | else => unreachable, |
| 26262 | | .e => false, |
| 26263 | | .ne => true, |
| 26264 | | }, |
| 26265 | | .scalar = .byte, |
| 26266 | | } } }}, |
| 26267 | | .each = .{ .once = &.{ |
| 26268 | | .{ ._, .p_b, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26269 | | } }, |
| 26270 | | }, .{ |
| 26271 | | .required_features = .{ .sse2, null, null, null }, |
| 26272 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 26273 | | .patterns = &.{ |
| 26274 | | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 26275 | | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26276 | | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 26277 | | }, |
| 26278 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26279 | | .kind = .all, |
| 26280 | | .inverted = switch (cc) { |
| 26281 | | else => unreachable, |
| 26282 | | .e => false, |
| 26283 | | .ne => true, |
| 26284 | | }, |
| 26285 | | .scalar = .word, |
| 26286 | | } } }}, |
| 26287 | | .each = .{ .once = &.{ |
| 26288 | | .{ ._, .p_w, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26289 | | } }, |
| 26290 | | }, .{ |
| 26291 | | .required_features = .{ .sse2, null, null, null }, |
| 26292 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 26293 | | .patterns = &.{ |
| 26294 | | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 26295 | | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26296 | | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 26297 | | }, |
| 26298 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26299 | | .kind = .all, |
| 26300 | | .inverted = switch (cc) { |
| 26301 | | else => unreachable, |
| 26302 | | .e => false, |
| 26303 | | .ne => true, |
| 26304 | | }, |
| 26305 | | .scalar = .dword, |
| 26306 | | } } }}, |
| 26307 | | .each = .{ .once = &.{ |
| 26308 | | .{ ._, .p_d, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26309 | | } }, |
| 26310 | | }, .{ |
| 26311 | | .required_features = .{ .sse4_1, null, null, null }, |
| 26312 | | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 26313 | | .patterns = &.{ |
| 26314 | | .{ .src = .{ .to_mut_xmm, .mem, .none } }, |
| 26315 | | .{ .src = .{ .mem, .to_mut_xmm, .none }, .commute = .{ 0, 1 } }, |
| 26316 | | .{ .src = .{ .to_mut_xmm, .to_xmm, .none } }, |
| 26317 | | }, |
| 26318 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26319 | | .kind = .all, |
| 26320 | | .inverted = switch (cc) { |
| 26321 | | else => unreachable, |
| 26322 | | .e => false, |
| 26323 | | .ne => true, |
| 26324 | | }, |
| 26325 | | .scalar = .qword, |
| 26326 | | } } }}, |
| 26327 | | .each = .{ .once = &.{ |
| 26328 | | .{ ._, .p_q, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26329 | | } }, |
| 26330 | | }, .{ |
| 26331 | | .required_features = .{ .mmx, null, null, null }, |
| 26332 | | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| 26333 | | .patterns = &.{ |
| 26334 | | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 26335 | | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 26336 | | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 26337 | | }, |
| 26338 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26339 | | .kind = .all, |
| 26340 | | .inverted = switch (cc) { |
| 26341 | | else => unreachable, |
| 26342 | | .e => false, |
| 26343 | | .ne => true, |
| 26344 | | }, |
| 26345 | | .scalar = .byte, |
| 26346 | | } } }}, |
| 26347 | | .each = .{ .once = &.{ |
| 26348 | | .{ ._, .p_b, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 26349 | | } }, |
| 26350 | | }, .{ |
| 26351 | | .required_features = .{ .mmx, null, null, null }, |
| 26352 | | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 26353 | | .patterns = &.{ |
| 26354 | | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 26355 | | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 26356 | | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 26357 | | }, |
| 26358 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26359 | | .kind = .all, |
| 26360 | | .inverted = switch (cc) { |
| 26361 | | else => unreachable, |
| 26362 | | .e => false, |
| 26363 | | .ne => true, |
| 26364 | | }, |
| 26365 | | .scalar = .word, |
| 26366 | | } } }}, |
| 26367 | | .each = .{ .once = &.{ |
| 26368 | | .{ ._, .p_w, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 26369 | | } }, |
| 26370 | | }, .{ |
| 26371 | | .required_features = .{ .mmx, null, null, null }, |
| 26372 | | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 26373 | | .patterns = &.{ |
| 26374 | | .{ .src = .{ .to_mut_mm, .mem, .none } }, |
| 26375 | | .{ .src = .{ .mem, .to_mut_mm, .none }, .commute = .{ 0, 1 } }, |
| 26376 | | .{ .src = .{ .to_mut_mm, .to_mm, .none } }, |
| 26377 | | }, |
| 26378 | | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26379 | | .kind = .all, |
| 26380 | | .inverted = switch (cc) { |
| 26381 | | else => unreachable, |
| 26382 | | .e => false, |
| 26383 | | .ne => true, |
| 26384 | | }, |
| 26385 | | .scalar = .dword, |
| 26386 | | } } }}, |
| 26387 | | .each = .{ .once = &.{ |
| 26388 | | .{ ._, .p_d, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 26389 | | } }, |
| 26390 | | }, .{ |
| 26391 | 26213 | .src_constraints = .{ .{ .bool_vec = .byte }, .{ .bool_vec = .byte }, .any }, |
| 26392 | 26214 | .patterns = &.{ |
| 26393 | 26215 | .{ .src = .{ .mut_mem, .imm8, .none } }, |
| ... | ... | @@ -26526,6 +26348,366 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26526 | 26348 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 26527 | 26349 | }, |
| 26528 | 26350 | } }, |
| 26351 | }, .{ |
| 26352 | .required_features = .{ .avx, null, null, null }, |
| 26353 | .src_constraints = .{ |
| 26354 | .{ .scalar_int = .{ .of = .xword, .is = .byte } }, |
| 26355 | .{ .scalar_int = .{ .of = .xword, .is = .byte } }, |
| 26356 | .any, |
| 26357 | }, |
| 26358 | .patterns = &.{ |
| 26359 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26360 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26361 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26362 | }, |
| 26363 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26364 | .kind = .all, |
| 26365 | .inverted = switch (cc) { |
| 26366 | else => unreachable, |
| 26367 | .e => false, |
| 26368 | .ne => true, |
| 26369 | }, |
| 26370 | .scalar = .byte, |
| 26371 | } } }}, |
| 26372 | .each = .{ .once = &.{ |
| 26373 | .{ ._, .vp_b, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26374 | } }, |
| 26375 | }, .{ |
| 26376 | .required_features = .{ .avx, null, null, null }, |
| 26377 | .src_constraints = .{ |
| 26378 | .{ .scalar_int = .{ .of = .xword, .is = .word } }, |
| 26379 | .{ .scalar_int = .{ .of = .xword, .is = .word } }, |
| 26380 | .any, |
| 26381 | }, |
| 26382 | .patterns = &.{ |
| 26383 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26384 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26385 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26386 | }, |
| 26387 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26388 | .kind = .all, |
| 26389 | .inverted = switch (cc) { |
| 26390 | else => unreachable, |
| 26391 | .e => false, |
| 26392 | .ne => true, |
| 26393 | }, |
| 26394 | .scalar = .word, |
| 26395 | } } }}, |
| 26396 | .each = .{ .once = &.{ |
| 26397 | .{ ._, .vp_w, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26398 | } }, |
| 26399 | }, .{ |
| 26400 | .required_features = .{ .avx, null, null, null }, |
| 26401 | .src_constraints = .{ |
| 26402 | .{ .scalar_int = .{ .of = .xword, .is = .dword } }, |
| 26403 | .{ .scalar_int = .{ .of = .xword, .is = .dword } }, |
| 26404 | .any, |
| 26405 | }, |
| 26406 | .patterns = &.{ |
| 26407 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26408 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26409 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26410 | }, |
| 26411 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26412 | .kind = .all, |
| 26413 | .inverted = switch (cc) { |
| 26414 | else => unreachable, |
| 26415 | .e => false, |
| 26416 | .ne => true, |
| 26417 | }, |
| 26418 | .scalar = .dword, |
| 26419 | } } }}, |
| 26420 | .each = .{ .once = &.{ |
| 26421 | .{ ._, .vp_d, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26422 | } }, |
| 26423 | }, .{ |
| 26424 | .required_features = .{ .avx, null, null, null }, |
| 26425 | .src_constraints = .{ |
| 26426 | .{ .scalar_int = .{ .of = .xword, .is = .qword } }, |
| 26427 | .{ .scalar_int = .{ .of = .xword, .is = .qword } }, |
| 26428 | .any, |
| 26429 | }, |
| 26430 | .patterns = &.{ |
| 26431 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26432 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26433 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26434 | }, |
| 26435 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26436 | .kind = .all, |
| 26437 | .inverted = switch (cc) { |
| 26438 | else => unreachable, |
| 26439 | .e => false, |
| 26440 | .ne => true, |
| 26441 | }, |
| 26442 | .scalar = .qword, |
| 26443 | } } }}, |
| 26444 | .each = .{ .once = &.{ |
| 26445 | .{ ._, .vp_q, .cmpeq, .dst0x, .src0x, .src1x, ._ }, |
| 26446 | } }, |
| 26447 | }, .{ |
| 26448 | .required_features = .{ .sse2, null, null, null }, |
| 26449 | .src_constraints = .{ |
| 26450 | .{ .scalar_int = .{ .of = .xword, .is = .byte } }, |
| 26451 | .{ .scalar_int = .{ .of = .xword, .is = .byte } }, |
| 26452 | .any, |
| 26453 | }, |
| 26454 | .patterns = &.{ |
| 26455 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26456 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26457 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 26458 | }, |
| 26459 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26460 | .kind = .all, |
| 26461 | .inverted = switch (cc) { |
| 26462 | else => unreachable, |
| 26463 | .e => false, |
| 26464 | .ne => true, |
| 26465 | }, |
| 26466 | .scalar = .byte, |
| 26467 | } } }}, |
| 26468 | .each = .{ .once = &.{ |
| 26469 | .{ ._, .p_b, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26470 | } }, |
| 26471 | }, .{ |
| 26472 | .required_features = .{ .sse2, null, null, null }, |
| 26473 | .src_constraints = .{ |
| 26474 | .{ .scalar_int = .{ .of = .xword, .is = .word } }, |
| 26475 | .{ .scalar_int = .{ .of = .xword, .is = .word } }, |
| 26476 | .any, |
| 26477 | }, |
| 26478 | .patterns = &.{ |
| 26479 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26480 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26481 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 26482 | }, |
| 26483 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26484 | .kind = .all, |
| 26485 | .inverted = switch (cc) { |
| 26486 | else => unreachable, |
| 26487 | .e => false, |
| 26488 | .ne => true, |
| 26489 | }, |
| 26490 | .scalar = .word, |
| 26491 | } } }}, |
| 26492 | .each = .{ .once = &.{ |
| 26493 | .{ ._, .p_w, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26494 | } }, |
| 26495 | }, .{ |
| 26496 | .required_features = .{ .sse2, null, null, null }, |
| 26497 | .src_constraints = .{ |
| 26498 | .{ .scalar_int = .{ .of = .xword, .is = .dword } }, |
| 26499 | .{ .scalar_int = .{ .of = .xword, .is = .dword } }, |
| 26500 | .any, |
| 26501 | }, |
| 26502 | .patterns = &.{ |
| 26503 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26504 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26505 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 26506 | }, |
| 26507 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26508 | .kind = .all, |
| 26509 | .inverted = switch (cc) { |
| 26510 | else => unreachable, |
| 26511 | .e => false, |
| 26512 | .ne => true, |
| 26513 | }, |
| 26514 | .scalar = .dword, |
| 26515 | } } }}, |
| 26516 | .each = .{ .once = &.{ |
| 26517 | .{ ._, .p_d, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26518 | } }, |
| 26519 | }, .{ |
| 26520 | .required_features = .{ .sse4_1, null, null, null }, |
| 26521 | .src_constraints = .{ |
| 26522 | .{ .scalar_int = .{ .of = .xword, .is = .qword } }, |
| 26523 | .{ .scalar_int = .{ .of = .xword, .is = .qword } }, |
| 26524 | .any, |
| 26525 | }, |
| 26526 | .patterns = &.{ |
| 26527 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 26528 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, |
| 26529 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 26530 | }, |
| 26531 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26532 | .kind = .all, |
| 26533 | .inverted = switch (cc) { |
| 26534 | else => unreachable, |
| 26535 | .e => false, |
| 26536 | .ne => true, |
| 26537 | }, |
| 26538 | .scalar = .qword, |
| 26539 | } } }}, |
| 26540 | .each = .{ .once = &.{ |
| 26541 | .{ ._, .p_q, .cmpeq, .dst0x, .src1x, ._, ._ }, |
| 26542 | } }, |
| 26543 | }, .{ |
| 26544 | .required_features = .{ .mmx, null, null, null }, |
| 26545 | .src_constraints = .{ |
| 26546 | .{ .scalar_int = .{ .of = .qword, .is = .byte } }, |
| 26547 | .{ .scalar_int = .{ .of = .qword, .is = .byte } }, |
| 26548 | .any, |
| 26549 | }, |
| 26550 | .patterns = &.{ |
| 26551 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 26552 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 26553 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 26554 | }, |
| 26555 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26556 | .kind = .all, |
| 26557 | .inverted = switch (cc) { |
| 26558 | else => unreachable, |
| 26559 | .e => false, |
| 26560 | .ne => true, |
| 26561 | }, |
| 26562 | .scalar = .byte, |
| 26563 | } } }}, |
| 26564 | .each = .{ .once = &.{ |
| 26565 | .{ ._, .p_b, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 26566 | } }, |
| 26567 | }, .{ |
| 26568 | .required_features = .{ .mmx, null, null, null }, |
| 26569 | .src_constraints = .{ |
| 26570 | .{ .scalar_int = .{ .of = .qword, .is = .word } }, |
| 26571 | .{ .scalar_int = .{ .of = .qword, .is = .word } }, |
| 26572 | .any, |
| 26573 | }, |
| 26574 | .patterns = &.{ |
| 26575 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 26576 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 26577 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 26578 | }, |
| 26579 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26580 | .kind = .all, |
| 26581 | .inverted = switch (cc) { |
| 26582 | else => unreachable, |
| 26583 | .e => false, |
| 26584 | .ne => true, |
| 26585 | }, |
| 26586 | .scalar = .word, |
| 26587 | } } }}, |
| 26588 | .each = .{ .once = &.{ |
| 26589 | .{ ._, .p_w, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 26590 | } }, |
| 26591 | }, .{ |
| 26592 | .required_features = .{ .mmx, null, null, null }, |
| 26593 | .src_constraints = .{ |
| 26594 | .{ .scalar_int = .{ .of = .qword, .is = .dword } }, |
| 26595 | .{ .scalar_int = .{ .of = .qword, .is = .dword } }, |
| 26596 | .any, |
| 26597 | }, |
| 26598 | .patterns = &.{ |
| 26599 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 26600 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 26601 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 26602 | }, |
| 26603 | .dst_temps = .{.{ .ref_mask = .{ .ref = .src0, .info = .{ |
| 26604 | .kind = .all, |
| 26605 | .inverted = switch (cc) { |
| 26606 | else => unreachable, |
| 26607 | .e => false, |
| 26608 | .ne => true, |
| 26609 | }, |
| 26610 | .scalar = .dword, |
| 26611 | } } }}, |
| 26612 | .each = .{ .once = &.{ |
| 26613 | .{ ._, .p_d, .cmpeq, .dst0q, .src1q, ._, ._ }, |
| 26614 | } }, |
| 26615 | }, .{ |
| 26616 | .required_features = .{ .avx2, null, null, null }, |
| 26617 | .src_constraints = .{ |
| 26618 | .{ .scalar_int = .{ .of = .yword, .is = .byte } }, |
| 26619 | .{ .scalar_int = .{ .of = .yword, .is = .byte } }, |
| 26620 | .any, |
| 26621 | }, |
| 26622 | .patterns = &.{ |
| 26623 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26624 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26625 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26626 | }, |
| 26627 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26628 | .kind = .all, |
| 26629 | .inverted = switch (cc) { |
| 26630 | else => unreachable, |
| 26631 | .e => false, |
| 26632 | .ne => true, |
| 26633 | }, |
| 26634 | .scalar = .byte, |
| 26635 | } } }}, |
| 26636 | .each = .{ .once = &.{ |
| 26637 | .{ ._, .vp_b, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26638 | } }, |
| 26639 | }, .{ |
| 26640 | .required_features = .{ .avx2, null, null, null }, |
| 26641 | .src_constraints = .{ |
| 26642 | .{ .scalar_int = .{ .of = .yword, .is = .word } }, |
| 26643 | .{ .scalar_int = .{ .of = .yword, .is = .word } }, |
| 26644 | .any, |
| 26645 | }, |
| 26646 | .patterns = &.{ |
| 26647 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26648 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26649 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26650 | }, |
| 26651 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26652 | .kind = .all, |
| 26653 | .inverted = switch (cc) { |
| 26654 | else => unreachable, |
| 26655 | .e => false, |
| 26656 | .ne => true, |
| 26657 | }, |
| 26658 | .scalar = .word, |
| 26659 | } } }}, |
| 26660 | .each = .{ .once = &.{ |
| 26661 | .{ ._, .vp_w, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26662 | } }, |
| 26663 | }, .{ |
| 26664 | .required_features = .{ .avx2, null, null, null }, |
| 26665 | .src_constraints = .{ |
| 26666 | .{ .scalar_int = .{ .of = .yword, .is = .dword } }, |
| 26667 | .{ .scalar_int = .{ .of = .yword, .is = .dword } }, |
| 26668 | .any, |
| 26669 | }, |
| 26670 | .patterns = &.{ |
| 26671 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26672 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26673 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26674 | }, |
| 26675 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26676 | .kind = .all, |
| 26677 | .inverted = switch (cc) { |
| 26678 | else => unreachable, |
| 26679 | .e => false, |
| 26680 | .ne => true, |
| 26681 | }, |
| 26682 | .scalar = .dword, |
| 26683 | } } }}, |
| 26684 | .each = .{ .once = &.{ |
| 26685 | .{ ._, .vp_d, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26686 | } }, |
| 26687 | }, .{ |
| 26688 | .required_features = .{ .avx2, null, null, null }, |
| 26689 | .src_constraints = .{ |
| 26690 | .{ .scalar_int = .{ .of = .yword, .is = .qword } }, |
| 26691 | .{ .scalar_int = .{ .of = .yword, .is = .qword } }, |
| 26692 | .any, |
| 26693 | }, |
| 26694 | .patterns = &.{ |
| 26695 | .{ .src = .{ .to_sse, .mem, .none } }, |
| 26696 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, |
| 26697 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 26698 | }, |
| 26699 | .dst_temps = .{.{ .mut_rc_mask = .{ .ref = .src0, .rc = .sse, .info = .{ |
| 26700 | .kind = .all, |
| 26701 | .inverted = switch (cc) { |
| 26702 | else => unreachable, |
| 26703 | .e => false, |
| 26704 | .ne => true, |
| 26705 | }, |
| 26706 | .scalar = .qword, |
| 26707 | } } }}, |
| 26708 | .each = .{ .once = &.{ |
| 26709 | .{ ._, .vp_q, .cmpeq, .dst0y, .src0y, .src1y, ._ }, |
| 26710 | } }, |
| 26529 | 26711 | }, .{ |
| 26530 | 26712 | .required_features = .{ .avx2, null, null, null }, |
| 26531 | 26713 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, |
| ... | ... | @@ -27511,7 +27693,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27511 | 27693 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 27512 | 27694 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 27513 | 27695 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 27514 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27696 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27515 | 27697 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27516 | 27698 | } }, |
| 27517 | 27699 | }, .{ |
| ... | ... | @@ -27683,7 +27865,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27683 | 27865 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 27684 | 27866 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 27685 | 27867 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 27686 | | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 27868 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27687 | 27869 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27688 | 27870 | } }, |
| 27689 | 27871 | }, .{ |
| ... | ... | @@ -27852,8 +28034,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27852 | 28034 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 27853 | 28035 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 27854 | 28036 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 27855 | | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 27856 | | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 28037 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 28038 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 27857 | 28039 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 27858 | 28040 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 27859 | 28041 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| ... | ... | @@ -27944,6 +28126,133 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27944 | 28126 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 27945 | 28127 | .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ }, |
| 27946 | 28128 | } }, |
| 28129 | }, .{ |
| 28130 | .src_constraints = .{ .{ .scalar_int_is = .word }, .{ .scalar_int_is = .word }, .any }, |
| 28131 | .patterns = &.{ |
| 28132 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 28133 | }, |
| 28134 | .extra_temps = .{ |
| 28135 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28136 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28137 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28138 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28139 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 28140 | .unused, |
| 28141 | .unused, |
| 28142 | .unused, |
| 28143 | .unused, |
| 28144 | }, |
| 28145 | .dst_temps = .{.mem}, |
| 28146 | .clobbers = .{ .eflags = true }, |
| 28147 | .each = .{ .once = &.{ |
| 28148 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 28149 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 28150 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28151 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 28152 | .{ ._, ._, .mov, .tmp4w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, |
| 28153 | .{ ._, ._, .cmp, .tmp4w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, |
| 28154 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 28155 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, |
| 28156 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, |
| 28157 | .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, |
| 28158 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 28159 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 28160 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 28161 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 28162 | .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ }, |
| 28163 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28164 | .{ .@"1:", ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 28165 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28166 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 28167 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 28168 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 28169 | .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ }, |
| 28170 | } }, |
| 28171 | }, .{ |
| 28172 | .src_constraints = .{ .{ .scalar_int_is = .dword }, .{ .scalar_int_is = .dword }, .any }, |
| 28173 | .patterns = &.{ |
| 28174 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 28175 | }, |
| 28176 | .extra_temps = .{ |
| 28177 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28178 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28179 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28180 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28181 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 28182 | .unused, |
| 28183 | .unused, |
| 28184 | .unused, |
| 28185 | .unused, |
| 28186 | }, |
| 28187 | .dst_temps = .{.mem}, |
| 28188 | .clobbers = .{ .eflags = true }, |
| 28189 | .each = .{ .once = &.{ |
| 28190 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 28191 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 28192 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28193 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 28194 | .{ ._, ._, .mov, .tmp4d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, |
| 28195 | .{ ._, ._, .cmp, .tmp4d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, |
| 28196 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 28197 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, |
| 28198 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, |
| 28199 | .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, |
| 28200 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 28201 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 28202 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 28203 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 28204 | .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ }, |
| 28205 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28206 | .{ .@"1:", ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 28207 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28208 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 28209 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 28210 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 28211 | .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ }, |
| 28212 | } }, |
| 28213 | }, .{ |
| 28214 | .required_features = .{ .@"64bit", null, null, null }, |
| 28215 | .src_constraints = .{ .{ .scalar_int_is = .qword }, .{ .scalar_int_is = .qword }, .any }, |
| 28216 | .patterns = &.{ |
| 28217 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 28218 | }, |
| 28219 | .extra_temps = .{ |
| 28220 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 28221 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 28222 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28223 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 28224 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 28225 | .unused, |
| 28226 | .unused, |
| 28227 | .unused, |
| 28228 | .unused, |
| 28229 | }, |
| 28230 | .dst_temps = .{.mem}, |
| 28231 | .clobbers = .{ .eflags = true }, |
| 28232 | .each = .{ .once = &.{ |
| 28233 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 28234 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 28235 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28236 | .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| 28237 | .{ ._, ._, .mov, .tmp4q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 28238 | .{ ._, ._, .cmp, .tmp4q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 28239 | .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, |
| 28240 | .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, |
| 28241 | .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, |
| 28242 | .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, |
| 28243 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 28244 | .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, |
| 28245 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| 28246 | .{ ._, ._r, .sh, .tmp3d, .ui(3), ._, ._ }, |
| 28247 | .{ ._, ._, .mov, .memia(.dst0p, .tmp3, .sub_ptr_size), .tmp2p, ._, ._ }, |
| 28248 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 28249 | .{ .@"1:", ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 28250 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 28251 | .{ ._, ._, .@"test", .tmp1d, .sia(-1, .none, .add_ptr_bit_size), ._, ._ }, |
| 28252 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| 28253 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 28254 | .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ }, |
| 28255 | } }, |
| 27947 | 28256 | }, .{ |
| 27948 | 28257 | .required_features = .{ .f16c, null, null, null }, |
| 27949 | 28258 | .src_constraints = .{ |
| ... | ... | @@ -48604,9 +48913,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 48604 | 48913 | try ops[0].toPair(&len, cg); |
| 48605 | 48914 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 48606 | 48915 | }, |
| 48607 | | .int_from_float, .int_from_float_optimized => |air_tag| if (use_old) try cg.airIntFromFloat(inst) else fallback: { |
| 48916 | .int_from_float, .int_from_float_optimized => |air_tag| if (use_old) try cg.airIntFromFloat(inst) else { |
| 48608 | 48917 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 48609 | | if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airIntFromFloat(inst); |
| 48610 | 48918 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 48611 | 48919 | var res: [1]Temp = undefined; |
| 48612 | 48920 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| ... | ... | @@ -48991,292 +49299,226 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 48991 | 49299 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 48992 | 49300 | } }, |
| 48993 | 49301 | }, .{ |
| 48994 | | .required_features = .{ .avx, null, null, null }, |
| 48995 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 48996 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 48997 | | .patterns = &.{ |
| 48998 | | .{ .src = .{ .mem, .none, .none } }, |
| 48999 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49000 | | }, |
| 49001 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49002 | | .each = .{ .once = &.{ |
| 49003 | | .{ ._, .v_, .cvttss2si, .dst0d, .src0d, ._, ._ }, |
| 49004 | | } }, |
| 49005 | | }, .{ |
| 49006 | | .required_features = .{ .sse, null, null, null }, |
| 49007 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49008 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 49009 | | .patterns = &.{ |
| 49010 | | .{ .src = .{ .mem, .none, .none } }, |
| 49011 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49012 | | }, |
| 49013 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49014 | | .each = .{ .once = &.{ |
| 49015 | | .{ ._, ._, .cvttss2si, .dst0d, .src0d, ._, ._ }, |
| 49016 | | } }, |
| 49017 | | }, .{ |
| 49018 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49019 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49020 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 49021 | | .patterns = &.{ |
| 49022 | | .{ .src = .{ .mem, .none, .none } }, |
| 49023 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49024 | | }, |
| 49025 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49026 | | .each = .{ .once = &.{ |
| 49027 | | .{ ._, .v_, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 49028 | | } }, |
| 49029 | | }, .{ |
| 49030 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49031 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49032 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 49302 | .required_features = .{ .f16c, null, null, null }, |
| 49303 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49304 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 49033 | 49305 | .patterns = &.{ |
| 49034 | 49306 | .{ .src = .{ .mem, .none, .none } }, |
| 49035 | 49307 | .{ .src = .{ .to_sse, .none, .none } }, |
| 49036 | 49308 | }, |
| 49037 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49038 | | .each = .{ .once = &.{ |
| 49039 | | .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 49040 | | } }, |
| 49041 | | }, .{ |
| 49042 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49043 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49044 | | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 49045 | | .patterns = &.{ |
| 49046 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49047 | | }, |
| 49048 | 49309 | .extra_temps = .{ |
| 49049 | | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 49050 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49051 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49052 | | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 49310 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 49311 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 49312 | .unused, |
| 49313 | .unused, |
| 49053 | 49314 | .unused, |
| 49054 | 49315 | .unused, |
| 49055 | 49316 | .unused, |
| 49056 | 49317 | .unused, |
| 49057 | 49318 | .unused, |
| 49058 | 49319 | }, |
| 49059 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49060 | | .clobbers = .{ .eflags = true }, |
| 49320 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 49061 | 49321 | .each = .{ .once = &.{ |
| 49062 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 49063 | | .{ ._, .v_, .cvttss2si, .tmp2q, .src0d, ._, ._ }, |
| 49064 | | .{ ._, .v_ss, .sub, .tmp0x, .src0x, .lea(.tmp1d), ._ }, |
| 49065 | | .{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ }, |
| 49066 | | .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ }, |
| 49067 | | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| 49068 | | .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ }, |
| 49069 | | .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ }, |
| 49322 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 49323 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 49324 | .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ }, |
| 49325 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 49070 | 49326 | } }, |
| 49071 | 49327 | }, .{ |
| 49072 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49073 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49074 | | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 49328 | .required_features = .{ .f16c, null, null, null }, |
| 49329 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49330 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 49075 | 49331 | .patterns = &.{ |
| 49076 | | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 49332 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49077 | 49333 | }, |
| 49078 | 49334 | .extra_temps = .{ |
| 49079 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49080 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49081 | | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 49082 | | .unused, |
| 49335 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49336 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 49337 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 49338 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 49083 | 49339 | .unused, |
| 49084 | 49340 | .unused, |
| 49085 | 49341 | .unused, |
| 49086 | 49342 | .unused, |
| 49087 | 49343 | .unused, |
| 49088 | 49344 | }, |
| 49089 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49090 | | .clobbers = .{ .eflags = true }, |
| 49345 | .dst_temps = .{.mem}, |
| 49091 | 49346 | .each = .{ .once = &.{ |
| 49092 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 49093 | | .{ ._, ._, .cvttss2si, .tmp1q, .src0d, ._, ._ }, |
| 49094 | | .{ ._, ._ss, .sub, .src0x, .lea(.tmp0d), ._, ._ }, |
| 49095 | | .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 49096 | | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| 49097 | | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 49098 | | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| 49099 | | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 49347 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 49348 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 49349 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49350 | .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 49351 | .{ ._, .v_, .cvttps2dq, .tmp3x, .tmp3x, ._, ._ }, |
| 49352 | .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 49353 | .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 49354 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 49355 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49100 | 49356 | } }, |
| 49101 | 49357 | }, .{ |
| 49102 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49103 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49104 | | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 49358 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 49359 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49360 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49105 | 49361 | .patterns = &.{ |
| 49106 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49362 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49107 | 49363 | }, |
| 49108 | 49364 | .call_frame = .{ .alignment = .@"16" }, |
| 49109 | 49365 | .extra_temps = .{ |
| 49110 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } }, |
| 49111 | | .unused, |
| 49112 | | .unused, |
| 49113 | | .unused, |
| 49366 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49367 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49368 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49369 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49114 | 49370 | .unused, |
| 49115 | 49371 | .unused, |
| 49116 | 49372 | .unused, |
| 49117 | 49373 | .unused, |
| 49118 | 49374 | .unused, |
| 49119 | 49375 | }, |
| 49120 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 49376 | .dst_temps = .{.mem}, |
| 49121 | 49377 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49122 | 49378 | .each = .{ .once = &.{ |
| 49123 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 49379 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49380 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49381 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0) }, |
| 49382 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49383 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 49384 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 49385 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49124 | 49386 | } }, |
| 49125 | 49387 | }, .{ |
| 49126 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49127 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49128 | | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 49388 | .required_features = .{ .avx, null, null, null }, |
| 49389 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49390 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49129 | 49391 | .patterns = &.{ |
| 49130 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49392 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49131 | 49393 | }, |
| 49132 | 49394 | .call_frame = .{ .alignment = .@"16" }, |
| 49133 | 49395 | .extra_temps = .{ |
| 49134 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 49135 | | .unused, |
| 49136 | | .unused, |
| 49137 | | .unused, |
| 49396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49398 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49399 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49138 | 49400 | .unused, |
| 49139 | 49401 | .unused, |
| 49140 | 49402 | .unused, |
| 49141 | 49403 | .unused, |
| 49142 | 49404 | .unused, |
| 49143 | 49405 | }, |
| 49144 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 49406 | .dst_temps = .{.mem}, |
| 49145 | 49407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49146 | 49408 | .each = .{ .once = &.{ |
| 49147 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 49409 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49410 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49411 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0) }, |
| 49412 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49413 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 49414 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 49415 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 49148 | 49416 | } }, |
| 49149 | 49417 | }, .{ |
| 49150 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49151 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49152 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49418 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 49419 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49420 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49153 | 49421 | .patterns = &.{ |
| 49154 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49422 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49155 | 49423 | }, |
| 49156 | 49424 | .call_frame = .{ .alignment = .@"16" }, |
| 49157 | 49425 | .extra_temps = .{ |
| 49158 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49159 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49160 | | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 49161 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 49162 | | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49163 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49164 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 49426 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49427 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49428 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49429 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49430 | .unused, |
| 49431 | .unused, |
| 49432 | .unused, |
| 49165 | 49433 | .unused, |
| 49166 | 49434 | .unused, |
| 49167 | 49435 | }, |
| 49168 | 49436 | .dst_temps = .{.mem}, |
| 49169 | 49437 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49170 | 49438 | .each = .{ .once = &.{ |
| 49171 | | .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ }, |
| 49172 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 49173 | | .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, |
| 49174 | | .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ }, |
| 49175 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 49176 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 49177 | | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| 49178 | | .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, |
| 49179 | | .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, |
| 49180 | | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 49181 | | .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, |
| 49182 | | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, |
| 49183 | | .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, |
| 49184 | | .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, |
| 49185 | | .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 49186 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 49439 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49440 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49441 | .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49442 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49443 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 49444 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 49445 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49187 | 49446 | } }, |
| 49188 | 49447 | }, .{ |
| 49189 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 49190 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49191 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49448 | .required_features = .{ .sse2, null, null, null }, |
| 49449 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49450 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49192 | 49451 | .patterns = &.{ |
| 49193 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49452 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49194 | 49453 | }, |
| 49195 | 49454 | .call_frame = .{ .alignment = .@"16" }, |
| 49196 | 49455 | .extra_temps = .{ |
| 49197 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49198 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49199 | | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 49200 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 49201 | | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49202 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49203 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 49456 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49457 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49458 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49459 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49460 | .unused, |
| 49461 | .unused, |
| 49462 | .unused, |
| 49204 | 49463 | .unused, |
| 49205 | 49464 | .unused, |
| 49206 | 49465 | }, |
| 49207 | 49466 | .dst_temps = .{.mem}, |
| 49208 | 49467 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49209 | 49468 | .each = .{ .once = &.{ |
| 49210 | | .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ }, |
| 49211 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 49212 | | .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, |
| 49213 | | .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ }, |
| 49214 | | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 49215 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 49216 | | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| 49217 | | .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, |
| 49218 | | .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, |
| 49219 | | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 49220 | | .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, |
| 49221 | | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, |
| 49222 | | .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, |
| 49223 | | .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, |
| 49224 | | .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 49225 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 49469 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49470 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49471 | .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49472 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49473 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 49474 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 49475 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 49226 | 49476 | } }, |
| 49227 | 49477 | }, .{ |
| 49228 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49229 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49230 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49478 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 49479 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49480 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49231 | 49481 | .patterns = &.{ |
| 49232 | 49482 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49233 | 49483 | }, |
| 49234 | 49484 | .call_frame = .{ .alignment = .@"16" }, |
| 49235 | 49485 | .extra_temps = .{ |
| 49236 | | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 49237 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49238 | | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 49239 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 49240 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 49241 | | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49242 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49486 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49487 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49488 | .{ .type = .f32, .kind = .mem }, |
| 49489 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49490 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49491 | .unused, |
| 49492 | .unused, |
| 49243 | 49493 | .unused, |
| 49244 | 49494 | .unused, |
| 49245 | 49495 | }, |
| 49246 | 49496 | .dst_temps = .{.mem}, |
| 49247 | 49497 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49248 | 49498 | .each = .{ .once = &.{ |
| 49249 | | .{ ._, ._ss, .mov, .tmp0x, .src0d, ._, ._ }, |
| 49250 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 49251 | | .{ ._, ._ps, .@"and", .tmp0x, .lea(.tmp1x), ._, ._ }, |
| 49252 | | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 49253 | | .{ ._, ._d, .movsx, .tmp4q, .src0d, ._, ._ }, |
| 49254 | | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, |
| 49255 | | .{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ }, |
| 49256 | | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| 49257 | | .{ ._, ._, .sub, .tmp1q, .tmp4q, ._, ._ }, |
| 49258 | | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 49259 | | .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ }, |
| 49260 | | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp5q, ._, ._ }, |
| 49261 | | .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, |
| 49262 | | .{ ._, ._, .lea, .tmp6p, .memd(.dst0, 16), ._, ._ }, |
| 49263 | | .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 49264 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 49499 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49500 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 49501 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49502 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49503 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49504 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 49505 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 49506 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49265 | 49507 | } }, |
| 49266 | 49508 | }, .{ |
| 49267 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49268 | | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 49269 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49509 | .required_features = .{ .sse, null, null, null }, |
| 49510 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49511 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49270 | 49512 | .patterns = &.{ |
| 49271 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49513 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49272 | 49514 | }, |
| 49273 | 49515 | .call_frame = .{ .alignment = .@"16" }, |
| 49274 | 49516 | .extra_temps = .{ |
| 49275 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 49276 | | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49277 | | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49278 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49279 | | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 49517 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49518 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49519 | .{ .type = .f32, .kind = .mem }, |
| 49520 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49521 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49280 | 49522 | .unused, |
| 49281 | 49523 | .unused, |
| 49282 | 49524 | .unused, |
| ... | ... | @@ -49285,48 +49527,53 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49285 | 49527 | .dst_temps = .{.mem}, |
| 49286 | 49528 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49287 | 49529 | .each = .{ .once = &.{ |
| 49288 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 49289 | | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 49290 | | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ }, |
| 49291 | | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 49292 | | .{ ._, ._, .lea, .tmp3p, .memd(.dst0, 16), ._, ._ }, |
| 49293 | | .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 49294 | | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 49530 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49531 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 49532 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49533 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49534 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49535 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 49536 | .{ ._, ._c, .in, .tmp0p, .si(1), ._, ._ }, |
| 49537 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 49295 | 49538 | } }, |
| 49296 | 49539 | }, .{ |
| 49297 | | .required_features = .{ .avx, null, null, null }, |
| 49298 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49299 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 49540 | .required_features = .{ .f16c, null, null, null }, |
| 49541 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49542 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .word } }}, |
| 49300 | 49543 | .patterns = &.{ |
| 49301 | 49544 | .{ .src = .{ .mem, .none, .none } }, |
| 49302 | 49545 | .{ .src = .{ .to_sse, .none, .none } }, |
| 49303 | 49546 | }, |
| 49304 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49547 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 49305 | 49548 | .each = .{ .once = &.{ |
| 49306 | | .{ ._, .v_, .cvttsd2si, .dst0d, .src0q, ._, ._ }, |
| 49549 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 49550 | .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ }, |
| 49551 | .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ }, |
| 49307 | 49552 | } }, |
| 49308 | 49553 | }, .{ |
| 49309 | | .required_features = .{ .sse2, null, null, null }, |
| 49310 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49311 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 49554 | .required_features = .{ .f16c, null, null, null }, |
| 49555 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49556 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 49312 | 49557 | .patterns = &.{ |
| 49313 | 49558 | .{ .src = .{ .mem, .none, .none } }, |
| 49314 | 49559 | .{ .src = .{ .to_sse, .none, .none } }, |
| 49315 | 49560 | }, |
| 49316 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49561 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 49317 | 49562 | .each = .{ .once = &.{ |
| 49318 | | .{ ._, ._, .cvttsd2si, .dst0d, .src0q, ._, ._ }, |
| 49563 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 49564 | .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ }, |
| 49565 | .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ }, |
| 49319 | 49566 | } }, |
| 49320 | 49567 | }, .{ |
| 49321 | | .required_features = .{ .x87, null, null, null }, |
| 49322 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49323 | | .dst_constraints = .{.{ .signed_int = .byte }}, |
| 49568 | .required_features = .{ .f16c, null, null, null }, |
| 49569 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49570 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 49324 | 49571 | .patterns = &.{ |
| 49325 | 49572 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49326 | 49573 | }, |
| 49327 | 49574 | .extra_temps = .{ |
| 49328 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49329 | | .{ .type = .i16, .kind = .mem }, |
| 49575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49576 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 49330 | 49577 | .unused, |
| 49331 | 49578 | .unused, |
| 49332 | 49579 | .unused, |
| ... | ... | @@ -49335,22 +49582,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49335 | 49582 | .unused, |
| 49336 | 49583 | .unused, |
| 49337 | 49584 | }, |
| 49338 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49585 | .dst_temps = .{.mem}, |
| 49339 | 49586 | .each = .{ .once = &.{ |
| 49340 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 49341 | | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 49342 | | .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ }, |
| 49587 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49588 | .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49589 | .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ }, |
| 49590 | .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49591 | .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 49592 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 49593 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49343 | 49594 | } }, |
| 49344 | 49595 | }, .{ |
| 49345 | | .required_features = .{ .x87, null, null, null }, |
| 49346 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49347 | | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 49596 | .required_features = .{ .f16c, null, null, null }, |
| 49597 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49598 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 49348 | 49599 | .patterns = &.{ |
| 49349 | 49600 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49350 | 49601 | }, |
| 49351 | 49602 | .extra_temps = .{ |
| 49352 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49353 | | .{ .type = .i16, .kind = .mem }, |
| 49603 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49604 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 49354 | 49605 | .unused, |
| 49355 | 49606 | .unused, |
| 49356 | 49607 | .unused, |
| ... | ... | @@ -49359,24 +49610,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49359 | 49610 | .unused, |
| 49360 | 49611 | .unused, |
| 49361 | 49612 | }, |
| 49362 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49613 | .dst_temps = .{.mem}, |
| 49363 | 49614 | .each = .{ .once = &.{ |
| 49364 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 49365 | | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 49366 | | .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ }, |
| 49615 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49616 | .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49617 | .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ }, |
| 49618 | .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49619 | .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 49620 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 49621 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49367 | 49622 | } }, |
| 49368 | 49623 | }, .{ |
| 49369 | | .required_features = .{ .x87, null, null, null }, |
| 49370 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49371 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .word }}, |
| 49624 | .required_features = .{ .avx, null, null, null }, |
| 49625 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49626 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 49372 | 49627 | .patterns = &.{ |
| 49373 | 49628 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49374 | 49629 | }, |
| 49630 | .call_frame = .{ .alignment = .@"16" }, |
| 49375 | 49631 | .extra_temps = .{ |
| 49376 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49377 | | .unused, |
| 49378 | | .unused, |
| 49379 | | .unused, |
| 49632 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49633 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49634 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49635 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49380 | 49636 | .unused, |
| 49381 | 49637 | .unused, |
| 49382 | 49638 | .unused, |
| ... | ... | @@ -49384,22 +49640,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49384 | 49640 | .unused, |
| 49385 | 49641 | }, |
| 49386 | 49642 | .dst_temps = .{.mem}, |
| 49643 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49387 | 49644 | .each = .{ .once = &.{ |
| 49388 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 49389 | | .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ }, |
| 49645 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49646 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49647 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49648 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49649 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 49650 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49651 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49390 | 49652 | } }, |
| 49391 | 49653 | }, .{ |
| 49392 | | .required_features = .{ .x87, null, null, null }, |
| 49393 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49394 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 49654 | .required_features = .{ .sse2, null, null, null }, |
| 49655 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49656 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 49395 | 49657 | .patterns = &.{ |
| 49396 | 49658 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49397 | 49659 | }, |
| 49660 | .call_frame = .{ .alignment = .@"16" }, |
| 49398 | 49661 | .extra_temps = .{ |
| 49399 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49400 | | .unused, |
| 49401 | | .unused, |
| 49402 | | .unused, |
| 49662 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49663 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49664 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49665 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49403 | 49666 | .unused, |
| 49404 | 49667 | .unused, |
| 49405 | 49668 | .unused, |
| ... | ... | @@ -49407,44 +49670,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49407 | 49670 | .unused, |
| 49408 | 49671 | }, |
| 49409 | 49672 | .dst_temps = .{.mem}, |
| 49673 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49410 | 49674 | .each = .{ .once = &.{ |
| 49411 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 49412 | | .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ }, |
| 49675 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49676 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49677 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49678 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49679 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 49680 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49681 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49413 | 49682 | } }, |
| 49414 | 49683 | }, .{ |
| 49415 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49416 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49417 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 49684 | .required_features = .{ .sse, null, null, null }, |
| 49685 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49686 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 49418 | 49687 | .patterns = &.{ |
| 49419 | | .{ .src = .{ .mem, .none, .none } }, |
| 49420 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49421 | 49689 | }, |
| 49422 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49423 | | .each = .{ .once = &.{ |
| 49424 | | .{ ._, .v_, .cvttsd2si, .dst0q, .src0q, ._, ._ }, |
| 49425 | | } }, |
| 49426 | | }, .{ |
| 49427 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 49428 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49429 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 49430 | | .patterns = &.{ |
| 49431 | | .{ .src = .{ .mem, .none, .none } }, |
| 49432 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49690 | .call_frame = .{ .alignment = .@"16" }, |
| 49691 | .extra_temps = .{ |
| 49692 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49693 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49694 | .{ .type = .f32, .kind = .mem }, |
| 49695 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49696 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49697 | .unused, |
| 49698 | .unused, |
| 49699 | .unused, |
| 49700 | .unused, |
| 49433 | 49701 | }, |
| 49434 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49702 | .dst_temps = .{.mem}, |
| 49703 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49435 | 49704 | .each = .{ .once = &.{ |
| 49436 | | .{ ._, ._, .cvttsd2si, .dst0q, .src0q, ._, ._ }, |
| 49705 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49706 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49707 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49708 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49709 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49710 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 49711 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49712 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49437 | 49713 | } }, |
| 49438 | 49714 | }, .{ |
| 49439 | | .required_features = .{ .x87, null, null, null }, |
| 49440 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49441 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 49715 | .required_features = .{ .f16c, null, null, null }, |
| 49716 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49717 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 49442 | 49718 | .patterns = &.{ |
| 49443 | 49719 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49444 | 49720 | }, |
| 49445 | 49721 | .extra_temps = .{ |
| 49446 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49447 | | .unused, |
| 49722 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49723 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 49448 | 49724 | .unused, |
| 49449 | 49725 | .unused, |
| 49450 | 49726 | .unused, |
| ... | ... | @@ -49455,164 +49731,176 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49455 | 49731 | }, |
| 49456 | 49732 | .dst_temps = .{.mem}, |
| 49457 | 49733 | .each = .{ .once = &.{ |
| 49458 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 49459 | | .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ }, |
| 49734 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49735 | .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49736 | .{ ._, .v_, .cvttps2dq, .tmp1x, .tmp1x, ._, ._ }, |
| 49737 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 49738 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 49739 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49460 | 49740 | } }, |
| 49461 | 49741 | }, .{ |
| 49462 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49463 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49464 | | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 49742 | .required_features = .{ .f16c, null, null, null }, |
| 49743 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49744 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49465 | 49745 | .patterns = &.{ |
| 49466 | | .{ .src = .{ .to_sse, .none, .none } }, |
| 49746 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49467 | 49747 | }, |
| 49468 | 49748 | .extra_temps = .{ |
| 49469 | | .{ .type = .f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 49470 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49471 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49472 | | .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 49749 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49750 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 49751 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 49752 | .unused, |
| 49473 | 49753 | .unused, |
| 49474 | 49754 | .unused, |
| 49475 | 49755 | .unused, |
| 49476 | 49756 | .unused, |
| 49477 | 49757 | .unused, |
| 49478 | 49758 | }, |
| 49479 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49480 | | .clobbers = .{ .eflags = true }, |
| 49759 | .dst_temps = .{.mem}, |
| 49481 | 49760 | .each = .{ .once = &.{ |
| 49482 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 49483 | | .{ ._, .v_, .cvttsd2si, .tmp2q, .src0d, ._, ._ }, |
| 49484 | | .{ ._, .v_sd, .sub, .tmp0x, .src0x, .lea(.tmp1q), ._ }, |
| 49485 | | .{ ._, .v_, .cvttsd2si, .dst0q, .tmp0d, ._, ._ }, |
| 49486 | | .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ }, |
| 49487 | | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| 49488 | | .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ }, |
| 49489 | | .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ }, |
| 49761 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49762 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49763 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49764 | .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ }, |
| 49765 | .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ }, |
| 49766 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 49767 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49768 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49490 | 49769 | } }, |
| 49491 | 49770 | }, .{ |
| 49492 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 49493 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49494 | | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 49771 | .required_features = .{ .avx, null, null, null }, |
| 49772 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49773 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49495 | 49774 | .patterns = &.{ |
| 49496 | | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 49775 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49497 | 49776 | }, |
| 49777 | .call_frame = .{ .alignment = .@"16" }, |
| 49498 | 49778 | .extra_temps = .{ |
| 49499 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49500 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49501 | | .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 49502 | | .unused, |
| 49779 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49780 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49781 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49782 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49503 | 49783 | .unused, |
| 49504 | 49784 | .unused, |
| 49505 | 49785 | .unused, |
| 49506 | 49786 | .unused, |
| 49507 | 49787 | .unused, |
| 49508 | 49788 | }, |
| 49509 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49510 | | .clobbers = .{ .eflags = true }, |
| 49789 | .dst_temps = .{.mem}, |
| 49790 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49511 | 49791 | .each = .{ .once = &.{ |
| 49512 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 49513 | | .{ ._, ._, .cvttsd2si, .tmp1q, .src0d, ._, ._ }, |
| 49514 | | .{ ._, ._sd, .sub, .src0x, .lea(.tmp0q), ._, ._ }, |
| 49515 | | .{ ._, ._, .cvttsd2si, .dst0q, .src0d, ._, ._ }, |
| 49516 | | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| 49517 | | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 49518 | | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| 49519 | | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 49792 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49793 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49794 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49795 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49796 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 49797 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49798 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49520 | 49799 | } }, |
| 49521 | 49800 | }, .{ |
| 49522 | | .required_features = .{ .@"64bit", .x87, null, null }, |
| 49523 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49524 | | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 49801 | .required_features = .{ .avx, null, null, null }, |
| 49802 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49803 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49525 | 49804 | .patterns = &.{ |
| 49526 | 49805 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49527 | 49806 | }, |
| 49807 | .call_frame = .{ .alignment = .@"16" }, |
| 49528 | 49808 | .extra_temps = .{ |
| 49529 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49530 | | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 49531 | | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 49532 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49533 | | .{ .type = .i64, .kind = .mem }, |
| 49809 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49810 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49811 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } }, |
| 49812 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 49813 | .unused, |
| 49534 | 49814 | .unused, |
| 49535 | 49815 | .unused, |
| 49536 | 49816 | .unused, |
| 49537 | 49817 | .unused, |
| 49538 | 49818 | }, |
| 49539 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49540 | | .clobbers = .{ .eflags = true }, |
| 49819 | .dst_temps = .{.mem}, |
| 49820 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49541 | 49821 | .each = .{ .once = &.{ |
| 49542 | | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 49543 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 49544 | | .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ }, |
| 49545 | | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 49546 | | .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ }, |
| 49547 | | .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ }, |
| 49548 | | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 49549 | | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 49550 | | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 49551 | | .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, |
| 49552 | | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 49822 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49823 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49824 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49825 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49826 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 49827 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49828 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49553 | 49829 | } }, |
| 49554 | 49830 | }, .{ |
| 49555 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49556 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49557 | | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 49831 | .required_features = .{ .sse2, null, null, null }, |
| 49832 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49833 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49558 | 49834 | .patterns = &.{ |
| 49559 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49835 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49560 | 49836 | }, |
| 49561 | 49837 | .call_frame = .{ .alignment = .@"16" }, |
| 49562 | 49838 | .extra_temps = .{ |
| 49563 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } }, |
| 49564 | | .unused, |
| 49565 | | .unused, |
| 49566 | | .unused, |
| 49839 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49840 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49841 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49842 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49567 | 49843 | .unused, |
| 49568 | 49844 | .unused, |
| 49569 | 49845 | .unused, |
| 49570 | 49846 | .unused, |
| 49571 | 49847 | .unused, |
| 49572 | 49848 | }, |
| 49573 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 49849 | .dst_temps = .{.mem}, |
| 49574 | 49850 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49575 | 49851 | .each = .{ .once = &.{ |
| 49576 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 49852 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49853 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49854 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49855 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49856 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 49857 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49858 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49577 | 49859 | } }, |
| 49578 | 49860 | }, .{ |
| 49579 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49580 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49581 | | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 49861 | .required_features = .{ .sse2, null, null, null }, |
| 49862 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49863 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49582 | 49864 | .patterns = &.{ |
| 49583 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49865 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49584 | 49866 | }, |
| 49585 | 49867 | .call_frame = .{ .alignment = .@"16" }, |
| 49586 | 49868 | .extra_temps = .{ |
| 49587 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } }, |
| 49588 | | .unused, |
| 49589 | | .unused, |
| 49590 | | .unused, |
| 49869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49870 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49871 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } }, |
| 49872 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 49591 | 49873 | .unused, |
| 49592 | 49874 | .unused, |
| 49593 | 49875 | .unused, |
| 49594 | 49876 | .unused, |
| 49595 | 49877 | .unused, |
| 49596 | 49878 | }, |
| 49597 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 49879 | .dst_temps = .{.mem}, |
| 49598 | 49880 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49599 | 49881 | .each = .{ .once = &.{ |
| 49600 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 49882 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49883 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49884 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49885 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49886 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 49887 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49888 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49601 | 49889 | } }, |
| 49602 | 49890 | }, .{ |
| 49603 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49604 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49605 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49891 | .required_features = .{ .sse, null, null, null }, |
| 49892 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49893 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49606 | 49894 | .patterns = &.{ |
| 49607 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49895 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49608 | 49896 | }, |
| 49609 | 49897 | .call_frame = .{ .alignment = .@"16" }, |
| 49610 | 49898 | .extra_temps = .{ |
| 49611 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49612 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 49613 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } }, |
| 49614 | | .unused, |
| 49615 | | .unused, |
| 49899 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49900 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49901 | .{ .type = .f32, .kind = .mem }, |
| 49902 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49903 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49616 | 49904 | .unused, |
| 49617 | 49905 | .unused, |
| 49618 | 49906 | .unused, |
| ... | ... | @@ -49621,24 +49909,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49621 | 49909 | .dst_temps = .{.mem}, |
| 49622 | 49910 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49623 | 49911 | .each = .{ .once = &.{ |
| 49624 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 49625 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 49626 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49912 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49913 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49914 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49915 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49916 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49917 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 49918 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49919 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49627 | 49920 | } }, |
| 49628 | 49921 | }, .{ |
| 49629 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49630 | | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 49631 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49922 | .required_features = .{ .sse, null, null, null }, |
| 49923 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49924 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49632 | 49925 | .patterns = &.{ |
| 49633 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 49926 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49634 | 49927 | }, |
| 49635 | 49928 | .call_frame = .{ .alignment = .@"16" }, |
| 49636 | 49929 | .extra_temps = .{ |
| 49637 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49638 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 49639 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } }, |
| 49640 | | .unused, |
| 49641 | | .unused, |
| 49930 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49931 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 49932 | .{ .type = .f32, .kind = .mem }, |
| 49933 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49934 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } }, |
| 49642 | 49935 | .unused, |
| 49643 | 49936 | .unused, |
| 49644 | 49937 | .unused, |
| ... | ... | @@ -49647,22 +49940,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49647 | 49940 | .dst_temps = .{.mem}, |
| 49648 | 49941 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49649 | 49942 | .each = .{ .once = &.{ |
| 49650 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 49651 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 49652 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49943 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49944 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49945 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49946 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49947 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49948 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| 49949 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49950 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49653 | 49951 | } }, |
| 49654 | 49952 | }, .{ |
| 49655 | | .required_features = .{ .x87, null, null, null }, |
| 49656 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49657 | | .dst_constraints = .{.{ .signed_int = .byte }}, |
| 49953 | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 49954 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49955 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49658 | 49956 | .patterns = &.{ |
| 49659 | | .{ .src = .{ .mem, .none, .none } }, |
| 49660 | | .{ .src = .{ .to_x87, .none, .none } }, |
| 49957 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49661 | 49958 | }, |
| 49662 | 49959 | .extra_temps = .{ |
| 49663 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49664 | | .{ .type = .i16, .kind = .mem }, |
| 49665 | | .unused, |
| 49960 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49961 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 49962 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49666 | 49963 | .unused, |
| 49667 | 49964 | .unused, |
| 49668 | 49965 | .unused, |
| ... | ... | @@ -49670,50 +49967,60 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49670 | 49967 | .unused, |
| 49671 | 49968 | .unused, |
| 49672 | 49969 | }, |
| 49673 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49970 | .dst_temps = .{.mem}, |
| 49674 | 49971 | .each = .{ .once = &.{ |
| 49675 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 49676 | | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 49677 | | .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ }, |
| 49972 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49973 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49974 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49975 | .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ }, |
| 49976 | .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ }, |
| 49977 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| 49978 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49979 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49678 | 49980 | } }, |
| 49679 | 49981 | }, .{ |
| 49680 | | .required_features = .{ .x87, null, null, null }, |
| 49681 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49682 | | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 49982 | .required_features = .{ .avx, null, null, null }, |
| 49983 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49984 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49683 | 49985 | .patterns = &.{ |
| 49684 | | .{ .src = .{ .mem, .none, .none } }, |
| 49685 | | .{ .src = .{ .to_x87, .none, .none } }, |
| 49986 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49686 | 49987 | }, |
| 49988 | .call_frame = .{ .alignment = .@"16" }, |
| 49687 | 49989 | .extra_temps = .{ |
| 49688 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49689 | | .{ .type = .i16, .kind = .mem }, |
| 49690 | | .unused, |
| 49691 | | .unused, |
| 49990 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49991 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49992 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } }, |
| 49993 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49692 | 49994 | .unused, |
| 49693 | 49995 | .unused, |
| 49694 | 49996 | .unused, |
| 49695 | 49997 | .unused, |
| 49696 | 49998 | .unused, |
| 49697 | 49999 | }, |
| 49698 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50000 | .dst_temps = .{.mem}, |
| 50001 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49699 | 50002 | .each = .{ .once = &.{ |
| 49700 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 49701 | | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 49702 | | .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ }, |
| 50003 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50004 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 50005 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 50006 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50007 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50008 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50009 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49703 | 50010 | } }, |
| 49704 | 50011 | }, .{ |
| 49705 | | .required_features = .{ .x87, null, null, null }, |
| 49706 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49707 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .word }}, |
| 50012 | .required_features = .{ .avx, null, null, null }, |
| 50013 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50014 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49708 | 50015 | .patterns = &.{ |
| 49709 | | .{ .src = .{ .mem, .none, .none } }, |
| 49710 | | .{ .src = .{ .to_x87, .none, .none } }, |
| 50016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49711 | 50017 | }, |
| 50018 | .call_frame = .{ .alignment = .@"16" }, |
| 49712 | 50019 | .extra_temps = .{ |
| 49713 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 49714 | | .unused, |
| 49715 | | .unused, |
| 49716 | | .unused, |
| 50020 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50021 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50022 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } }, |
| 50023 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49717 | 50024 | .unused, |
| 49718 | 50025 | .unused, |
| 49719 | 50026 | .unused, |
| ... | ... | @@ -49721,23 +50028,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49721 | 50028 | .unused, |
| 49722 | 50029 | }, |
| 49723 | 50030 | .dst_temps = .{.mem}, |
| 50031 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49724 | 50032 | .each = .{ .once = &.{ |
| 49725 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 49726 | | .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ }, |
| 50033 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50034 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 50035 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 50036 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50037 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50038 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50039 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49727 | 50040 | } }, |
| 49728 | 50041 | }, .{ |
| 49729 | | .required_features = .{ .x87, null, null, null }, |
| 49730 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49731 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 50042 | .required_features = .{ .sse2, null, null, null }, |
| 50043 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50044 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49732 | 50045 | .patterns = &.{ |
| 49733 | | .{ .src = .{ .mem, .none, .none } }, |
| 49734 | | .{ .src = .{ .to_x87, .none, .none } }, |
| 50046 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49735 | 50047 | }, |
| 50048 | .call_frame = .{ .alignment = .@"16" }, |
| 49736 | 50049 | .extra_temps = .{ |
| 49737 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 49738 | | .unused, |
| 49739 | | .unused, |
| 49740 | | .unused, |
| 50050 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50051 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50052 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } }, |
| 50053 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49741 | 50054 | .unused, |
| 49742 | 50055 | .unused, |
| 49743 | 50056 | .unused, |
| ... | ... | @@ -49745,23 +50058,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49745 | 50058 | .unused, |
| 49746 | 50059 | }, |
| 49747 | 50060 | .dst_temps = .{.mem}, |
| 50061 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49748 | 50062 | .each = .{ .once = &.{ |
| 49749 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 49750 | | .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ }, |
| 50063 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50064 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 50065 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 50066 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50067 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50068 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50069 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49751 | 50070 | } }, |
| 49752 | 50071 | }, .{ |
| 49753 | | .required_features = .{ .x87, null, null, null }, |
| 49754 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49755 | | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 50072 | .required_features = .{ .sse2, null, null, null }, |
| 50073 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50074 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49756 | 50075 | .patterns = &.{ |
| 49757 | | .{ .src = .{ .mem, .none, .none } }, |
| 49758 | | .{ .src = .{ .to_x87, .none, .none } }, |
| 50076 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49759 | 50077 | }, |
| 50078 | .call_frame = .{ .alignment = .@"16" }, |
| 49760 | 50079 | .extra_temps = .{ |
| 49761 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 49762 | | .unused, |
| 49763 | | .unused, |
| 49764 | | .unused, |
| 50080 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50081 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50082 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } }, |
| 50083 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49765 | 50084 | .unused, |
| 49766 | 50085 | .unused, |
| 49767 | 50086 | .unused, |
| ... | ... | @@ -49769,215 +50088,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49769 | 50088 | .unused, |
| 49770 | 50089 | }, |
| 49771 | 50090 | .dst_temps = .{.mem}, |
| 50091 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49772 | 50092 | .each = .{ .once = &.{ |
| 49773 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 49774 | | .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ }, |
| 50093 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50094 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 50095 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 50096 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50097 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50098 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50099 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49775 | 50100 | } }, |
| 49776 | 50101 | }, .{ |
| 49777 | | .required_features = .{ .@"64bit", .x87, null, null }, |
| 49778 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49779 | | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 50102 | .required_features = .{ .sse, null, null, null }, |
| 50103 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50104 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49780 | 50105 | .patterns = &.{ |
| 49781 | | .{ .src = .{ .mem, .none, .none } }, |
| 49782 | | .{ .src = .{ .to_x87, .none, .none } }, |
| 50106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49783 | 50107 | }, |
| 50108 | .call_frame = .{ .alignment = .@"16" }, |
| 49784 | 50109 | .extra_temps = .{ |
| 49785 | | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49786 | | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 49787 | | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 49788 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 49789 | | .{ .type = .i64, .kind = .mem }, |
| 50110 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50111 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 50112 | .{ .type = .f32, .kind = .mem }, |
| 50113 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50114 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } }, |
| 49790 | 50115 | .unused, |
| 49791 | 50116 | .unused, |
| 49792 | 50117 | .unused, |
| 49793 | 50118 | .unused, |
| 49794 | 50119 | }, |
| 49795 | | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 49796 | | .clobbers = .{ .eflags = true }, |
| 50120 | .dst_temps = .{.mem}, |
| 50121 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49797 | 50122 | .each = .{ .once = &.{ |
| 49798 | | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 49799 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 49800 | | .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ }, |
| 49801 | | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 49802 | | .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ }, |
| 49803 | | .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ }, |
| 49804 | | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 49805 | | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 49806 | | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 49807 | | .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, |
| 49808 | | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 50123 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50124 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50125 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 50126 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 50127 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50128 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 50129 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50130 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49809 | 50131 | } }, |
| 49810 | 50132 | }, .{ |
| 49811 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49812 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49813 | | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 50133 | .required_features = .{ .sse, null, null, null }, |
| 50134 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50135 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49814 | 50136 | .patterns = &.{ |
| 49815 | 50137 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49816 | 50138 | }, |
| 49817 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50139 | .call_frame = .{ .alignment = .@"16" }, |
| 49818 | 50140 | .extra_temps = .{ |
| 49819 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49820 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49821 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 49822 | | .unused, |
| 49823 | | .unused, |
| 50141 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50142 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50143 | .{ .type = .f32, .kind = .mem }, |
| 50144 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50145 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } }, |
| 49824 | 50146 | .unused, |
| 49825 | 50147 | .unused, |
| 49826 | 50148 | .unused, |
| 49827 | 50149 | .unused, |
| 49828 | 50150 | }, |
| 49829 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 50151 | .dst_temps = .{.mem}, |
| 49830 | 50152 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49831 | 50153 | .each = .{ .once = &.{ |
| 49832 | | .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 49833 | | .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 49834 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50154 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50155 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50156 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 50157 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 50158 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50159 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 50160 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50161 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49835 | 50162 | } }, |
| 49836 | 50163 | }, .{ |
| 49837 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 49838 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49839 | | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 50164 | .required_features = .{ .avx, null, null, null }, |
| 50165 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50166 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 49840 | 50167 | .patterns = &.{ |
| 49841 | 50168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49842 | 50169 | }, |
| 49843 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50170 | .call_frame = .{ .alignment = .@"16" }, |
| 49844 | 50171 | .extra_temps = .{ |
| 49845 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49846 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49847 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 49848 | | .unused, |
| 49849 | | .unused, |
| 50172 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50173 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50174 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } }, |
| 50175 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50176 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49850 | 50177 | .unused, |
| 49851 | 50178 | .unused, |
| 49852 | 50179 | .unused, |
| 49853 | 50180 | .unused, |
| 49854 | 50181 | }, |
| 49855 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 50182 | .dst_temps = .{.mem}, |
| 49856 | 50183 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49857 | 50184 | .each = .{ .once = &.{ |
| 49858 | | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 49859 | | .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 50185 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50186 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 50187 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49860 | 50188 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50189 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50190 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 50191 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50192 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49861 | 50193 | } }, |
| 49862 | 50194 | }, .{ |
| 49863 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49864 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49865 | | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 50195 | .required_features = .{ .avx, null, null, null }, |
| 50196 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50197 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 49866 | 50198 | .patterns = &.{ |
| 49867 | 50199 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49868 | 50200 | }, |
| 49869 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50201 | .call_frame = .{ .alignment = .@"16" }, |
| 49870 | 50202 | .extra_temps = .{ |
| 49871 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49872 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49873 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 49874 | | .unused, |
| 49875 | | .unused, |
| 50203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50204 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50205 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } }, |
| 50206 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50207 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 49876 | 50208 | .unused, |
| 49877 | 50209 | .unused, |
| 49878 | 50210 | .unused, |
| 49879 | 50211 | .unused, |
| 49880 | 50212 | }, |
| 49881 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 50213 | .dst_temps = .{.mem}, |
| 49882 | 50214 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49883 | 50215 | .each = .{ .once = &.{ |
| 49884 | | .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, |
| 49885 | | .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ }, |
| 50216 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50217 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 50218 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49886 | 50219 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50220 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50221 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 50222 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50223 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49887 | 50224 | } }, |
| 49888 | 50225 | }, .{ |
| 49889 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49890 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49891 | | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 50226 | .required_features = .{ .sse2, null, null, null }, |
| 50227 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50228 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 49892 | 50229 | .patterns = &.{ |
| 49893 | 50230 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49894 | 50231 | }, |
| 49895 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50232 | .call_frame = .{ .alignment = .@"16" }, |
| 49896 | 50233 | .extra_temps = .{ |
| 49897 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49898 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49899 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 49900 | | .unused, |
| 49901 | | .unused, |
| 50234 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50235 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50236 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } }, |
| 50237 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50238 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49902 | 50239 | .unused, |
| 49903 | 50240 | .unused, |
| 49904 | 50241 | .unused, |
| 49905 | 50242 | .unused, |
| 49906 | 50243 | }, |
| 49907 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 50244 | .dst_temps = .{.mem}, |
| 49908 | 50245 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49909 | 50246 | .each = .{ .once = &.{ |
| 49910 | | .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 49911 | | .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 50247 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50248 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 50249 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49912 | 50250 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50251 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50252 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 50253 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50254 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49913 | 50255 | } }, |
| 49914 | 50256 | }, .{ |
| 49915 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 49916 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49917 | | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 50257 | .required_features = .{ .sse2, null, null, null }, |
| 50258 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50259 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 49918 | 50260 | .patterns = &.{ |
| 49919 | 50261 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49920 | 50262 | }, |
| 49921 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50263 | .call_frame = .{ .alignment = .@"16" }, |
| 49922 | 50264 | .extra_temps = .{ |
| 49923 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49924 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49925 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 49926 | | .unused, |
| 49927 | | .unused, |
| 50265 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50266 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50267 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } }, |
| 50268 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50269 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 49928 | 50270 | .unused, |
| 49929 | 50271 | .unused, |
| 49930 | 50272 | .unused, |
| 49931 | 50273 | .unused, |
| 49932 | 50274 | }, |
| 49933 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 50275 | .dst_temps = .{.mem}, |
| 49934 | 50276 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49935 | 50277 | .each = .{ .once = &.{ |
| 49936 | | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 49937 | | .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 50278 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50279 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 50280 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49938 | 50281 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50282 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 50283 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 50284 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50285 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49939 | 50286 | } }, |
| 49940 | 50287 | }, .{ |
| 49941 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 49942 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49943 | | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 50288 | .required_features = .{ .sse, null, null, null }, |
| 50289 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50290 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 49944 | 50291 | .patterns = &.{ |
| 49945 | 50292 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49946 | 50293 | }, |
| 49947 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50294 | .call_frame = .{ .alignment = .@"16" }, |
| 49948 | 50295 | .extra_temps = .{ |
| 49949 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49950 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49951 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 49952 | | .unused, |
| 49953 | | .unused, |
| 49954 | | .unused, |
| 50296 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50297 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50298 | .{ .type = .f32, .kind = .mem }, |
| 50299 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50300 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } }, |
| 50301 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49955 | 50302 | .unused, |
| 49956 | 50303 | .unused, |
| 49957 | 50304 | .unused, |
| 49958 | 50305 | }, |
| 49959 | | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 50306 | .dst_temps = .{.mem}, |
| 49960 | 50307 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49961 | 50308 | .each = .{ .once = &.{ |
| 49962 | | .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, |
| 49963 | | .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ }, |
| 49964 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50309 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50310 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50311 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 50312 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 50313 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50314 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 50315 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 50316 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50317 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49965 | 50318 | } }, |
| 49966 | 50319 | }, .{ |
| 49967 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49968 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49969 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50320 | .required_features = .{ .sse, null, null, null }, |
| 50321 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50322 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 49970 | 50323 | .patterns = &.{ |
| 49971 | 50324 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49972 | 50325 | }, |
| 49973 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50326 | .call_frame = .{ .alignment = .@"16" }, |
| 49974 | 50327 | .extra_temps = .{ |
| 49975 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 49976 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 49977 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 49978 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 49979 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 49980 | | .unused, |
| 50328 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50329 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 50330 | .{ .type = .f32, .kind = .mem }, |
| 50331 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50332 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } }, |
| 50333 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 49981 | 50334 | .unused, |
| 49982 | 50335 | .unused, |
| 49983 | 50336 | .unused, |
| ... | ... | @@ -49985,27 +50338,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49985 | 50338 | .dst_temps = .{.mem}, |
| 49986 | 50339 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49987 | 50340 | .each = .{ .once = &.{ |
| 49988 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 49989 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 49990 | | .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 49991 | | .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 50341 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50342 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50343 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 50344 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49992 | 50345 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50346 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 50347 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 50348 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50349 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49993 | 50350 | } }, |
| 49994 | 50351 | }, .{ |
| 49995 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 49996 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 49997 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50352 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50353 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50354 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49998 | 50355 | .patterns = &.{ |
| 49999 | 50356 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50000 | 50357 | }, |
| 50001 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50358 | .call_frame = .{ .alignment = .@"16" }, |
| 50002 | 50359 | .extra_temps = .{ |
| 50360 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50361 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50003 | 50362 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50004 | 50363 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50005 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 50006 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 50007 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 50008 | | .unused, |
| 50364 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50365 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfei" } } }, |
| 50009 | 50366 | .unused, |
| 50010 | 50367 | .unused, |
| 50011 | 50368 | .unused, |
| ... | ... | @@ -50013,27 +50370,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50013 | 50370 | .dst_temps = .{.mem}, |
| 50014 | 50371 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50015 | 50372 | .each = .{ .once = &.{ |
| 50016 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50017 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50018 | | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 50019 | | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 50020 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50373 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50374 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50375 | .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, |
| 50376 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50377 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 50378 | .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 50379 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 50380 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 50381 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50021 | 50383 | } }, |
| 50022 | 50384 | }, .{ |
| 50023 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50024 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 50025 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50385 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50386 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50387 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50026 | 50388 | .patterns = &.{ |
| 50027 | 50389 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50028 | 50390 | }, |
| 50029 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50391 | .call_frame = .{ .alignment = .@"16" }, |
| 50030 | 50392 | .extra_temps = .{ |
| 50393 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50394 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50031 | 50395 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50032 | 50396 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50033 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 50034 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 50035 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 50036 | | .unused, |
| 50397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50398 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfei" } } }, |
| 50037 | 50399 | .unused, |
| 50038 | 50400 | .unused, |
| 50039 | 50401 | .unused, |
| ... | ... | @@ -50041,27 +50403,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50041 | 50403 | .dst_temps = .{.mem}, |
| 50042 | 50404 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50043 | 50405 | .each = .{ .once = &.{ |
| 50044 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50045 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50046 | | .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ }, |
| 50047 | | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 50048 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50406 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50407 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50408 | .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, |
| 50409 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50410 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 50411 | .{ ._, .vp_w, .insr, .tmp4x, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 50412 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 50413 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 50414 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50415 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50049 | 50416 | } }, |
| 50050 | 50417 | }, .{ |
| 50051 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50052 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 50053 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50418 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 50419 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50420 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50054 | 50421 | .patterns = &.{ |
| 50055 | 50422 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50056 | 50423 | }, |
| 50057 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50424 | .call_frame = .{ .alignment = .@"16" }, |
| 50058 | 50425 | .extra_temps = .{ |
| 50426 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50427 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50059 | 50428 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50060 | 50429 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50061 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 50062 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 50063 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 50064 | | .unused, |
| 50430 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50431 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfei" } } }, |
| 50065 | 50432 | .unused, |
| 50066 | 50433 | .unused, |
| 50067 | 50434 | .unused, |
| ... | ... | @@ -50069,27 +50436,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50069 | 50436 | .dst_temps = .{.mem}, |
| 50070 | 50437 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50071 | 50438 | .each = .{ .once = &.{ |
| 50072 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50073 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50074 | | .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 50075 | | .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 50076 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50439 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50440 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50441 | .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 50442 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50443 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 50444 | .{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 50445 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 50446 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 50447 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50448 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50077 | 50449 | } }, |
| 50078 | 50450 | }, .{ |
| 50079 | 50451 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 50080 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 50081 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50452 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50453 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50082 | 50454 | .patterns = &.{ |
| 50083 | 50455 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50084 | 50456 | }, |
| 50085 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50457 | .call_frame = .{ .alignment = .@"16" }, |
| 50086 | 50458 | .extra_temps = .{ |
| 50459 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50460 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50087 | 50461 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50088 | 50462 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50089 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 50090 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 50091 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 50092 | | .unused, |
| 50463 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50464 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfei" } } }, |
| 50093 | 50465 | .unused, |
| 50094 | 50466 | .unused, |
| 50095 | 50467 | .unused, |
| ... | ... | @@ -50097,124 +50469,174 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50097 | 50469 | .dst_temps = .{.mem}, |
| 50098 | 50470 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50099 | 50471 | .each = .{ .once = &.{ |
| 50100 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50101 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50102 | | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 50103 | | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 50104 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50472 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50473 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50474 | .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 50475 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50476 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 50477 | .{ ._, .p_w, .insr, .tmp4x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 50478 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 50479 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 50480 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50481 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50105 | 50482 | } }, |
| 50106 | 50483 | }, .{ |
| 50107 | 50484 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50108 | | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 50109 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50485 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50486 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50110 | 50487 | .patterns = &.{ |
| 50111 | 50488 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50112 | 50489 | }, |
| 50113 | | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 50490 | .call_frame = .{ .alignment = .@"16" }, |
| 50114 | 50491 | .extra_temps = .{ |
| 50492 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50493 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50115 | 50494 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50116 | 50495 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50117 | | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 50118 | | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 50119 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 50120 | | .unused, |
| 50121 | | .unused, |
| 50496 | .{ .type = .f32, .kind = .mem }, |
| 50497 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50498 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfei" } } }, |
| 50122 | 50499 | .unused, |
| 50123 | 50500 | .unused, |
| 50124 | 50501 | }, |
| 50125 | 50502 | .dst_temps = .{.mem}, |
| 50126 | 50503 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50127 | 50504 | .each = .{ .once = &.{ |
| 50128 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50129 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50130 | | .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ }, |
| 50131 | | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 50132 | | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 50505 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50506 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50507 | .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50508 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50509 | .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 50510 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 50511 | .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ }, |
| 50512 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 50513 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 50514 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50515 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50133 | 50516 | } }, |
| 50134 | 50517 | }, .{ |
| 50135 | | .required_features = .{ .sse, null, null, null }, |
| 50136 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50137 | | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 50518 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50519 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50520 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50138 | 50521 | .patterns = &.{ |
| 50139 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50522 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50140 | 50523 | }, |
| 50141 | 50524 | .call_frame = .{ .alignment = .@"16" }, |
| 50142 | 50525 | .extra_temps = .{ |
| 50143 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 50144 | | .unused, |
| 50145 | | .unused, |
| 50146 | | .unused, |
| 50147 | | .unused, |
| 50148 | | .unused, |
| 50149 | | .unused, |
| 50526 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50527 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50528 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50529 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50530 | .{ .type = .f32, .kind = .mem }, |
| 50531 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50532 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfei" } } }, |
| 50150 | 50533 | .unused, |
| 50151 | 50534 | .unused, |
| 50152 | 50535 | }, |
| 50153 | | .dst_temps = .{.{ .reg = .eax }}, |
| 50536 | .dst_temps = .{.mem}, |
| 50154 | 50537 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50155 | 50538 | .each = .{ .once = &.{ |
| 50156 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50539 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50540 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50541 | .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50542 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50543 | .{ ._, ._, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 50544 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 50545 | .{ ._, ._ss, .mov, .tmp5x, .tmp4d, ._, ._ }, |
| 50546 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 50547 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 50548 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 50549 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50550 | } }, |
| 50551 | }, .{ |
| 50552 | .required_features = .{ .avx, null, null, null }, |
| 50553 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50554 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 50555 | .patterns = &.{ |
| 50556 | .{ .src = .{ .mem, .none, .none } }, |
| 50557 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50558 | }, |
| 50559 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50560 | .each = .{ .once = &.{ |
| 50561 | .{ ._, .v_, .cvttss2si, .dst0d, .src0d, ._, ._ }, |
| 50157 | 50562 | } }, |
| 50158 | 50563 | }, .{ |
| 50159 | 50564 | .required_features = .{ .sse, null, null, null }, |
| 50160 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50161 | | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 50565 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50566 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 50162 | 50567 | .patterns = &.{ |
| 50163 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50568 | .{ .src = .{ .mem, .none, .none } }, |
| 50569 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50164 | 50570 | }, |
| 50165 | | .call_frame = .{ .alignment = .@"16" }, |
| 50166 | | .extra_temps = .{ |
| 50167 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } }, |
| 50168 | | .unused, |
| 50169 | | .unused, |
| 50170 | | .unused, |
| 50171 | | .unused, |
| 50172 | | .unused, |
| 50173 | | .unused, |
| 50174 | | .unused, |
| 50175 | | .unused, |
| 50571 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50572 | .each = .{ .once = &.{ |
| 50573 | .{ ._, ._, .cvttss2si, .dst0d, .src0d, ._, ._ }, |
| 50574 | } }, |
| 50575 | }, .{ |
| 50576 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50577 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50578 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 50579 | .patterns = &.{ |
| 50580 | .{ .src = .{ .mem, .none, .none } }, |
| 50581 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50176 | 50582 | }, |
| 50177 | | .dst_temps = .{.{ .reg = .eax }}, |
| 50178 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50583 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50179 | 50584 | .each = .{ .once = &.{ |
| 50180 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50585 | .{ ._, .v_, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 50181 | 50586 | } }, |
| 50182 | 50587 | }, .{ |
| 50183 | 50588 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50184 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50185 | | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 50589 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50590 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 50186 | 50591 | .patterns = &.{ |
| 50187 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50592 | .{ .src = .{ .mem, .none, .none } }, |
| 50593 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50594 | }, |
| 50595 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50596 | .each = .{ .once = &.{ |
| 50597 | .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 50598 | } }, |
| 50599 | }, .{ |
| 50600 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50601 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50602 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 50603 | .patterns = &.{ |
| 50604 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50188 | 50605 | }, |
| 50189 | | .call_frame = .{ .alignment = .@"16" }, |
| 50190 | 50606 | .extra_temps = .{ |
| 50191 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } }, |
| 50192 | | .unused, |
| 50193 | | .unused, |
| 50194 | | .unused, |
| 50607 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 50608 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50609 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50610 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 50195 | 50611 | .unused, |
| 50196 | 50612 | .unused, |
| 50197 | 50613 | .unused, |
| 50198 | 50614 | .unused, |
| 50199 | 50615 | .unused, |
| 50200 | 50616 | }, |
| 50201 | | .dst_temps = .{.{ .reg = .rax }}, |
| 50202 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50617 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50618 | .clobbers = .{ .eflags = true }, |
| 50203 | 50619 | .each = .{ .once = &.{ |
| 50204 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50620 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 50621 | .{ ._, .v_, .cvttss2si, .tmp2q, .src0d, ._, ._ }, |
| 50622 | .{ ._, .v_ss, .sub, .tmp0x, .src0x, .lea(.tmp1d), ._ }, |
| 50623 | .{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ }, |
| 50624 | .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ }, |
| 50625 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| 50626 | .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ }, |
| 50627 | .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ }, |
| 50205 | 50628 | } }, |
| 50206 | 50629 | }, .{ |
| 50207 | 50630 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50208 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50209 | | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 50631 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50632 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 50210 | 50633 | .patterns = &.{ |
| 50211 | | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50634 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 50212 | 50635 | }, |
| 50213 | | .call_frame = .{ .alignment = .@"16" }, |
| 50214 | 50636 | .extra_temps = .{ |
| 50215 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } }, |
| 50216 | | .unused, |
| 50217 | | .unused, |
| 50637 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50638 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50639 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 50218 | 50640 | .unused, |
| 50219 | 50641 | .unused, |
| 50220 | 50642 | .unused, |
| ... | ... | @@ -50222,21 +50644,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50222 | 50644 | .unused, |
| 50223 | 50645 | .unused, |
| 50224 | 50646 | }, |
| 50225 | | .dst_temps = .{.{ .reg = .rax }}, |
| 50226 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50647 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50648 | .clobbers = .{ .eflags = true }, |
| 50227 | 50649 | .each = .{ .once = &.{ |
| 50228 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50650 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 50651 | .{ ._, ._, .cvttss2si, .tmp1q, .src0d, ._, ._ }, |
| 50652 | .{ ._, ._ss, .sub, .src0x, .lea(.tmp0d), ._, ._ }, |
| 50653 | .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 50654 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| 50655 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 50656 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| 50657 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 50229 | 50658 | } }, |
| 50230 | 50659 | }, .{ |
| 50231 | 50660 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50232 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50661 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50233 | 50662 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 50234 | 50663 | .patterns = &.{ |
| 50235 | 50664 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50236 | 50665 | }, |
| 50237 | 50666 | .call_frame = .{ .alignment = .@"16" }, |
| 50238 | 50667 | .extra_temps = .{ |
| 50239 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } }, |
| 50668 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } }, |
| 50240 | 50669 | .unused, |
| 50241 | 50670 | .unused, |
| 50242 | 50671 | .unused, |
| ... | ... | @@ -50253,14 +50682,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50253 | 50682 | } }, |
| 50254 | 50683 | }, .{ |
| 50255 | 50684 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50256 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50685 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50257 | 50686 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 50258 | 50687 | .patterns = &.{ |
| 50259 | 50688 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50260 | 50689 | }, |
| 50261 | 50690 | .call_frame = .{ .alignment = .@"16" }, |
| 50262 | 50691 | .extra_temps = .{ |
| 50263 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } }, |
| 50692 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50264 | 50693 | .unused, |
| 50265 | 50694 | .unused, |
| 50266 | 50695 | .unused, |
| ... | ... | @@ -50276,110 +50705,163 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50276 | 50705 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50277 | 50706 | } }, |
| 50278 | 50707 | }, .{ |
| 50279 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50280 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50281 | | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50708 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50709 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50710 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 50282 | 50711 | .patterns = &.{ |
| 50283 | 50712 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50284 | 50713 | }, |
| 50285 | 50714 | .call_frame = .{ .alignment = .@"16" }, |
| 50286 | 50715 | .extra_temps = .{ |
| 50716 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50717 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 50718 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 50719 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50720 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 50287 | 50721 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50288 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50289 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } }, |
| 50290 | | .unused, |
| 50291 | | .unused, |
| 50292 | | .unused, |
| 50293 | | .unused, |
| 50722 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 50294 | 50723 | .unused, |
| 50295 | 50724 | .unused, |
| 50296 | 50725 | }, |
| 50297 | 50726 | .dst_temps = .{.mem}, |
| 50298 | 50727 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50299 | 50728 | .each = .{ .once = &.{ |
| 50300 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50301 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50302 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50729 | .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ }, |
| 50730 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 50731 | .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, |
| 50732 | .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ }, |
| 50733 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 50734 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 50735 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| 50736 | .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, |
| 50737 | .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, |
| 50738 | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 50739 | .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, |
| 50740 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, |
| 50741 | .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, |
| 50742 | .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, |
| 50743 | .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 50744 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 50303 | 50745 | } }, |
| 50304 | 50746 | }, .{ |
| 50305 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50306 | | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 50307 | | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50747 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 50748 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50749 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 50308 | 50750 | .patterns = &.{ |
| 50309 | 50751 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50310 | 50752 | }, |
| 50311 | 50753 | .call_frame = .{ .alignment = .@"16" }, |
| 50312 | 50754 | .extra_temps = .{ |
| 50755 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50756 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 50757 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 50758 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50759 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 50313 | 50760 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50314 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50315 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } }, |
| 50316 | | .unused, |
| 50317 | | .unused, |
| 50318 | | .unused, |
| 50319 | | .unused, |
| 50761 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 50320 | 50762 | .unused, |
| 50321 | 50763 | .unused, |
| 50322 | 50764 | }, |
| 50323 | 50765 | .dst_temps = .{.mem}, |
| 50324 | 50766 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50325 | 50767 | .each = .{ .once = &.{ |
| 50326 | | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 50327 | | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 50328 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50768 | .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ }, |
| 50769 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 50770 | .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, |
| 50771 | .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ }, |
| 50772 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 50773 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 50774 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| 50775 | .{ ._, ._, .xor, .tmp4q, .tmp0q, ._, ._ }, |
| 50776 | .{ ._, ._, .sub, .tmp1q, .tmp0q, ._, ._ }, |
| 50777 | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 50778 | .{ ._, ._, .sbb, .tmp4q, .tmp0q, ._, ._ }, |
| 50779 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp4q, ._, ._ }, |
| 50780 | .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, |
| 50781 | .{ ._, ._, .lea, .tmp5p, .memd(.dst0, 16), ._, ._ }, |
| 50782 | .{ ._, ._, .mov, .tmp6d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 50783 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 50329 | 50784 | } }, |
| 50330 | | } }) catch |err| switch (err) { |
| 50331 | | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 50332 | | @tagName(air_tag), |
| 50333 | | ty_op.ty.toType().fmt(pt), |
| 50334 | | cg.typeOf(ty_op.operand).fmt(pt), |
| 50335 | | ops[0].tracking(cg), |
| 50336 | | }), |
| 50337 | | else => |e| return e, |
| 50338 | | }; |
| 50339 | | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 50340 | | }, |
| 50341 | | .float_from_int => |air_tag| if (use_old) try cg.airFloatFromInt(inst) else fallback: { |
| 50342 | | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 50343 | | if (ty_op.ty.toType().isVector(zcu)) break :fallback try cg.airFloatFromInt(inst); |
| 50344 | | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 50345 | | var res: [1]Temp = undefined; |
| 50346 | | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 50347 | | .required_features = .{ .f16c, null, null, null }, |
| 50348 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 50349 | | .dst_constraints = .{.{ .float = .word }}, |
| 50785 | }, .{ |
| 50786 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50787 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50788 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 50350 | 50789 | .patterns = &.{ |
| 50351 | | .{ .src = .{ .mem, .none, .none } }, |
| 50352 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 50790 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50353 | 50791 | }, |
| 50792 | .call_frame = .{ .alignment = .@"16" }, |
| 50354 | 50793 | .extra_temps = .{ |
| 50355 | | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50356 | | .unused, |
| 50357 | | .unused, |
| 50358 | | .unused, |
| 50359 | | .unused, |
| 50794 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 50795 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 50796 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 50797 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50798 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 50799 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 50800 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50801 | .unused, |
| 50802 | .unused, |
| 50803 | }, |
| 50804 | .dst_temps = .{.mem}, |
| 50805 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50806 | .each = .{ .once = &.{ |
| 50807 | .{ ._, ._ss, .mov, .tmp0x, .src0d, ._, ._ }, |
| 50808 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 50809 | .{ ._, ._ps, .@"and", .tmp0x, .lea(.tmp1x), ._, ._ }, |
| 50810 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 50811 | .{ ._, ._d, .movsx, .tmp4q, .src0d, ._, ._ }, |
| 50812 | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, |
| 50813 | .{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ }, |
| 50814 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| 50815 | .{ ._, ._, .sub, .tmp1q, .tmp4q, ._, ._ }, |
| 50816 | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 50817 | .{ ._, ._, .sbb, .tmp5q, .tmp4q, ._, ._ }, |
| 50818 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp5q, ._, ._ }, |
| 50819 | .{ ._, ._, .sbb, .tmp1q, .tmp1q, ._, ._ }, |
| 50820 | .{ ._, ._, .lea, .tmp6p, .memd(.dst0, 16), ._, ._ }, |
| 50821 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 50822 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 50823 | } }, |
| 50824 | }, .{ |
| 50825 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50826 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50827 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 50828 | .patterns = &.{ |
| 50829 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50830 | }, |
| 50831 | .call_frame = .{ .alignment = .@"16" }, |
| 50832 | .extra_temps = .{ |
| 50833 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50834 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 50835 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 50836 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50837 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 50360 | 50838 | .unused, |
| 50361 | 50839 | .unused, |
| 50362 | 50840 | .unused, |
| 50363 | 50841 | .unused, |
| 50364 | 50842 | }, |
| 50365 | | .dst_temps = .{.{ .rc = .sse }}, |
| 50843 | .dst_temps = .{.mem}, |
| 50844 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50366 | 50845 | .each = .{ .once = &.{ |
| 50367 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 50368 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50369 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 50370 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 50846 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50847 | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 50848 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ }, |
| 50849 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| 50850 | .{ ._, ._, .lea, .tmp3p, .memd(.dst0, 16), ._, ._ }, |
| 50851 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, |
| 50852 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 50371 | 50853 | } }, |
| 50372 | 50854 | }, .{ |
| 50373 | | .required_features = .{ .f16c, null, null, null }, |
| 50374 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 50375 | | .dst_constraints = .{.{ .float = .word }}, |
| 50855 | .required_features = .{ .avx, null, null, null }, |
| 50856 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50857 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50376 | 50858 | .patterns = &.{ |
| 50377 | 50859 | .{ .src = .{ .mem, .none, .none } }, |
| 50378 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 50860 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50379 | 50861 | }, |
| 50380 | 50862 | .extra_temps = .{ |
| 50381 | | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50382 | | .unused, |
| 50863 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50864 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 50383 | 50865 | .unused, |
| 50384 | 50866 | .unused, |
| 50385 | 50867 | .unused, |
| ... | ... | @@ -50388,24 +50870,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50388 | 50870 | .unused, |
| 50389 | 50871 | .unused, |
| 50390 | 50872 | }, |
| 50391 | | .dst_temps = .{.{ .rc = .sse }}, |
| 50873 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 50392 | 50874 | .each = .{ .once = &.{ |
| 50393 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 50394 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50395 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 50396 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 50875 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50876 | .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 50877 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 50397 | 50878 | } }, |
| 50398 | 50879 | }, .{ |
| 50399 | | .required_features = .{ .f16c, null, null, null }, |
| 50400 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 50401 | | .dst_constraints = .{.{ .float = .word }}, |
| 50880 | .required_features = .{ .ssse3, null, null, null }, |
| 50881 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50882 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50402 | 50883 | .patterns = &.{ |
| 50403 | 50884 | .{ .src = .{ .mem, .none, .none } }, |
| 50404 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 50885 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50405 | 50886 | }, |
| 50406 | 50887 | .extra_temps = .{ |
| 50407 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50408 | | .unused, |
| 50888 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50889 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 50409 | 50890 | .unused, |
| 50410 | 50891 | .unused, |
| 50411 | 50892 | .unused, |
| ... | ... | @@ -50414,64 +50895,106 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50414 | 50895 | .unused, |
| 50415 | 50896 | .unused, |
| 50416 | 50897 | }, |
| 50417 | | .dst_temps = .{.{ .rc = .sse }}, |
| 50898 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 50418 | 50899 | .each = .{ .once = &.{ |
| 50419 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 50420 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50421 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 50422 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 50900 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50901 | .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 50902 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 50423 | 50903 | } }, |
| 50424 | 50904 | }, .{ |
| 50425 | | .required_features = .{ .f16c, null, null, null }, |
| 50426 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 50427 | | .dst_constraints = .{.{ .float = .word }}, |
| 50905 | .required_features = .{ .avx, null, null, null }, |
| 50906 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50907 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50428 | 50908 | .patterns = &.{ |
| 50429 | | .{ .src = .{ .mem, .none, .none } }, |
| 50430 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 50909 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50431 | 50910 | }, |
| 50432 | 50911 | .extra_temps = .{ |
| 50433 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50912 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50913 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 50914 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 50915 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 50916 | .unused, |
| 50917 | .unused, |
| 50434 | 50918 | .unused, |
| 50435 | 50919 | .unused, |
| 50436 | 50920 | .unused, |
| 50921 | }, |
| 50922 | .dst_temps = .{.mem}, |
| 50923 | .each = .{ .once = &.{ |
| 50924 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50925 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 50926 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50927 | .{ .@"0:", .v_, .cvttps2dq, .tmp3x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50928 | .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 50929 | .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 50930 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 50931 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50932 | } }, |
| 50933 | }, .{ |
| 50934 | .required_features = .{ .ssse3, null, null, null }, |
| 50935 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50936 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50937 | .patterns = &.{ |
| 50938 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50939 | }, |
| 50940 | .extra_temps = .{ |
| 50941 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50942 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 50943 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 50944 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 50437 | 50945 | .unused, |
| 50438 | 50946 | .unused, |
| 50439 | 50947 | .unused, |
| 50440 | 50948 | .unused, |
| 50441 | 50949 | .unused, |
| 50442 | 50950 | }, |
| 50443 | | .dst_temps = .{.{ .rc = .sse }}, |
| 50951 | .dst_temps = .{.mem}, |
| 50444 | 50952 | .each = .{ .once = &.{ |
| 50445 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 50446 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50447 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 50448 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 50953 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50954 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 50955 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50956 | .{ .@"0:", ._, .cvttps2dq, .tmp3x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50957 | .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ }, |
| 50958 | .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 50959 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 50960 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50449 | 50961 | } }, |
| 50450 | 50962 | }, .{ |
| 50451 | | .required_features = .{ .f16c, null, null, null }, |
| 50452 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 50453 | | .dst_constraints = .{.{ .float = .word }}, |
| 50963 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 50964 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50965 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50454 | 50966 | .patterns = &.{ |
| 50455 | | .{ .src = .{ .mem, .none, .none } }, |
| 50456 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 50967 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50457 | 50968 | }, |
| 50458 | | .dst_temps = .{.{ .rc = .sse }}, |
| 50969 | .extra_temps = .{ |
| 50970 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50971 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 50972 | .unused, |
| 50973 | .unused, |
| 50974 | .unused, |
| 50975 | .unused, |
| 50976 | .unused, |
| 50977 | .unused, |
| 50978 | .unused, |
| 50979 | }, |
| 50980 | .dst_temps = .{.mem}, |
| 50459 | 50981 | .each = .{ .once = &.{ |
| 50460 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50461 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, |
| 50462 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 50982 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50983 | .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50984 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 50985 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 50986 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50463 | 50987 | } }, |
| 50464 | 50988 | }, .{ |
| 50465 | | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 50466 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 50467 | | .dst_constraints = .{.{ .float = .word }}, |
| 50989 | .required_features = .{ .sse, null, null, null }, |
| 50990 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50991 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50468 | 50992 | .patterns = &.{ |
| 50469 | | .{ .src = .{ .mem, .none, .none } }, |
| 50470 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 50993 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50471 | 50994 | }, |
| 50472 | 50995 | .extra_temps = .{ |
| 50473 | | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50474 | | .unused, |
| 50996 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50997 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 50475 | 50998 | .unused, |
| 50476 | 50999 | .unused, |
| 50477 | 51000 | .unused, |
| ... | ... | @@ -50480,97 +51003,192 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50480 | 51003 | .unused, |
| 50481 | 51004 | .unused, |
| 50482 | 51005 | }, |
| 50483 | | .dst_temps = .{.{ .rc = .sse }}, |
| 51006 | .dst_temps = .{.mem}, |
| 50484 | 51007 | .each = .{ .once = &.{ |
| 50485 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 50486 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50487 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, |
| 50488 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 51008 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51009 | .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51010 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 51011 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 51012 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50489 | 51013 | } }, |
| 50490 | 51014 | }, .{ |
| 50491 | | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 50492 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 50493 | | .dst_constraints = .{.{ .float = .word }}, |
| 51015 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 51016 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51017 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50494 | 51018 | .patterns = &.{ |
| 50495 | | .{ .src = .{ .mem, .none, .none } }, |
| 50496 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51019 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50497 | 51020 | }, |
| 50498 | | .dst_temps = .{.{ .rc = .sse }}, |
| 51021 | .call_frame = .{ .alignment = .@"16" }, |
| 51022 | .extra_temps = .{ |
| 51023 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51024 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51025 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51026 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 51027 | .unused, |
| 51028 | .unused, |
| 51029 | .unused, |
| 51030 | .unused, |
| 51031 | .unused, |
| 51032 | }, |
| 51033 | .dst_temps = .{.mem}, |
| 51034 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50499 | 51035 | .each = .{ .once = &.{ |
| 50500 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50501 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 50502 | | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 51036 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51037 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51038 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51039 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 51040 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 51041 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50503 | 51042 | } }, |
| 50504 | 51043 | }, .{ |
| 50505 | | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 50506 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 50507 | | .dst_constraints = .{.{ .float = .word }}, |
| 51044 | .required_features = .{ .avx, null, null, null }, |
| 51045 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51046 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50508 | 51047 | .patterns = &.{ |
| 50509 | | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 51048 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50510 | 51049 | }, |
| 51050 | .call_frame = .{ .alignment = .@"16" }, |
| 50511 | 51051 | .extra_temps = .{ |
| 50512 | | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 51052 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51053 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51054 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51055 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 50513 | 51056 | .unused, |
| 50514 | 51057 | .unused, |
| 50515 | 51058 | .unused, |
| 50516 | 51059 | .unused, |
| 50517 | 51060 | .unused, |
| 51061 | }, |
| 51062 | .dst_temps = .{.mem}, |
| 51063 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51064 | .each = .{ .once = &.{ |
| 51065 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51066 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51067 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51068 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 51069 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 51070 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 51071 | } }, |
| 51072 | }, .{ |
| 51073 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 51074 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51075 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 51076 | .patterns = &.{ |
| 51077 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51078 | }, |
| 51079 | .call_frame = .{ .alignment = .@"16" }, |
| 51080 | .extra_temps = .{ |
| 51081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51082 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51083 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51084 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 51085 | .unused, |
| 51086 | .unused, |
| 50518 | 51087 | .unused, |
| 50519 | 51088 | .unused, |
| 50520 | 51089 | .unused, |
| 50521 | 51090 | }, |
| 50522 | | .dst_temps = .{.{ .rc = .sse }}, |
| 50523 | | .clobbers = .{ .eflags = true }, |
| 51091 | .dst_temps = .{.mem}, |
| 51092 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50524 | 51093 | .each = .{ .once = &.{ |
| 50525 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50526 | | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 50527 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 50528 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 50529 | | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 50530 | | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 50531 | | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 50532 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 50533 | | .{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ }, |
| 50534 | | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 50535 | | .{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 50536 | | .{ .@"0:", .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 51094 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51095 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51096 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51097 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 51098 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 51099 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50537 | 51100 | } }, |
| 50538 | 51101 | }, .{ |
| 50539 | 51102 | .required_features = .{ .sse, null, null, null }, |
| 50540 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 50541 | | .dst_constraints = .{.{ .float = .word }}, |
| 51103 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51104 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50542 | 51105 | .patterns = &.{ |
| 50543 | | .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, |
| 51106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50544 | 51107 | }, |
| 50545 | 51108 | .call_frame = .{ .alignment = .@"16" }, |
| 50546 | 51109 | .extra_temps = .{ |
| 50547 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 50548 | | .unused, |
| 50549 | | .unused, |
| 50550 | | .unused, |
| 51110 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51111 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51112 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51113 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 50551 | 51114 | .unused, |
| 50552 | 51115 | .unused, |
| 50553 | 51116 | .unused, |
| 50554 | 51117 | .unused, |
| 50555 | 51118 | .unused, |
| 50556 | 51119 | }, |
| 50557 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 51120 | .dst_temps = .{.mem}, |
| 50558 | 51121 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50559 | 51122 | .each = .{ .once = &.{ |
| 50560 | | .{ ._, ._, .movsx, .src0d, .src0b, ._, ._ }, |
| 50561 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51123 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51124 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51125 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51126 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 51127 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 51128 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50562 | 51129 | } }, |
| 50563 | 51130 | }, .{ |
| 50564 | | .required_features = .{ .sse, null, null, null }, |
| 50565 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 50566 | | .dst_constraints = .{.{ .float = .word }}, |
| 51131 | .required_features = .{ .avx, null, null, null }, |
| 51132 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51133 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 50567 | 51134 | .patterns = &.{ |
| 50568 | | .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, |
| 51135 | .{ .src = .{ .mem, .none, .none } }, |
| 51136 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51137 | }, |
| 51138 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 51139 | .each = .{ .once = &.{ |
| 51140 | .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 51141 | .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ }, |
| 51142 | } }, |
| 51143 | }, .{ |
| 51144 | .required_features = .{ .sse2, null, null, null }, |
| 51145 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51146 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 51147 | .patterns = &.{ |
| 51148 | .{ .src = .{ .mem, .none, .none } }, |
| 51149 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51150 | }, |
| 51151 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 51152 | .each = .{ .once = &.{ |
| 51153 | .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 51154 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 51155 | } }, |
| 51156 | }, .{ |
| 51157 | .required_features = .{ .avx, null, null, null }, |
| 51158 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51159 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 51160 | .patterns = &.{ |
| 51161 | .{ .src = .{ .mem, .none, .none } }, |
| 51162 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51163 | }, |
| 51164 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 51165 | .each = .{ .once = &.{ |
| 51166 | .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 51167 | .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ }, |
| 51168 | } }, |
| 51169 | }, .{ |
| 51170 | .required_features = .{ .sse4_1, null, null, null }, |
| 51171 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51172 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 51173 | .patterns = &.{ |
| 51174 | .{ .src = .{ .mem, .none, .none } }, |
| 51175 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51176 | }, |
| 51177 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 51178 | .each = .{ .once = &.{ |
| 51179 | .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 51180 | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 51181 | } }, |
| 51182 | }, .{ |
| 51183 | .required_features = .{ .avx, null, null, null }, |
| 51184 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51185 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 51186 | .patterns = &.{ |
| 51187 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50569 | 51188 | }, |
| 50570 | | .call_frame = .{ .alignment = .@"16" }, |
| 50571 | 51189 | .extra_temps = .{ |
| 50572 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 50573 | | .unused, |
| 51190 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51191 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 50574 | 51192 | .unused, |
| 50575 | 51193 | .unused, |
| 50576 | 51194 | .unused, |
| ... | ... | @@ -50579,23 +51197,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50579 | 51197 | .unused, |
| 50580 | 51198 | .unused, |
| 50581 | 51199 | }, |
| 50582 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 50583 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51200 | .dst_temps = .{.mem}, |
| 50584 | 51201 | .each = .{ .once = &.{ |
| 50585 | | .{ ._, ._, .movzx, .src0d, .src0b, ._, ._ }, |
| 50586 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51202 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51203 | .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51204 | .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 51205 | .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 51206 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 51207 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50587 | 51208 | } }, |
| 50588 | 51209 | }, .{ |
| 50589 | | .required_features = .{ .sse, null, null, null }, |
| 50590 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 50591 | | .dst_constraints = .{.{ .float = .word }}, |
| 51210 | .required_features = .{ .sse2, null, null, null }, |
| 51211 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51212 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 50592 | 51213 | .patterns = &.{ |
| 50593 | | .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, |
| 51214 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50594 | 51215 | }, |
| 50595 | | .call_frame = .{ .alignment = .@"16" }, |
| 50596 | 51216 | .extra_temps = .{ |
| 50597 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 50598 | | .unused, |
| 51217 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51218 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 50599 | 51219 | .unused, |
| 50600 | 51220 | .unused, |
| 50601 | 51221 | .unused, |
| ... | ... | @@ -50604,23 +51224,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50604 | 51224 | .unused, |
| 50605 | 51225 | .unused, |
| 50606 | 51226 | }, |
| 50607 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 50608 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51227 | .dst_temps = .{.mem}, |
| 50609 | 51228 | .each = .{ .once = &.{ |
| 50610 | | .{ ._, ._, .movsx, .src0d, .src0w, ._, ._ }, |
| 50611 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51229 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51230 | .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51231 | .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ }, |
| 51232 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 51233 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 51234 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50612 | 51235 | } }, |
| 50613 | 51236 | }, .{ |
| 50614 | | .required_features = .{ .sse, null, null, null }, |
| 50615 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 50616 | | .dst_constraints = .{.{ .float = .word }}, |
| 51237 | .required_features = .{ .avx, null, null, null }, |
| 51238 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51239 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 50617 | 51240 | .patterns = &.{ |
| 50618 | | .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, |
| 51241 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50619 | 51242 | }, |
| 50620 | | .call_frame = .{ .alignment = .@"16" }, |
| 50621 | 51243 | .extra_temps = .{ |
| 50622 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 50623 | | .unused, |
| 51244 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51245 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 50624 | 51246 | .unused, |
| 50625 | 51247 | .unused, |
| 50626 | 51248 | .unused, |
| ... | ... | @@ -50629,70 +51251,12586 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50629 | 51251 | .unused, |
| 50630 | 51252 | .unused, |
| 50631 | 51253 | }, |
| 50632 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 50633 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51254 | .dst_temps = .{.mem}, |
| 50634 | 51255 | .each = .{ .once = &.{ |
| 50635 | | .{ ._, ._, .movzx, .src0d, .src0w, ._, ._ }, |
| 50636 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51256 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51257 | .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51258 | .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 51259 | .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 51260 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 51261 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50637 | 51262 | } }, |
| 50638 | 51263 | }, .{ |
| 50639 | | .required_features = .{ .sse, null, null, null }, |
| 50640 | | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 50641 | | .dst_constraints = .{.{ .float = .word }}, |
| 51264 | .required_features = .{ .sse4_1, null, null, null }, |
| 51265 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51266 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 50642 | 51267 | .patterns = &.{ |
| 50643 | | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 51268 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50644 | 51269 | }, |
| 50645 | | .call_frame = .{ .alignment = .@"16" }, |
| 50646 | 51270 | .extra_temps = .{ |
| 50647 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 51271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51272 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 51273 | .unused, |
| 51274 | .unused, |
| 51275 | .unused, |
| 50648 | 51276 | .unused, |
| 50649 | 51277 | .unused, |
| 50650 | 51278 | .unused, |
| 50651 | 51279 | .unused, |
| 51280 | }, |
| 51281 | .dst_temps = .{.mem}, |
| 51282 | .each = .{ .once = &.{ |
| 51283 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51284 | .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51285 | .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ }, |
| 51286 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 51287 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 51288 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51289 | } }, |
| 51290 | }, .{ |
| 51291 | .required_features = .{ .avx, null, null, null }, |
| 51292 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51293 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 51294 | .patterns = &.{ |
| 51295 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51296 | }, |
| 51297 | .call_frame = .{ .alignment = .@"16" }, |
| 51298 | .extra_temps = .{ |
| 51299 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51300 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51301 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51302 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 51303 | .unused, |
| 50652 | 51304 | .unused, |
| 50653 | 51305 | .unused, |
| 50654 | 51306 | .unused, |
| 50655 | 51307 | .unused, |
| 50656 | 51308 | }, |
| 50657 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 51309 | .dst_temps = .{.mem}, |
| 50658 | 51310 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50659 | 51311 | .each = .{ .once = &.{ |
| 50660 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51312 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51313 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51314 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51315 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 51316 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 51317 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50661 | 51318 | } }, |
| 50662 | 51319 | }, .{ |
| 50663 | 51320 | .required_features = .{ .sse, null, null, null }, |
| 50664 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 50665 | | .dst_constraints = .{.{ .float = .word }}, |
| 51321 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51322 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 50666 | 51323 | .patterns = &.{ |
| 50667 | | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 51324 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50668 | 51325 | }, |
| 50669 | 51326 | .call_frame = .{ .alignment = .@"16" }, |
| 50670 | 51327 | .extra_temps = .{ |
| 50671 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 51328 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51329 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51330 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51331 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 51332 | .unused, |
| 50672 | 51333 | .unused, |
| 50673 | 51334 | .unused, |
| 50674 | 51335 | .unused, |
| 50675 | 51336 | .unused, |
| 51337 | }, |
| 51338 | .dst_temps = .{.mem}, |
| 51339 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51340 | .each = .{ .once = &.{ |
| 51341 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51342 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 51343 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51344 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 51345 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 51346 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51347 | } }, |
| 51348 | }, .{ |
| 51349 | .required_features = .{ .avx, null, null, null }, |
| 51350 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51351 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 51352 | .patterns = &.{ |
| 51353 | .{ .src = .{ .mem, .none, .none } }, |
| 51354 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51355 | }, |
| 51356 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 51357 | .each = .{ .once = &.{ |
| 51358 | .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 51359 | } }, |
| 51360 | }, .{ |
| 51361 | .required_features = .{ .sse2, null, null, null }, |
| 51362 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51363 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 51364 | .patterns = &.{ |
| 51365 | .{ .src = .{ .mem, .none, .none } }, |
| 51366 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51367 | }, |
| 51368 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 51369 | .each = .{ .once = &.{ |
| 51370 | .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 51371 | } }, |
| 51372 | }, .{ |
| 51373 | .required_features = .{ .avx, null, null, null }, |
| 51374 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51375 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 51376 | .patterns = &.{ |
| 51377 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51378 | }, |
| 51379 | .extra_temps = .{ |
| 51380 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51381 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 51382 | .unused, |
| 51383 | .unused, |
| 51384 | .unused, |
| 50676 | 51385 | .unused, |
| 50677 | 51386 | .unused, |
| 50678 | 51387 | .unused, |
| 50679 | 51388 | .unused, |
| 50680 | 51389 | }, |
| 50681 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 50682 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51390 | .dst_temps = .{.mem}, |
| 50683 | 51391 | .each = .{ .once = &.{ |
| 50684 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51392 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51393 | .{ .@"0:", .v_, .cvttps2dq, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51394 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 51395 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 51396 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50685 | 51397 | } }, |
| 50686 | 51398 | }, .{ |
| 50687 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50688 | | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 51399 | .required_features = .{ .sse2, null, null, null }, |
| 51400 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 51401 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 51402 | .patterns = &.{ |
| 51403 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51404 | }, |
| 51405 | .extra_temps = .{ |
| 51406 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51407 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 51408 | .unused, |
| 51409 | .unused, |
| 51410 | .unused, |
| 51411 | .unused, |
| 51412 | .unused, |
| 51413 | .unused, |
| 51414 | .unused, |
| 51415 | }, |
| 51416 | .dst_temps = .{.mem}, |
| 51417 | .each = .{ .once = &.{ |
| 51418 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51419 | .{ .@"0:", ._, .cvttps2dq, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51420 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 51421 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 51422 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51423 | } }, |
| 51424 | }, .{ |
| 51425 | .required_features = .{ .avx, null, null, null }, |
| 51426 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51427 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 51428 | .patterns = &.{ |
| 51429 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51430 | }, |
| 51431 | .call_frame = .{ .alignment = .@"16" }, |
| 51432 | .extra_temps = .{ |
| 51433 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51434 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51435 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51436 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 51437 | .unused, |
| 51438 | .unused, |
| 51439 | .unused, |
| 51440 | .unused, |
| 51441 | .unused, |
| 51442 | }, |
| 51443 | .dst_temps = .{.mem}, |
| 51444 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51445 | .each = .{ .once = &.{ |
| 51446 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51447 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51448 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51449 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 51450 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51451 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51452 | } }, |
| 51453 | }, .{ |
| 51454 | .required_features = .{ .avx, null, null, null }, |
| 51455 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51456 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 51457 | .patterns = &.{ |
| 51458 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51459 | }, |
| 51460 | .call_frame = .{ .alignment = .@"16" }, |
| 51461 | .extra_temps = .{ |
| 51462 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51463 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51464 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfsi" } } }, |
| 51465 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 51466 | .unused, |
| 51467 | .unused, |
| 51468 | .unused, |
| 51469 | .unused, |
| 51470 | .unused, |
| 51471 | }, |
| 51472 | .dst_temps = .{.mem}, |
| 51473 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51474 | .each = .{ .once = &.{ |
| 51475 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51476 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51477 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51478 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 51479 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51480 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51481 | } }, |
| 51482 | }, .{ |
| 51483 | .required_features = .{ .sse, null, null, null }, |
| 51484 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51485 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 51486 | .patterns = &.{ |
| 51487 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51488 | }, |
| 51489 | .call_frame = .{ .alignment = .@"16" }, |
| 51490 | .extra_temps = .{ |
| 51491 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51492 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51493 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 51494 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 51495 | .unused, |
| 51496 | .unused, |
| 51497 | .unused, |
| 51498 | .unused, |
| 51499 | .unused, |
| 51500 | }, |
| 51501 | .dst_temps = .{.mem}, |
| 51502 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51503 | .each = .{ .once = &.{ |
| 51504 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51505 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51506 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51507 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 51508 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51509 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51510 | } }, |
| 51511 | }, .{ |
| 51512 | .required_features = .{ .sse, null, null, null }, |
| 51513 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51514 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 51515 | .patterns = &.{ |
| 51516 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51517 | }, |
| 51518 | .call_frame = .{ .alignment = .@"16" }, |
| 51519 | .extra_temps = .{ |
| 51520 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51521 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51522 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfsi" } } }, |
| 51523 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 51524 | .unused, |
| 51525 | .unused, |
| 51526 | .unused, |
| 51527 | .unused, |
| 51528 | .unused, |
| 51529 | }, |
| 51530 | .dst_temps = .{.mem}, |
| 51531 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51532 | .each = .{ .once = &.{ |
| 51533 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51534 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51535 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51536 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 51537 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51538 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51539 | } }, |
| 51540 | }, .{ |
| 51541 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51542 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51543 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 51544 | .patterns = &.{ |
| 51545 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51546 | }, |
| 51547 | .extra_temps = .{ |
| 51548 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51549 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 51550 | .unused, |
| 51551 | .unused, |
| 51552 | .unused, |
| 51553 | .unused, |
| 51554 | .unused, |
| 51555 | .unused, |
| 51556 | .unused, |
| 51557 | }, |
| 51558 | .dst_temps = .{.mem}, |
| 51559 | .each = .{ .once = &.{ |
| 51560 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51561 | .{ .@"0:", .v_, .cvttss2si, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51562 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 51563 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51564 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51565 | } }, |
| 51566 | }, .{ |
| 51567 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51568 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51569 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 51570 | .patterns = &.{ |
| 51571 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51572 | }, |
| 51573 | .extra_temps = .{ |
| 51574 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51575 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 51576 | .unused, |
| 51577 | .unused, |
| 51578 | .unused, |
| 51579 | .unused, |
| 51580 | .unused, |
| 51581 | .unused, |
| 51582 | .unused, |
| 51583 | }, |
| 51584 | .dst_temps = .{.mem}, |
| 51585 | .each = .{ .once = &.{ |
| 51586 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51587 | .{ .@"0:", ._, .cvttss2si, .tmp1q, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51588 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 51589 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51590 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51591 | } }, |
| 51592 | }, .{ |
| 51593 | .required_features = .{ .avx, null, null, null }, |
| 51594 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51595 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 51596 | .patterns = &.{ |
| 51597 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51598 | }, |
| 51599 | .call_frame = .{ .alignment = .@"16" }, |
| 51600 | .extra_temps = .{ |
| 51601 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51602 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51603 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfdi" } } }, |
| 51604 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 51605 | .unused, |
| 51606 | .unused, |
| 51607 | .unused, |
| 51608 | .unused, |
| 51609 | .unused, |
| 51610 | }, |
| 51611 | .dst_temps = .{.mem}, |
| 51612 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51613 | .each = .{ .once = &.{ |
| 51614 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51615 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51616 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51617 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51618 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51619 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51620 | } }, |
| 51621 | }, .{ |
| 51622 | .required_features = .{ .avx, null, null, null }, |
| 51623 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51624 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 51625 | .patterns = &.{ |
| 51626 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51627 | }, |
| 51628 | .call_frame = .{ .alignment = .@"16" }, |
| 51629 | .extra_temps = .{ |
| 51630 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51631 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51632 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfdi" } } }, |
| 51633 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 51634 | .unused, |
| 51635 | .unused, |
| 51636 | .unused, |
| 51637 | .unused, |
| 51638 | .unused, |
| 51639 | }, |
| 51640 | .dst_temps = .{.mem}, |
| 51641 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51642 | .each = .{ .once = &.{ |
| 51643 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51644 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51645 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51646 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51647 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51648 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51649 | } }, |
| 51650 | }, .{ |
| 51651 | .required_features = .{ .sse, null, null, null }, |
| 51652 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51653 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 51654 | .patterns = &.{ |
| 51655 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51656 | }, |
| 51657 | .call_frame = .{ .alignment = .@"16" }, |
| 51658 | .extra_temps = .{ |
| 51659 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51660 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51661 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfdi" } } }, |
| 51662 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 51663 | .unused, |
| 51664 | .unused, |
| 51665 | .unused, |
| 51666 | .unused, |
| 51667 | .unused, |
| 51668 | }, |
| 51669 | .dst_temps = .{.mem}, |
| 51670 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51671 | .each = .{ .once = &.{ |
| 51672 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51673 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51674 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51675 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51676 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51678 | } }, |
| 51679 | }, .{ |
| 51680 | .required_features = .{ .sse, null, null, null }, |
| 51681 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51682 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 51683 | .patterns = &.{ |
| 51684 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51685 | }, |
| 51686 | .call_frame = .{ .alignment = .@"16" }, |
| 51687 | .extra_temps = .{ |
| 51688 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51689 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51690 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfdi" } } }, |
| 51691 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 51692 | .unused, |
| 51693 | .unused, |
| 51694 | .unused, |
| 51695 | .unused, |
| 51696 | .unused, |
| 51697 | }, |
| 51698 | .dst_temps = .{.mem}, |
| 51699 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51700 | .each = .{ .once = &.{ |
| 51701 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51702 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51703 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51704 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51705 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51706 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51707 | } }, |
| 51708 | }, .{ |
| 51709 | .required_features = .{ .avx, null, null, null }, |
| 51710 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51711 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 51712 | .patterns = &.{ |
| 51713 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51714 | }, |
| 51715 | .call_frame = .{ .alignment = .@"16" }, |
| 51716 | .extra_temps = .{ |
| 51717 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51718 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51719 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } }, |
| 51720 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 51721 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 51722 | .unused, |
| 51723 | .unused, |
| 51724 | .unused, |
| 51725 | .unused, |
| 51726 | }, |
| 51727 | .dst_temps = .{.mem}, |
| 51728 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51729 | .each = .{ .once = &.{ |
| 51730 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51731 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51732 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51733 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51734 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 51735 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51736 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51737 | } }, |
| 51738 | }, .{ |
| 51739 | .required_features = .{ .avx, null, null, null }, |
| 51740 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51741 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 51742 | .patterns = &.{ |
| 51743 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51744 | }, |
| 51745 | .call_frame = .{ .alignment = .@"16" }, |
| 51746 | .extra_temps = .{ |
| 51747 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51748 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51749 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 51750 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 51751 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 51752 | .unused, |
| 51753 | .unused, |
| 51754 | .unused, |
| 51755 | .unused, |
| 51756 | }, |
| 51757 | .dst_temps = .{.mem}, |
| 51758 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51759 | .each = .{ .once = &.{ |
| 51760 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51761 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51762 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51763 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51764 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 51765 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51766 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51767 | } }, |
| 51768 | }, .{ |
| 51769 | .required_features = .{ .sse, null, null, null }, |
| 51770 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51771 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 51772 | .patterns = &.{ |
| 51773 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51774 | }, |
| 51775 | .call_frame = .{ .alignment = .@"16" }, |
| 51776 | .extra_temps = .{ |
| 51777 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51778 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51779 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } }, |
| 51780 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 51781 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 51782 | .unused, |
| 51783 | .unused, |
| 51784 | .unused, |
| 51785 | .unused, |
| 51786 | }, |
| 51787 | .dst_temps = .{.mem}, |
| 51788 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51789 | .each = .{ .once = &.{ |
| 51790 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51791 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51792 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51793 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51794 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 51795 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51796 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51797 | } }, |
| 51798 | }, .{ |
| 51799 | .required_features = .{ .sse, null, null, null }, |
| 51800 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51801 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 51802 | .patterns = &.{ |
| 51803 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51804 | }, |
| 51805 | .call_frame = .{ .alignment = .@"16" }, |
| 51806 | .extra_temps = .{ |
| 51807 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51808 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51809 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 51810 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 51811 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 51812 | .unused, |
| 51813 | .unused, |
| 51814 | .unused, |
| 51815 | .unused, |
| 51816 | }, |
| 51817 | .dst_temps = .{.mem}, |
| 51818 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51819 | .each = .{ .once = &.{ |
| 51820 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51821 | .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51822 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51823 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 51824 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"4", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 51825 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51826 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51827 | } }, |
| 51828 | }, .{ |
| 51829 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51830 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51831 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 51832 | .patterns = &.{ |
| 51833 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51834 | }, |
| 51835 | .call_frame = .{ .alignment = .@"16" }, |
| 51836 | .extra_temps = .{ |
| 51837 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51838 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51839 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51840 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51841 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51842 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfei" } } }, |
| 51843 | .unused, |
| 51844 | .unused, |
| 51845 | .unused, |
| 51846 | }, |
| 51847 | .dst_temps = .{.mem}, |
| 51848 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51849 | .each = .{ .once = &.{ |
| 51850 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51851 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51852 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 51853 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 51854 | .{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51855 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 51856 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 51857 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51858 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51859 | } }, |
| 51860 | }, .{ |
| 51861 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51862 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51863 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 51864 | .patterns = &.{ |
| 51865 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51866 | }, |
| 51867 | .call_frame = .{ .alignment = .@"16" }, |
| 51868 | .extra_temps = .{ |
| 51869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51870 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51871 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51872 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51873 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51874 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfei" } } }, |
| 51875 | .unused, |
| 51876 | .unused, |
| 51877 | .unused, |
| 51878 | }, |
| 51879 | .dst_temps = .{.mem}, |
| 51880 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51881 | .each = .{ .once = &.{ |
| 51882 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51883 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51884 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 51885 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 51886 | .{ ._, .v_ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51887 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 51888 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 51889 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51890 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51891 | } }, |
| 51892 | }, .{ |
| 51893 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51894 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51895 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 51896 | .patterns = &.{ |
| 51897 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51898 | }, |
| 51899 | .call_frame = .{ .alignment = .@"16" }, |
| 51900 | .extra_temps = .{ |
| 51901 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51902 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51903 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51904 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51905 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51906 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfei" } } }, |
| 51907 | .unused, |
| 51908 | .unused, |
| 51909 | .unused, |
| 51910 | }, |
| 51911 | .dst_temps = .{.mem}, |
| 51912 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51913 | .each = .{ .once = &.{ |
| 51914 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51915 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51916 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 51917 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 51918 | .{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51919 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 51920 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 51921 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51922 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51923 | } }, |
| 51924 | }, .{ |
| 51925 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51926 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51927 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 51928 | .patterns = &.{ |
| 51929 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51930 | }, |
| 51931 | .call_frame = .{ .alignment = .@"16" }, |
| 51932 | .extra_temps = .{ |
| 51933 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51934 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51935 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51936 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51937 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 51938 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfei" } } }, |
| 51939 | .unused, |
| 51940 | .unused, |
| 51941 | .unused, |
| 51942 | }, |
| 51943 | .dst_temps = .{.mem}, |
| 51944 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51945 | .each = .{ .once = &.{ |
| 51946 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51947 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51948 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 51949 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 51950 | .{ ._, ._ss, .mov, .tmp4x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51951 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 51952 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 51953 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 51954 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51955 | } }, |
| 51956 | }, .{ |
| 51957 | .required_features = .{ .avx, null, null, null }, |
| 51958 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 51959 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 51960 | .patterns = &.{ |
| 51961 | .{ .src = .{ .mem, .none, .none } }, |
| 51962 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51963 | }, |
| 51964 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 51965 | .each = .{ .once = &.{ |
| 51966 | .{ ._, .v_, .cvttsd2si, .dst0d, .src0q, ._, ._ }, |
| 51967 | } }, |
| 51968 | }, .{ |
| 51969 | .required_features = .{ .sse2, null, null, null }, |
| 51970 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 51971 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 51972 | .patterns = &.{ |
| 51973 | .{ .src = .{ .mem, .none, .none } }, |
| 51974 | .{ .src = .{ .to_sse, .none, .none } }, |
| 51975 | }, |
| 51976 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 51977 | .each = .{ .once = &.{ |
| 51978 | .{ ._, ._, .cvttsd2si, .dst0d, .src0q, ._, ._ }, |
| 51979 | } }, |
| 51980 | }, .{ |
| 51981 | .required_features = .{ .x87, null, null, null }, |
| 51982 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 51983 | .dst_constraints = .{.{ .signed_int = .byte }}, |
| 51984 | .patterns = &.{ |
| 51985 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51986 | }, |
| 51987 | .extra_temps = .{ |
| 51988 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51989 | .{ .type = .i16, .kind = .mem }, |
| 51990 | .unused, |
| 51991 | .unused, |
| 51992 | .unused, |
| 51993 | .unused, |
| 51994 | .unused, |
| 51995 | .unused, |
| 51996 | .unused, |
| 51997 | }, |
| 51998 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 51999 | .each = .{ .once = &.{ |
| 52000 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 52001 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 52002 | .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ }, |
| 52003 | } }, |
| 52004 | }, .{ |
| 52005 | .required_features = .{ .x87, null, null, null }, |
| 52006 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52007 | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 52008 | .patterns = &.{ |
| 52009 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52010 | }, |
| 52011 | .extra_temps = .{ |
| 52012 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52013 | .{ .type = .i16, .kind = .mem }, |
| 52014 | .unused, |
| 52015 | .unused, |
| 52016 | .unused, |
| 52017 | .unused, |
| 52018 | .unused, |
| 52019 | .unused, |
| 52020 | .unused, |
| 52021 | }, |
| 52022 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 52023 | .each = .{ .once = &.{ |
| 52024 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 52025 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 52026 | .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ }, |
| 52027 | } }, |
| 52028 | }, .{ |
| 52029 | .required_features = .{ .x87, null, null, null }, |
| 52030 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52031 | .dst_constraints = .{.{ .signed_or_exclusive_int = .word }}, |
| 52032 | .patterns = &.{ |
| 52033 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52034 | }, |
| 52035 | .extra_temps = .{ |
| 52036 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52037 | .unused, |
| 52038 | .unused, |
| 52039 | .unused, |
| 52040 | .unused, |
| 52041 | .unused, |
| 52042 | .unused, |
| 52043 | .unused, |
| 52044 | .unused, |
| 52045 | }, |
| 52046 | .dst_temps = .{.mem}, |
| 52047 | .each = .{ .once = &.{ |
| 52048 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 52049 | .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ }, |
| 52050 | } }, |
| 52051 | }, .{ |
| 52052 | .required_features = .{ .x87, null, null, null }, |
| 52053 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52054 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 52055 | .patterns = &.{ |
| 52056 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52057 | }, |
| 52058 | .extra_temps = .{ |
| 52059 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52060 | .unused, |
| 52061 | .unused, |
| 52062 | .unused, |
| 52063 | .unused, |
| 52064 | .unused, |
| 52065 | .unused, |
| 52066 | .unused, |
| 52067 | .unused, |
| 52068 | }, |
| 52069 | .dst_temps = .{.mem}, |
| 52070 | .each = .{ .once = &.{ |
| 52071 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 52072 | .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ }, |
| 52073 | } }, |
| 52074 | }, .{ |
| 52075 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52076 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52077 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 52078 | .patterns = &.{ |
| 52079 | .{ .src = .{ .mem, .none, .none } }, |
| 52080 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52081 | }, |
| 52082 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 52083 | .each = .{ .once = &.{ |
| 52084 | .{ ._, .v_, .cvttsd2si, .dst0q, .src0q, ._, ._ }, |
| 52085 | } }, |
| 52086 | }, .{ |
| 52087 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52088 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52089 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 52090 | .patterns = &.{ |
| 52091 | .{ .src = .{ .mem, .none, .none } }, |
| 52092 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52093 | }, |
| 52094 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 52095 | .each = .{ .once = &.{ |
| 52096 | .{ ._, ._, .cvttsd2si, .dst0q, .src0q, ._, ._ }, |
| 52097 | } }, |
| 52098 | }, .{ |
| 52099 | .required_features = .{ .x87, null, null, null }, |
| 52100 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52101 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 52102 | .patterns = &.{ |
| 52103 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52104 | }, |
| 52105 | .extra_temps = .{ |
| 52106 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52107 | .unused, |
| 52108 | .unused, |
| 52109 | .unused, |
| 52110 | .unused, |
| 52111 | .unused, |
| 52112 | .unused, |
| 52113 | .unused, |
| 52114 | .unused, |
| 52115 | }, |
| 52116 | .dst_temps = .{.mem}, |
| 52117 | .each = .{ .once = &.{ |
| 52118 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 52119 | .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ }, |
| 52120 | } }, |
| 52121 | }, .{ |
| 52122 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52123 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52124 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 52125 | .patterns = &.{ |
| 52126 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52127 | }, |
| 52128 | .extra_temps = .{ |
| 52129 | .{ .type = .f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 52130 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 52131 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 52132 | .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 52133 | .unused, |
| 52134 | .unused, |
| 52135 | .unused, |
| 52136 | .unused, |
| 52137 | .unused, |
| 52138 | }, |
| 52139 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 52140 | .clobbers = .{ .eflags = true }, |
| 52141 | .each = .{ .once = &.{ |
| 52142 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 52143 | .{ ._, .v_, .cvttsd2si, .tmp2q, .src0d, ._, ._ }, |
| 52144 | .{ ._, .v_sd, .sub, .tmp0x, .src0x, .lea(.tmp1q), ._ }, |
| 52145 | .{ ._, .v_, .cvttsd2si, .dst0q, .tmp0d, ._, ._ }, |
| 52146 | .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ }, |
| 52147 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| 52148 | .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ }, |
| 52149 | .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ }, |
| 52150 | } }, |
| 52151 | }, .{ |
| 52152 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52153 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52154 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 52155 | .patterns = &.{ |
| 52156 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 52157 | }, |
| 52158 | .extra_temps = .{ |
| 52159 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 52160 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 52161 | .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 52162 | .unused, |
| 52163 | .unused, |
| 52164 | .unused, |
| 52165 | .unused, |
| 52166 | .unused, |
| 52167 | .unused, |
| 52168 | }, |
| 52169 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 52170 | .clobbers = .{ .eflags = true }, |
| 52171 | .each = .{ .once = &.{ |
| 52172 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 52173 | .{ ._, ._, .cvttsd2si, .tmp1q, .src0d, ._, ._ }, |
| 52174 | .{ ._, ._sd, .sub, .src0x, .lea(.tmp0q), ._, ._ }, |
| 52175 | .{ ._, ._, .cvttsd2si, .dst0q, .src0d, ._, ._ }, |
| 52176 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| 52177 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 52178 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, |
| 52179 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 52180 | } }, |
| 52181 | }, .{ |
| 52182 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 52183 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52184 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 52185 | .patterns = &.{ |
| 52186 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52187 | }, |
| 52188 | .extra_temps = .{ |
| 52189 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 52190 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 52191 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 52192 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52193 | .{ .type = .i64, .kind = .mem }, |
| 52194 | .unused, |
| 52195 | .unused, |
| 52196 | .unused, |
| 52197 | .unused, |
| 52198 | }, |
| 52199 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 52200 | .clobbers = .{ .eflags = true }, |
| 52201 | .each = .{ .once = &.{ |
| 52202 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, |
| 52203 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 52204 | .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ }, |
| 52205 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 52206 | .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ }, |
| 52207 | .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ }, |
| 52208 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 52209 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 52210 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 52211 | .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, |
| 52212 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 52213 | } }, |
| 52214 | }, .{ |
| 52215 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52216 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52217 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 52218 | .patterns = &.{ |
| 52219 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 52220 | }, |
| 52221 | .call_frame = .{ .alignment = .@"16" }, |
| 52222 | .extra_temps = .{ |
| 52223 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } }, |
| 52224 | .unused, |
| 52225 | .unused, |
| 52226 | .unused, |
| 52227 | .unused, |
| 52228 | .unused, |
| 52229 | .unused, |
| 52230 | .unused, |
| 52231 | .unused, |
| 52232 | }, |
| 52233 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 52234 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52235 | .each = .{ .once = &.{ |
| 52236 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 52237 | } }, |
| 52238 | }, .{ |
| 52239 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52240 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52241 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 52242 | .patterns = &.{ |
| 52243 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 52244 | }, |
| 52245 | .call_frame = .{ .alignment = .@"16" }, |
| 52246 | .extra_temps = .{ |
| 52247 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } }, |
| 52248 | .unused, |
| 52249 | .unused, |
| 52250 | .unused, |
| 52251 | .unused, |
| 52252 | .unused, |
| 52253 | .unused, |
| 52254 | .unused, |
| 52255 | .unused, |
| 52256 | }, |
| 52257 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 52258 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52259 | .each = .{ .once = &.{ |
| 52260 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 52261 | } }, |
| 52262 | }, .{ |
| 52263 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52264 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52265 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 52266 | .patterns = &.{ |
| 52267 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 52268 | }, |
| 52269 | .call_frame = .{ .alignment = .@"16" }, |
| 52270 | .extra_temps = .{ |
| 52271 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52272 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52273 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } }, |
| 52274 | .unused, |
| 52275 | .unused, |
| 52276 | .unused, |
| 52277 | .unused, |
| 52278 | .unused, |
| 52279 | .unused, |
| 52280 | }, |
| 52281 | .dst_temps = .{.mem}, |
| 52282 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52283 | .each = .{ .once = &.{ |
| 52284 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 52285 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 52286 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52287 | } }, |
| 52288 | }, .{ |
| 52289 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52290 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, |
| 52291 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 52292 | .patterns = &.{ |
| 52293 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 52294 | }, |
| 52295 | .call_frame = .{ .alignment = .@"16" }, |
| 52296 | .extra_temps = .{ |
| 52297 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52298 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52299 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } }, |
| 52300 | .unused, |
| 52301 | .unused, |
| 52302 | .unused, |
| 52303 | .unused, |
| 52304 | .unused, |
| 52305 | .unused, |
| 52306 | }, |
| 52307 | .dst_temps = .{.mem}, |
| 52308 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52309 | .each = .{ .once = &.{ |
| 52310 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 52311 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 52312 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52313 | } }, |
| 52314 | }, .{ |
| 52315 | .required_features = .{ .avx, null, null, null }, |
| 52316 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52317 | .dst_constraints = .{.{ .scalar_int = .{ .of = .word, .is = .byte } }}, |
| 52318 | .patterns = &.{ |
| 52319 | .{ .src = .{ .mem, .none, .none } }, |
| 52320 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52321 | }, |
| 52322 | .extra_temps = .{ |
| 52323 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52324 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 52325 | .unused, |
| 52326 | .unused, |
| 52327 | .unused, |
| 52328 | .unused, |
| 52329 | .unused, |
| 52330 | .unused, |
| 52331 | .unused, |
| 52332 | }, |
| 52333 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52334 | .each = .{ .once = &.{ |
| 52335 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 52336 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 52337 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 52338 | } }, |
| 52339 | }, .{ |
| 52340 | .required_features = .{ .ssse3, null, null, null }, |
| 52341 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52342 | .dst_constraints = .{.{ .scalar_int = .{ .of = .word, .is = .byte } }}, |
| 52343 | .patterns = &.{ |
| 52344 | .{ .src = .{ .mem, .none, .none } }, |
| 52345 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52346 | }, |
| 52347 | .extra_temps = .{ |
| 52348 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52349 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 52350 | .unused, |
| 52351 | .unused, |
| 52352 | .unused, |
| 52353 | .unused, |
| 52354 | .unused, |
| 52355 | .unused, |
| 52356 | .unused, |
| 52357 | }, |
| 52358 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52359 | .each = .{ .once = &.{ |
| 52360 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 52361 | .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 52362 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 52363 | } }, |
| 52364 | }, .{ |
| 52365 | .required_features = .{ .avx, null, null, null }, |
| 52366 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 52367 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 52368 | .patterns = &.{ |
| 52369 | .{ .src = .{ .mem, .none, .none } }, |
| 52370 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52371 | }, |
| 52372 | .extra_temps = .{ |
| 52373 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52374 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 52375 | .unused, |
| 52376 | .unused, |
| 52377 | .unused, |
| 52378 | .unused, |
| 52379 | .unused, |
| 52380 | .unused, |
| 52381 | .unused, |
| 52382 | }, |
| 52383 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52384 | .each = .{ .once = &.{ |
| 52385 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 52386 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ }, |
| 52387 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 52388 | } }, |
| 52389 | }, .{ |
| 52390 | .required_features = .{ .avx, null, null, null }, |
| 52391 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 52392 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 52393 | .patterns = &.{ |
| 52394 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52395 | }, |
| 52396 | .extra_temps = .{ |
| 52397 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52398 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 52399 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 52400 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 52401 | .unused, |
| 52402 | .unused, |
| 52403 | .unused, |
| 52404 | .unused, |
| 52405 | .unused, |
| 52406 | }, |
| 52407 | .dst_temps = .{.mem}, |
| 52408 | .clobbers = .{ .eflags = true }, |
| 52409 | .each = .{ .once = &.{ |
| 52410 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 52411 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 52412 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52413 | .{ .@"0:", .v_, .cvttpd2dq, .tmp3x, .memsia(.src0y, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52414 | .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 52415 | .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 52416 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 52417 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52418 | } }, |
| 52419 | }, .{ |
| 52420 | .required_features = .{ .ssse3, null, null, null }, |
| 52421 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52422 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .byte } }}, |
| 52423 | .patterns = &.{ |
| 52424 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52425 | }, |
| 52426 | .extra_temps = .{ |
| 52427 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52428 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 52429 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 52430 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 52431 | .unused, |
| 52432 | .unused, |
| 52433 | .unused, |
| 52434 | .unused, |
| 52435 | .unused, |
| 52436 | }, |
| 52437 | .dst_temps = .{.mem}, |
| 52438 | .clobbers = .{ .eflags = true }, |
| 52439 | .each = .{ .once = &.{ |
| 52440 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 52441 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 52442 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52443 | .{ .@"0:", ._, .cvttpd2dq, .tmp3x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52444 | .{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ }, |
| 52445 | .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 52446 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 52447 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52448 | } }, |
| 52449 | }, .{ |
| 52450 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 52451 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52452 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52453 | .patterns = &.{ |
| 52454 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52455 | }, |
| 52456 | .extra_temps = .{ |
| 52457 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52458 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 52459 | .unused, |
| 52460 | .unused, |
| 52461 | .unused, |
| 52462 | .unused, |
| 52463 | .unused, |
| 52464 | .unused, |
| 52465 | .unused, |
| 52466 | }, |
| 52467 | .dst_temps = .{.mem}, |
| 52468 | .clobbers = .{ .eflags = true }, |
| 52469 | .each = .{ .once = &.{ |
| 52470 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52471 | .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52472 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 52473 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 52474 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52475 | } }, |
| 52476 | }, .{ |
| 52477 | .required_features = .{ .sse2, null, null, null }, |
| 52478 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52479 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52480 | .patterns = &.{ |
| 52481 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52482 | }, |
| 52483 | .extra_temps = .{ |
| 52484 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52485 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 52486 | .unused, |
| 52487 | .unused, |
| 52488 | .unused, |
| 52489 | .unused, |
| 52490 | .unused, |
| 52491 | .unused, |
| 52492 | .unused, |
| 52493 | }, |
| 52494 | .dst_temps = .{.mem}, |
| 52495 | .clobbers = .{ .eflags = true }, |
| 52496 | .each = .{ .once = &.{ |
| 52497 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52498 | .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52499 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 52500 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 52501 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52502 | } }, |
| 52503 | }, .{ |
| 52504 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 52505 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52506 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52507 | .patterns = &.{ |
| 52508 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52509 | }, |
| 52510 | .extra_temps = .{ |
| 52511 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52512 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52513 | .{ .type = .i16, .kind = .mem }, |
| 52514 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 52515 | .unused, |
| 52516 | .unused, |
| 52517 | .unused, |
| 52518 | .unused, |
| 52519 | .unused, |
| 52520 | }, |
| 52521 | .dst_temps = .{.mem}, |
| 52522 | .each = .{ .once = &.{ |
| 52523 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52524 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 52525 | .{ ._, .fi_p, .stt, .tmp2w, ._, ._, ._ }, |
| 52526 | .{ ._, ._, .movzx, .tmp3d, .tmp2b, ._, ._ }, |
| 52527 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52528 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 52529 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52530 | } }, |
| 52531 | }, .{ |
| 52532 | .required_features = .{ .x87, null, null, null }, |
| 52533 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52534 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52535 | .patterns = &.{ |
| 52536 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52537 | }, |
| 52538 | .extra_temps = .{ |
| 52539 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52540 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52541 | .{ .type = .i16, .kind = .mem }, |
| 52542 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 52543 | .unused, |
| 52544 | .unused, |
| 52545 | .unused, |
| 52546 | .unused, |
| 52547 | .unused, |
| 52548 | }, |
| 52549 | .dst_temps = .{.mem}, |
| 52550 | .each = .{ .once = &.{ |
| 52551 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52552 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 52553 | .{ ._, .fi_p, .stt, .tmp2w, ._, ._, ._ }, |
| 52554 | .{ ._, ._, .movzx, .tmp3d, .tmp2b, ._, ._ }, |
| 52555 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52556 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 52557 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 52558 | } }, |
| 52559 | }, .{ |
| 52560 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 52561 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52562 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52563 | .patterns = &.{ |
| 52564 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52565 | }, |
| 52566 | .call_frame = .{ .alignment = .@"16" }, |
| 52567 | .extra_temps = .{ |
| 52568 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52569 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 52570 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 52571 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 52572 | .unused, |
| 52573 | .unused, |
| 52574 | .unused, |
| 52575 | .unused, |
| 52576 | .unused, |
| 52577 | }, |
| 52578 | .dst_temps = .{.mem}, |
| 52579 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52580 | .each = .{ .once = &.{ |
| 52581 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52582 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52583 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52584 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52585 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 52586 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52587 | } }, |
| 52588 | }, .{ |
| 52589 | .required_features = .{ .avx, null, null, null }, |
| 52590 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52591 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52592 | .patterns = &.{ |
| 52593 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52594 | }, |
| 52595 | .call_frame = .{ .alignment = .@"16" }, |
| 52596 | .extra_temps = .{ |
| 52597 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52598 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 52599 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 52600 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 52601 | .unused, |
| 52602 | .unused, |
| 52603 | .unused, |
| 52604 | .unused, |
| 52605 | .unused, |
| 52606 | }, |
| 52607 | .dst_temps = .{.mem}, |
| 52608 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52609 | .each = .{ .once = &.{ |
| 52610 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52611 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52612 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52613 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52614 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 52615 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 52616 | } }, |
| 52617 | }, .{ |
| 52618 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 52619 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52620 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52621 | .patterns = &.{ |
| 52622 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52623 | }, |
| 52624 | .call_frame = .{ .alignment = .@"16" }, |
| 52625 | .extra_temps = .{ |
| 52626 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52627 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 52628 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 52629 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 52630 | .unused, |
| 52631 | .unused, |
| 52632 | .unused, |
| 52633 | .unused, |
| 52634 | .unused, |
| 52635 | }, |
| 52636 | .dst_temps = .{.mem}, |
| 52637 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52638 | .each = .{ .once = &.{ |
| 52639 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52640 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52641 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52642 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52643 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 52644 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52645 | } }, |
| 52646 | }, .{ |
| 52647 | .required_features = .{ .sse2, null, null, null }, |
| 52648 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52649 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52650 | .patterns = &.{ |
| 52651 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52652 | }, |
| 52653 | .call_frame = .{ .alignment = .@"16" }, |
| 52654 | .extra_temps = .{ |
| 52655 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52656 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 52657 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 52658 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 52659 | .unused, |
| 52660 | .unused, |
| 52661 | .unused, |
| 52662 | .unused, |
| 52663 | .unused, |
| 52664 | }, |
| 52665 | .dst_temps = .{.mem}, |
| 52666 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52667 | .each = .{ .once = &.{ |
| 52668 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52669 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52670 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52671 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52672 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 52673 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 52674 | } }, |
| 52675 | }, .{ |
| 52676 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 52677 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52678 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52679 | .patterns = &.{ |
| 52680 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52681 | }, |
| 52682 | .call_frame = .{ .alignment = .@"16" }, |
| 52683 | .extra_temps = .{ |
| 52684 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52685 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 52686 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 52687 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 52688 | .unused, |
| 52689 | .unused, |
| 52690 | .unused, |
| 52691 | .unused, |
| 52692 | .unused, |
| 52693 | }, |
| 52694 | .dst_temps = .{.mem}, |
| 52695 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52696 | .each = .{ .once = &.{ |
| 52697 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52698 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 52699 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52700 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52701 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52702 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 52703 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52704 | } }, |
| 52705 | }, .{ |
| 52706 | .required_features = .{ .sse, null, null, null }, |
| 52707 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52708 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 52709 | .patterns = &.{ |
| 52710 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52711 | }, |
| 52712 | .call_frame = .{ .alignment = .@"16" }, |
| 52713 | .extra_temps = .{ |
| 52714 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52715 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 52716 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 52717 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 52718 | .unused, |
| 52719 | .unused, |
| 52720 | .unused, |
| 52721 | .unused, |
| 52722 | .unused, |
| 52723 | }, |
| 52724 | .dst_temps = .{.mem}, |
| 52725 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52726 | .each = .{ .once = &.{ |
| 52727 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52728 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 52729 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52730 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52731 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 52732 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 52733 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 52734 | } }, |
| 52735 | }, .{ |
| 52736 | .required_features = .{ .avx, null, null, null }, |
| 52737 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52738 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .word } }}, |
| 52739 | .patterns = &.{ |
| 52740 | .{ .src = .{ .mem, .none, .none } }, |
| 52741 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52742 | }, |
| 52743 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52744 | .each = .{ .once = &.{ |
| 52745 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 52746 | .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ }, |
| 52747 | } }, |
| 52748 | }, .{ |
| 52749 | .required_features = .{ .sse2, null, null, null }, |
| 52750 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52751 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .word } }}, |
| 52752 | .patterns = &.{ |
| 52753 | .{ .src = .{ .mem, .none, .none } }, |
| 52754 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52755 | }, |
| 52756 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52757 | .each = .{ .once = &.{ |
| 52758 | .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 52759 | .{ ._, .p_w, .ackssd, .dst0x, .dst0x, ._, ._ }, |
| 52760 | } }, |
| 52761 | }, .{ |
| 52762 | .required_features = .{ .avx, null, null, null }, |
| 52763 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 52764 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 52765 | .patterns = &.{ |
| 52766 | .{ .src = .{ .mem, .none, .none } }, |
| 52767 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52768 | }, |
| 52769 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52770 | .each = .{ .once = &.{ |
| 52771 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ }, |
| 52772 | .{ ._, .vp_w, .ackssd, .dst0x, .dst0x, .dst0x, ._ }, |
| 52773 | } }, |
| 52774 | }, .{ |
| 52775 | .required_features = .{ .avx, null, null, null }, |
| 52776 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52777 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }}, |
| 52778 | .patterns = &.{ |
| 52779 | .{ .src = .{ .mem, .none, .none } }, |
| 52780 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52781 | }, |
| 52782 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52783 | .each = .{ .once = &.{ |
| 52784 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 52785 | .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ }, |
| 52786 | } }, |
| 52787 | }, .{ |
| 52788 | .required_features = .{ .sse4_1, null, null, null }, |
| 52789 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52790 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }}, |
| 52791 | .patterns = &.{ |
| 52792 | .{ .src = .{ .mem, .none, .none } }, |
| 52793 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52794 | }, |
| 52795 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52796 | .each = .{ .once = &.{ |
| 52797 | .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 52798 | .{ ._, .p_w, .ackusd, .dst0x, .dst0x, ._, ._ }, |
| 52799 | } }, |
| 52800 | }, .{ |
| 52801 | .required_features = .{ .avx, null, null, null }, |
| 52802 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 52803 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 52804 | .patterns = &.{ |
| 52805 | .{ .src = .{ .mem, .none, .none } }, |
| 52806 | .{ .src = .{ .to_sse, .none, .none } }, |
| 52807 | }, |
| 52808 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 52809 | .each = .{ .once = &.{ |
| 52810 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ }, |
| 52811 | .{ ._, .vp_w, .ackusd, .dst0x, .dst0x, .dst0x, ._ }, |
| 52812 | } }, |
| 52813 | }, .{ |
| 52814 | .required_features = .{ .avx, null, null, null }, |
| 52815 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 52816 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 52817 | .patterns = &.{ |
| 52818 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52819 | }, |
| 52820 | .extra_temps = .{ |
| 52821 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52822 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 52823 | .unused, |
| 52824 | .unused, |
| 52825 | .unused, |
| 52826 | .unused, |
| 52827 | .unused, |
| 52828 | .unused, |
| 52829 | .unused, |
| 52830 | }, |
| 52831 | .dst_temps = .{.mem}, |
| 52832 | .clobbers = .{ .eflags = true }, |
| 52833 | .each = .{ .once = &.{ |
| 52834 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52835 | .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52836 | .{ ._, .vp_w, .ackssd, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 52837 | .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 52838 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 52839 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52840 | } }, |
| 52841 | }, .{ |
| 52842 | .required_features = .{ .sse2, null, null, null }, |
| 52843 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52844 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }}, |
| 52845 | .patterns = &.{ |
| 52846 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52847 | }, |
| 52848 | .extra_temps = .{ |
| 52849 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52850 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 52851 | .unused, |
| 52852 | .unused, |
| 52853 | .unused, |
| 52854 | .unused, |
| 52855 | .unused, |
| 52856 | .unused, |
| 52857 | .unused, |
| 52858 | }, |
| 52859 | .dst_temps = .{.mem}, |
| 52860 | .clobbers = .{ .eflags = true }, |
| 52861 | .each = .{ .once = &.{ |
| 52862 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52863 | .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52864 | .{ ._, .p_w, .ackssd, .tmp1x, .tmp1x, ._, ._ }, |
| 52865 | .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 52866 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 52867 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52868 | } }, |
| 52869 | }, .{ |
| 52870 | .required_features = .{ .avx, null, null, null }, |
| 52871 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 52872 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 52873 | .patterns = &.{ |
| 52874 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52875 | }, |
| 52876 | .extra_temps = .{ |
| 52877 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52878 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 52879 | .unused, |
| 52880 | .unused, |
| 52881 | .unused, |
| 52882 | .unused, |
| 52883 | .unused, |
| 52884 | .unused, |
| 52885 | .unused, |
| 52886 | }, |
| 52887 | .dst_temps = .{.mem}, |
| 52888 | .clobbers = .{ .eflags = true }, |
| 52889 | .each = .{ .once = &.{ |
| 52890 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52891 | .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52892 | .{ ._, .vp_w, .ackusd, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 52893 | .{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 52894 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 52895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52896 | } }, |
| 52897 | }, .{ |
| 52898 | .required_features = .{ .sse4_1, null, null, null }, |
| 52899 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 52900 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .word } }}, |
| 52901 | .patterns = &.{ |
| 52902 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52903 | }, |
| 52904 | .extra_temps = .{ |
| 52905 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52906 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 52907 | .unused, |
| 52908 | .unused, |
| 52909 | .unused, |
| 52910 | .unused, |
| 52911 | .unused, |
| 52912 | .unused, |
| 52913 | .unused, |
| 52914 | }, |
| 52915 | .dst_temps = .{.mem}, |
| 52916 | .clobbers = .{ .eflags = true }, |
| 52917 | .each = .{ .once = &.{ |
| 52918 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52919 | .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52920 | .{ ._, .p_w, .ackusd, .tmp1x, .tmp1x, ._, ._ }, |
| 52921 | .{ ._, ._d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 52922 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 52923 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52924 | } }, |
| 52925 | }, .{ |
| 52926 | .required_features = .{ .sse2, null, null, null }, |
| 52927 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52928 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 52929 | .patterns = &.{ |
| 52930 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52931 | }, |
| 52932 | .extra_temps = .{ |
| 52933 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52934 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 52935 | .unused, |
| 52936 | .unused, |
| 52937 | .unused, |
| 52938 | .unused, |
| 52939 | .unused, |
| 52940 | .unused, |
| 52941 | .unused, |
| 52942 | }, |
| 52943 | .dst_temps = .{.mem}, |
| 52944 | .clobbers = .{ .eflags = true }, |
| 52945 | .each = .{ .once = &.{ |
| 52946 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52947 | .{ .@"0:", ._, .cvttsd2si, .tmp1d, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 52948 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 52949 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 52950 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52951 | } }, |
| 52952 | }, .{ |
| 52953 | .required_features = .{ .x87, null, null, null }, |
| 52954 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52955 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 52956 | .patterns = &.{ |
| 52957 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52958 | }, |
| 52959 | .extra_temps = .{ |
| 52960 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52961 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52962 | .unused, |
| 52963 | .unused, |
| 52964 | .unused, |
| 52965 | .unused, |
| 52966 | .unused, |
| 52967 | .unused, |
| 52968 | .unused, |
| 52969 | }, |
| 52970 | .dst_temps = .{.mem}, |
| 52971 | .each = .{ .once = &.{ |
| 52972 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52973 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 52974 | .{ ._, .fi_p, .stt, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 52975 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 52976 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52977 | } }, |
| 52978 | }, .{ |
| 52979 | .required_features = .{ .x87, null, null, null }, |
| 52980 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52981 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 52982 | .patterns = &.{ |
| 52983 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52984 | }, |
| 52985 | .extra_temps = .{ |
| 52986 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52987 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 52988 | .{ .type = .i32, .kind = .mem }, |
| 52989 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 52990 | .unused, |
| 52991 | .unused, |
| 52992 | .unused, |
| 52993 | .unused, |
| 52994 | .unused, |
| 52995 | }, |
| 52996 | .dst_temps = .{.mem}, |
| 52997 | .each = .{ .once = &.{ |
| 52998 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52999 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 53000 | .{ ._, .fi_p, .stt, .tmp2d, ._, ._, ._ }, |
| 53001 | .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ }, |
| 53002 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 53003 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 53004 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53005 | } }, |
| 53006 | }, .{ |
| 53007 | .required_features = .{ .avx, null, null, null }, |
| 53008 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53009 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 53010 | .patterns = &.{ |
| 53011 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53012 | }, |
| 53013 | .call_frame = .{ .alignment = .@"16" }, |
| 53014 | .extra_temps = .{ |
| 53015 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53016 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53017 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 53018 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 53019 | .unused, |
| 53020 | .unused, |
| 53021 | .unused, |
| 53022 | .unused, |
| 53023 | .unused, |
| 53024 | }, |
| 53025 | .dst_temps = .{.mem}, |
| 53026 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53027 | .each = .{ .once = &.{ |
| 53028 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53029 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53030 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53031 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 53032 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 53033 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53034 | } }, |
| 53035 | }, .{ |
| 53036 | .required_features = .{ .sse2, null, null, null }, |
| 53037 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53038 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 53039 | .patterns = &.{ |
| 53040 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53041 | }, |
| 53042 | .call_frame = .{ .alignment = .@"16" }, |
| 53043 | .extra_temps = .{ |
| 53044 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53045 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53046 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 53047 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 53048 | .unused, |
| 53049 | .unused, |
| 53050 | .unused, |
| 53051 | .unused, |
| 53052 | .unused, |
| 53053 | }, |
| 53054 | .dst_temps = .{.mem}, |
| 53055 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53056 | .each = .{ .once = &.{ |
| 53057 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53058 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53059 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53060 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 53061 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 53062 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53063 | } }, |
| 53064 | }, .{ |
| 53065 | .required_features = .{ .sse, null, null, null }, |
| 53066 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53067 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 53068 | .patterns = &.{ |
| 53069 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53070 | }, |
| 53071 | .call_frame = .{ .alignment = .@"16" }, |
| 53072 | .extra_temps = .{ |
| 53073 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53074 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53075 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 53076 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 53077 | .unused, |
| 53078 | .unused, |
| 53079 | .unused, |
| 53080 | .unused, |
| 53081 | .unused, |
| 53082 | }, |
| 53083 | .dst_temps = .{.mem}, |
| 53084 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53085 | .each = .{ .once = &.{ |
| 53086 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53087 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53088 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53089 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53090 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 53091 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 53092 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53093 | } }, |
| 53094 | }, .{ |
| 53095 | .required_features = .{ .avx, null, null, null }, |
| 53096 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 53097 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }}, |
| 53098 | .patterns = &.{ |
| 53099 | .{ .src = .{ .mem, .none, .none } }, |
| 53100 | .{ .src = .{ .to_sse, .none, .none } }, |
| 53101 | }, |
| 53102 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 53103 | .each = .{ .once = &.{ |
| 53104 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 53105 | } }, |
| 53106 | }, .{ |
| 53107 | .required_features = .{ .sse2, null, null, null }, |
| 53108 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 53109 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }}, |
| 53110 | .patterns = &.{ |
| 53111 | .{ .src = .{ .mem, .none, .none } }, |
| 53112 | .{ .src = .{ .to_sse, .none, .none } }, |
| 53113 | }, |
| 53114 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 53115 | .each = .{ .once = &.{ |
| 53116 | .{ ._, ._, .cvttpd2dq, .dst0x, .src0x, ._, ._ }, |
| 53117 | } }, |
| 53118 | }, .{ |
| 53119 | .required_features = .{ .avx, null, null, null }, |
| 53120 | .src_constraints = .{ .{ .scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 53121 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 53122 | .patterns = &.{ |
| 53123 | .{ .src = .{ .mem, .none, .none } }, |
| 53124 | .{ .src = .{ .to_sse, .none, .none } }, |
| 53125 | }, |
| 53126 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 53127 | .each = .{ .once = &.{ |
| 53128 | .{ ._, .v_, .cvttpd2dq, .dst0x, .src0y, ._, ._ }, |
| 53129 | } }, |
| 53130 | }, .{ |
| 53131 | .required_features = .{ .avx, null, null, null }, |
| 53132 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }, .any, .any }, |
| 53133 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 53134 | .patterns = &.{ |
| 53135 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53136 | }, |
| 53137 | .extra_temps = .{ |
| 53138 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53139 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 53140 | .unused, |
| 53141 | .unused, |
| 53142 | .unused, |
| 53143 | .unused, |
| 53144 | .unused, |
| 53145 | .unused, |
| 53146 | .unused, |
| 53147 | }, |
| 53148 | .dst_temps = .{.mem}, |
| 53149 | .clobbers = .{ .eflags = true }, |
| 53150 | .each = .{ .once = &.{ |
| 53151 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53152 | .{ .@"0:", .v_, .cvttpd2dq, .tmp1x, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53153 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 53154 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 53155 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53156 | } }, |
| 53157 | }, .{ |
| 53158 | .required_features = .{ .sse2, null, null, null }, |
| 53159 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| 53160 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }}, |
| 53161 | .patterns = &.{ |
| 53162 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53163 | }, |
| 53164 | .extra_temps = .{ |
| 53165 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53166 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 53167 | .unused, |
| 53168 | .unused, |
| 53169 | .unused, |
| 53170 | .unused, |
| 53171 | .unused, |
| 53172 | .unused, |
| 53173 | .unused, |
| 53174 | }, |
| 53175 | .dst_temps = .{.mem}, |
| 53176 | .clobbers = .{ .eflags = true }, |
| 53177 | .each = .{ .once = &.{ |
| 53178 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53179 | .{ .@"0:", ._, .cvttpd2dq, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53180 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 53181 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53182 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53183 | } }, |
| 53184 | }, .{ |
| 53185 | .required_features = .{ .x87, null, null, null }, |
| 53186 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53187 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53188 | .patterns = &.{ |
| 53189 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53190 | }, |
| 53191 | .extra_temps = .{ |
| 53192 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53193 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 53194 | .unused, |
| 53195 | .unused, |
| 53196 | .unused, |
| 53197 | .unused, |
| 53198 | .unused, |
| 53199 | .unused, |
| 53200 | .unused, |
| 53201 | }, |
| 53202 | .dst_temps = .{.mem}, |
| 53203 | .each = .{ .once = &.{ |
| 53204 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53205 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 53206 | .{ ._, .fi_p, .stt, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 53207 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53208 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53209 | } }, |
| 53210 | }, .{ |
| 53211 | .required_features = .{ .x87, null, null, null }, |
| 53212 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53213 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 53214 | .patterns = &.{ |
| 53215 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53216 | }, |
| 53217 | .extra_temps = .{ |
| 53218 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53219 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 53220 | .{ .type = .i64, .kind = .mem }, |
| 53221 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 53222 | .unused, |
| 53223 | .unused, |
| 53224 | .unused, |
| 53225 | .unused, |
| 53226 | .unused, |
| 53227 | }, |
| 53228 | .dst_temps = .{.mem}, |
| 53229 | .each = .{ .once = &.{ |
| 53230 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53231 | .{ .@"0:", .f_, .ld, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 53232 | .{ ._, .fi_p, .stt, .tmp2q, ._, ._, ._ }, |
| 53233 | .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ }, |
| 53234 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53235 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53236 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53237 | } }, |
| 53238 | }, .{ |
| 53239 | .required_features = .{ .avx, null, null, null }, |
| 53240 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53241 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53242 | .patterns = &.{ |
| 53243 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53244 | }, |
| 53245 | .call_frame = .{ .alignment = .@"16" }, |
| 53246 | .extra_temps = .{ |
| 53247 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53248 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53249 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 53250 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 53251 | .unused, |
| 53252 | .unused, |
| 53253 | .unused, |
| 53254 | .unused, |
| 53255 | .unused, |
| 53256 | }, |
| 53257 | .dst_temps = .{.mem}, |
| 53258 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53259 | .each = .{ .once = &.{ |
| 53260 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53261 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53262 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53263 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53264 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53265 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53266 | } }, |
| 53267 | }, .{ |
| 53268 | .required_features = .{ .avx, null, null, null }, |
| 53269 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53270 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 53271 | .patterns = &.{ |
| 53272 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53273 | }, |
| 53274 | .call_frame = .{ .alignment = .@"16" }, |
| 53275 | .extra_temps = .{ |
| 53276 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53277 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53278 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfsi" } } }, |
| 53279 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 53280 | .unused, |
| 53281 | .unused, |
| 53282 | .unused, |
| 53283 | .unused, |
| 53284 | .unused, |
| 53285 | }, |
| 53286 | .dst_temps = .{.mem}, |
| 53287 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53288 | .each = .{ .once = &.{ |
| 53289 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53290 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53291 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53292 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53293 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53294 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53295 | } }, |
| 53296 | }, .{ |
| 53297 | .required_features = .{ .sse2, null, null, null }, |
| 53298 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53299 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53300 | .patterns = &.{ |
| 53301 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53302 | }, |
| 53303 | .call_frame = .{ .alignment = .@"16" }, |
| 53304 | .extra_temps = .{ |
| 53305 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53306 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53307 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 53308 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 53309 | .unused, |
| 53310 | .unused, |
| 53311 | .unused, |
| 53312 | .unused, |
| 53313 | .unused, |
| 53314 | }, |
| 53315 | .dst_temps = .{.mem}, |
| 53316 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53317 | .each = .{ .once = &.{ |
| 53318 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53319 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53320 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53321 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53322 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53323 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53324 | } }, |
| 53325 | }, .{ |
| 53326 | .required_features = .{ .sse2, null, null, null }, |
| 53327 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53328 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 53329 | .patterns = &.{ |
| 53330 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53331 | }, |
| 53332 | .call_frame = .{ .alignment = .@"16" }, |
| 53333 | .extra_temps = .{ |
| 53334 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53335 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53336 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfsi" } } }, |
| 53337 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 53338 | .unused, |
| 53339 | .unused, |
| 53340 | .unused, |
| 53341 | .unused, |
| 53342 | .unused, |
| 53343 | }, |
| 53344 | .dst_temps = .{.mem}, |
| 53345 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53346 | .each = .{ .once = &.{ |
| 53347 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53348 | .{ .@"0:", ._sd, .mov, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53349 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53350 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53351 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53352 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53353 | } }, |
| 53354 | }, .{ |
| 53355 | .required_features = .{ .sse, null, null, null }, |
| 53356 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53357 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53358 | .patterns = &.{ |
| 53359 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53360 | }, |
| 53361 | .call_frame = .{ .alignment = .@"16" }, |
| 53362 | .extra_temps = .{ |
| 53363 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53364 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53365 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfsi" } } }, |
| 53366 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 53367 | .unused, |
| 53368 | .unused, |
| 53369 | .unused, |
| 53370 | .unused, |
| 53371 | .unused, |
| 53372 | }, |
| 53373 | .dst_temps = .{.mem}, |
| 53374 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53375 | .each = .{ .once = &.{ |
| 53376 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53377 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53378 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53379 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53380 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53381 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53383 | } }, |
| 53384 | }, .{ |
| 53385 | .required_features = .{ .sse, null, null, null }, |
| 53386 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53387 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 53388 | .patterns = &.{ |
| 53389 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53390 | }, |
| 53391 | .call_frame = .{ .alignment = .@"16" }, |
| 53392 | .extra_temps = .{ |
| 53393 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53394 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53395 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfsi" } } }, |
| 53396 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 53397 | .unused, |
| 53398 | .unused, |
| 53399 | .unused, |
| 53400 | .unused, |
| 53401 | .unused, |
| 53402 | }, |
| 53403 | .dst_temps = .{.mem}, |
| 53404 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53405 | .each = .{ .once = &.{ |
| 53406 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 53407 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53408 | .{ ._, ._ps, .movl, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 53409 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53410 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 53411 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 53412 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53413 | } }, |
| 53414 | }, .{ |
| 53415 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 53416 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53417 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 53418 | .patterns = &.{ |
| 53419 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53420 | }, |
| 53421 | .extra_temps = .{ |
| 53422 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53423 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 53424 | .unused, |
| 53425 | .unused, |
| 53426 | .unused, |
| 53427 | .unused, |
| 53428 | .unused, |
| 53429 | .unused, |
| 53430 | .unused, |
| 53431 | }, |
| 53432 | .dst_temps = .{.mem}, |
| 53433 | .clobbers = .{ .eflags = true }, |
| 53434 | .each = .{ .once = &.{ |
| 53435 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53436 | .{ .@"0:", .v_, .cvttsd2si, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53437 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 53438 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53439 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53440 | } }, |
| 53441 | }, .{ |
| 53442 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 53443 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53444 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 53445 | .patterns = &.{ |
| 53446 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53447 | }, |
| 53448 | .extra_temps = .{ |
| 53449 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53450 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 53451 | .unused, |
| 53452 | .unused, |
| 53453 | .unused, |
| 53454 | .unused, |
| 53455 | .unused, |
| 53456 | .unused, |
| 53457 | .unused, |
| 53458 | }, |
| 53459 | .dst_temps = .{.mem}, |
| 53460 | .clobbers = .{ .eflags = true }, |
| 53461 | .each = .{ .once = &.{ |
| 53462 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53463 | .{ .@"0:", ._, .cvttsd2si, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53464 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 53465 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53466 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53467 | } }, |
| 53468 | }, .{ |
| 53469 | .required_features = .{ .x87, null, null, null }, |
| 53470 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53471 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 53472 | .patterns = &.{ |
| 53473 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53474 | }, |
| 53475 | .extra_temps = .{ |
| 53476 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53477 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 53478 | .unused, |
| 53479 | .unused, |
| 53480 | .unused, |
| 53481 | .unused, |
| 53482 | .unused, |
| 53483 | .unused, |
| 53484 | .unused, |
| 53485 | }, |
| 53486 | .dst_temps = .{.mem}, |
| 53487 | .each = .{ .once = &.{ |
| 53488 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53489 | .{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 53490 | .{ ._, .fi_p, .stt, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 53491 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53492 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53493 | } }, |
| 53494 | }, .{ |
| 53495 | .required_features = .{ .avx, null, null, null }, |
| 53496 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53497 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 53498 | .patterns = &.{ |
| 53499 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53500 | }, |
| 53501 | .call_frame = .{ .alignment = .@"16" }, |
| 53502 | .extra_temps = .{ |
| 53503 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53504 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53505 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfdi" } } }, |
| 53506 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 53507 | .unused, |
| 53508 | .unused, |
| 53509 | .unused, |
| 53510 | .unused, |
| 53511 | .unused, |
| 53512 | }, |
| 53513 | .dst_temps = .{.mem}, |
| 53514 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53515 | .each = .{ .once = &.{ |
| 53516 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53517 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53518 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53519 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53520 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53521 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53522 | } }, |
| 53523 | }, .{ |
| 53524 | .required_features = .{ .avx, null, null, null }, |
| 53525 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53526 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 53527 | .patterns = &.{ |
| 53528 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53529 | }, |
| 53530 | .call_frame = .{ .alignment = .@"16" }, |
| 53531 | .extra_temps = .{ |
| 53532 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53533 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53534 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfdi" } } }, |
| 53535 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53536 | .unused, |
| 53537 | .unused, |
| 53538 | .unused, |
| 53539 | .unused, |
| 53540 | .unused, |
| 53541 | }, |
| 53542 | .dst_temps = .{.mem}, |
| 53543 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53544 | .each = .{ .once = &.{ |
| 53545 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53546 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53547 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53548 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53549 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53550 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53551 | } }, |
| 53552 | }, .{ |
| 53553 | .required_features = .{ .sse2, null, null, null }, |
| 53554 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53555 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 53556 | .patterns = &.{ |
| 53557 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53558 | }, |
| 53559 | .call_frame = .{ .alignment = .@"16" }, |
| 53560 | .extra_temps = .{ |
| 53561 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53562 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53563 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfdi" } } }, |
| 53564 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 53565 | .unused, |
| 53566 | .unused, |
| 53567 | .unused, |
| 53568 | .unused, |
| 53569 | .unused, |
| 53570 | }, |
| 53571 | .dst_temps = .{.mem}, |
| 53572 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53573 | .each = .{ .once = &.{ |
| 53574 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53575 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53576 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53577 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53578 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53579 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53580 | } }, |
| 53581 | }, .{ |
| 53582 | .required_features = .{ .sse2, null, null, null }, |
| 53583 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53584 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 53585 | .patterns = &.{ |
| 53586 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53587 | }, |
| 53588 | .call_frame = .{ .alignment = .@"16" }, |
| 53589 | .extra_temps = .{ |
| 53590 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53591 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53592 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfdi" } } }, |
| 53593 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53594 | .unused, |
| 53595 | .unused, |
| 53596 | .unused, |
| 53597 | .unused, |
| 53598 | .unused, |
| 53599 | }, |
| 53600 | .dst_temps = .{.mem}, |
| 53601 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53602 | .each = .{ .once = &.{ |
| 53603 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53604 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53605 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53606 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53607 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53608 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53609 | } }, |
| 53610 | }, .{ |
| 53611 | .required_features = .{ .sse, null, null, null }, |
| 53612 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53613 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 53614 | .patterns = &.{ |
| 53615 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53616 | }, |
| 53617 | .call_frame = .{ .alignment = .@"16" }, |
| 53618 | .extra_temps = .{ |
| 53619 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53620 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53621 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfdi" } } }, |
| 53622 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 53623 | .unused, |
| 53624 | .unused, |
| 53625 | .unused, |
| 53626 | .unused, |
| 53627 | .unused, |
| 53628 | }, |
| 53629 | .dst_temps = .{.mem}, |
| 53630 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53631 | .each = .{ .once = &.{ |
| 53632 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53633 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53634 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53635 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53636 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53637 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53638 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53639 | } }, |
| 53640 | }, .{ |
| 53641 | .required_features = .{ .sse, null, null, null }, |
| 53642 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53643 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 53644 | .patterns = &.{ |
| 53645 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53646 | }, |
| 53647 | .call_frame = .{ .alignment = .@"16" }, |
| 53648 | .extra_temps = .{ |
| 53649 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53650 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53651 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfdi" } } }, |
| 53652 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53653 | .unused, |
| 53654 | .unused, |
| 53655 | .unused, |
| 53656 | .unused, |
| 53657 | .unused, |
| 53658 | }, |
| 53659 | .dst_temps = .{.mem}, |
| 53660 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53661 | .each = .{ .once = &.{ |
| 53662 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53663 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53664 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53665 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53666 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53667 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53668 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53669 | } }, |
| 53670 | }, .{ |
| 53671 | .required_features = .{ .avx, null, null, null }, |
| 53672 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53673 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 53674 | .patterns = &.{ |
| 53675 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53676 | }, |
| 53677 | .call_frame = .{ .alignment = .@"16" }, |
| 53678 | .extra_temps = .{ |
| 53679 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53680 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53681 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } }, |
| 53682 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53683 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 53684 | .unused, |
| 53685 | .unused, |
| 53686 | .unused, |
| 53687 | .unused, |
| 53688 | }, |
| 53689 | .dst_temps = .{.mem}, |
| 53690 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53691 | .each = .{ .once = &.{ |
| 53692 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53693 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53694 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53695 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53696 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 53697 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53698 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53699 | } }, |
| 53700 | }, .{ |
| 53701 | .required_features = .{ .avx, null, null, null }, |
| 53702 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53703 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 53704 | .patterns = &.{ |
| 53705 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53706 | }, |
| 53707 | .call_frame = .{ .alignment = .@"16" }, |
| 53708 | .extra_temps = .{ |
| 53709 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53710 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53711 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } }, |
| 53712 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53713 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 53714 | .unused, |
| 53715 | .unused, |
| 53716 | .unused, |
| 53717 | .unused, |
| 53718 | }, |
| 53719 | .dst_temps = .{.mem}, |
| 53720 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53721 | .each = .{ .once = &.{ |
| 53722 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53723 | .{ .@"0:", .v_sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53724 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53725 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53726 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 53727 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53728 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53729 | } }, |
| 53730 | }, .{ |
| 53731 | .required_features = .{ .sse2, null, null, null }, |
| 53732 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53733 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 53734 | .patterns = &.{ |
| 53735 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53736 | }, |
| 53737 | .call_frame = .{ .alignment = .@"16" }, |
| 53738 | .extra_temps = .{ |
| 53739 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53740 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53741 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } }, |
| 53742 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53743 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 53744 | .unused, |
| 53745 | .unused, |
| 53746 | .unused, |
| 53747 | .unused, |
| 53748 | }, |
| 53749 | .dst_temps = .{.mem}, |
| 53750 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53751 | .each = .{ .once = &.{ |
| 53752 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53753 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53754 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53755 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53756 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 53757 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53758 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53759 | } }, |
| 53760 | }, .{ |
| 53761 | .required_features = .{ .sse2, null, null, null }, |
| 53762 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53763 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 53764 | .patterns = &.{ |
| 53765 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53766 | }, |
| 53767 | .call_frame = .{ .alignment = .@"16" }, |
| 53768 | .extra_temps = .{ |
| 53769 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53770 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53771 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } }, |
| 53772 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53773 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 53774 | .unused, |
| 53775 | .unused, |
| 53776 | .unused, |
| 53777 | .unused, |
| 53778 | }, |
| 53779 | .dst_temps = .{.mem}, |
| 53780 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53781 | .each = .{ .once = &.{ |
| 53782 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53783 | .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53784 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53785 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53786 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 53787 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53788 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53789 | } }, |
| 53790 | }, .{ |
| 53791 | .required_features = .{ .sse, null, null, null }, |
| 53792 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53793 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 53794 | .patterns = &.{ |
| 53795 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53796 | }, |
| 53797 | .call_frame = .{ .alignment = .@"16" }, |
| 53798 | .extra_temps = .{ |
| 53799 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53800 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53801 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } }, |
| 53802 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53803 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 53804 | .unused, |
| 53805 | .unused, |
| 53806 | .unused, |
| 53807 | .unused, |
| 53808 | }, |
| 53809 | .dst_temps = .{.mem}, |
| 53810 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53811 | .each = .{ .once = &.{ |
| 53812 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53813 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53814 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53815 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53816 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53817 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 53818 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53819 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53820 | } }, |
| 53821 | }, .{ |
| 53822 | .required_features = .{ .sse, null, null, null }, |
| 53823 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53824 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 53825 | .patterns = &.{ |
| 53826 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53827 | }, |
| 53828 | .call_frame = .{ .alignment = .@"16" }, |
| 53829 | .extra_temps = .{ |
| 53830 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53831 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53832 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } }, |
| 53833 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 53834 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 53835 | .unused, |
| 53836 | .unused, |
| 53837 | .unused, |
| 53838 | .unused, |
| 53839 | }, |
| 53840 | .dst_temps = .{.mem}, |
| 53841 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53842 | .each = .{ .once = &.{ |
| 53843 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53844 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 53845 | .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53846 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 53847 | .{ ._, ._, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 53848 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"2", .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 53849 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53850 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53851 | } }, |
| 53852 | }, .{ |
| 53853 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 53854 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53855 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53856 | .patterns = &.{ |
| 53857 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53858 | }, |
| 53859 | .call_frame = .{ .alignment = .@"16" }, |
| 53860 | .extra_temps = .{ |
| 53861 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53862 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 53863 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 53864 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 53865 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53866 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } }, |
| 53867 | .unused, |
| 53868 | .unused, |
| 53869 | .unused, |
| 53870 | }, |
| 53871 | .dst_temps = .{.mem}, |
| 53872 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53873 | .each = .{ .once = &.{ |
| 53874 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53875 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 53876 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 53877 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 53878 | .{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53879 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 53880 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 53881 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53882 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53883 | } }, |
| 53884 | }, .{ |
| 53885 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 53886 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53887 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 53888 | .patterns = &.{ |
| 53889 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53890 | }, |
| 53891 | .call_frame = .{ .alignment = .@"16" }, |
| 53892 | .extra_temps = .{ |
| 53893 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53894 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 53895 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 53896 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 53897 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53898 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } }, |
| 53899 | .unused, |
| 53900 | .unused, |
| 53901 | .unused, |
| 53902 | }, |
| 53903 | .dst_temps = .{.mem}, |
| 53904 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53905 | .each = .{ .once = &.{ |
| 53906 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53907 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 53908 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 53909 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 53910 | .{ ._, .v_sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53911 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 53912 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 53913 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53914 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53915 | } }, |
| 53916 | }, .{ |
| 53917 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 53918 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53919 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53920 | .patterns = &.{ |
| 53921 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53922 | }, |
| 53923 | .call_frame = .{ .alignment = .@"16" }, |
| 53924 | .extra_temps = .{ |
| 53925 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53926 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 53927 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 53928 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 53929 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53930 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } }, |
| 53931 | .unused, |
| 53932 | .unused, |
| 53933 | .unused, |
| 53934 | }, |
| 53935 | .dst_temps = .{.mem}, |
| 53936 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53937 | .each = .{ .once = &.{ |
| 53938 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53939 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 53940 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 53941 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 53942 | .{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53943 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 53944 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 53945 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53946 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53947 | } }, |
| 53948 | }, .{ |
| 53949 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 53950 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53951 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 53952 | .patterns = &.{ |
| 53953 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53954 | }, |
| 53955 | .call_frame = .{ .alignment = .@"16" }, |
| 53956 | .extra_temps = .{ |
| 53957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 53959 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 53960 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 53961 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53962 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } }, |
| 53963 | .unused, |
| 53964 | .unused, |
| 53965 | .unused, |
| 53966 | }, |
| 53967 | .dst_temps = .{.mem}, |
| 53968 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 53969 | .each = .{ .once = &.{ |
| 53970 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 53971 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 53972 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 53973 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 53974 | .{ ._, ._sd, .mov, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 53975 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 53976 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 53977 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 53978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 53979 | } }, |
| 53980 | }, .{ |
| 53981 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 53982 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 53983 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 53984 | .patterns = &.{ |
| 53985 | .{ .src = .{ .to_mem, .none, .none } }, |
| 53986 | }, |
| 53987 | .call_frame = .{ .alignment = .@"16" }, |
| 53988 | .extra_temps = .{ |
| 53989 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 53990 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 53991 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 53992 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 53993 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 53994 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } }, |
| 53995 | .unused, |
| 53996 | .unused, |
| 53997 | .unused, |
| 53998 | }, |
| 53999 | .dst_temps = .{.mem}, |
| 54000 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54001 | .each = .{ .once = &.{ |
| 54002 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54003 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 54004 | .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 54005 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 54006 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 54007 | .{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54008 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 54009 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 54010 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 54011 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54012 | } }, |
| 54013 | }, .{ |
| 54014 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 54015 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 54016 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 54017 | .patterns = &.{ |
| 54018 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54019 | }, |
| 54020 | .call_frame = .{ .alignment = .@"16" }, |
| 54021 | .extra_temps = .{ |
| 54022 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54023 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 54024 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 54025 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 54026 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 54027 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } }, |
| 54028 | .unused, |
| 54029 | .unused, |
| 54030 | .unused, |
| 54031 | }, |
| 54032 | .dst_temps = .{.mem}, |
| 54033 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54034 | .each = .{ .once = &.{ |
| 54035 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54036 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 54037 | .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 54038 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 54039 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 54040 | .{ ._, ._ps, .movl, .tmp4x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54041 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 54042 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 54043 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 54044 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54045 | } }, |
| 54046 | }, .{ |
| 54047 | .required_features = .{ .x87, null, null, null }, |
| 54048 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54049 | .dst_constraints = .{.{ .signed_int = .byte }}, |
| 54050 | .patterns = &.{ |
| 54051 | .{ .src = .{ .mem, .none, .none } }, |
| 54052 | .{ .src = .{ .to_x87, .none, .none } }, |
| 54053 | }, |
| 54054 | .extra_temps = .{ |
| 54055 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 54056 | .{ .type = .i16, .kind = .mem }, |
| 54057 | .unused, |
| 54058 | .unused, |
| 54059 | .unused, |
| 54060 | .unused, |
| 54061 | .unused, |
| 54062 | .unused, |
| 54063 | .unused, |
| 54064 | }, |
| 54065 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 54066 | .each = .{ .once = &.{ |
| 54067 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 54068 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 54069 | .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ }, |
| 54070 | } }, |
| 54071 | }, .{ |
| 54072 | .required_features = .{ .x87, null, null, null }, |
| 54073 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54074 | .dst_constraints = .{.{ .unsigned_int = .byte }}, |
| 54075 | .patterns = &.{ |
| 54076 | .{ .src = .{ .mem, .none, .none } }, |
| 54077 | .{ .src = .{ .to_x87, .none, .none } }, |
| 54078 | }, |
| 54079 | .extra_temps = .{ |
| 54080 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 54081 | .{ .type = .i16, .kind = .mem }, |
| 54082 | .unused, |
| 54083 | .unused, |
| 54084 | .unused, |
| 54085 | .unused, |
| 54086 | .unused, |
| 54087 | .unused, |
| 54088 | .unused, |
| 54089 | }, |
| 54090 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 54091 | .each = .{ .once = &.{ |
| 54092 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 54093 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, |
| 54094 | .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ }, |
| 54095 | } }, |
| 54096 | }, .{ |
| 54097 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 54098 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54099 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 54100 | .patterns = &.{ |
| 54101 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54102 | }, |
| 54103 | .extra_temps = .{ |
| 54104 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 54105 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54106 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54107 | .{ .type = .i16, .kind = .mem }, |
| 54108 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 54109 | .unused, |
| 54110 | .unused, |
| 54111 | .unused, |
| 54112 | .unused, |
| 54113 | }, |
| 54114 | .dst_temps = .{.mem}, |
| 54115 | .clobbers = .{ .eflags = true }, |
| 54116 | .each = .{ .once = &.{ |
| 54117 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 54118 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54119 | .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, |
| 54120 | .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, |
| 54121 | .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ }, |
| 54122 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 54123 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 54124 | .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, |
| 54125 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54126 | } }, |
| 54127 | }, .{ |
| 54128 | .required_features = .{ .x87, null, null, null }, |
| 54129 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54130 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }}, |
| 54131 | .patterns = &.{ |
| 54132 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54133 | }, |
| 54134 | .extra_temps = .{ |
| 54135 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 54136 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54137 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54138 | .{ .type = .i16, .kind = .mem }, |
| 54139 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 54140 | .unused, |
| 54141 | .unused, |
| 54142 | .unused, |
| 54143 | .unused, |
| 54144 | }, |
| 54145 | .dst_temps = .{.mem}, |
| 54146 | .clobbers = .{ .eflags = true }, |
| 54147 | .each = .{ .once = &.{ |
| 54148 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 54149 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54150 | .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, |
| 54151 | .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, |
| 54152 | .{ ._, ._, .movsx, .tmp4d, .tmp3b, ._, ._ }, |
| 54153 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 54154 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 54155 | .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, |
| 54156 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 54157 | } }, |
| 54158 | }, .{ |
| 54159 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 54160 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54161 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 54162 | .patterns = &.{ |
| 54163 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54164 | }, |
| 54165 | .extra_temps = .{ |
| 54166 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 54167 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54168 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54169 | .{ .type = .i16, .kind = .mem }, |
| 54170 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 54171 | .unused, |
| 54172 | .unused, |
| 54173 | .unused, |
| 54174 | .unused, |
| 54175 | }, |
| 54176 | .dst_temps = .{.mem}, |
| 54177 | .clobbers = .{ .eflags = true }, |
| 54178 | .each = .{ .once = &.{ |
| 54179 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 54180 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54181 | .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, |
| 54182 | .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, |
| 54183 | .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ }, |
| 54184 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 54185 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 54186 | .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, |
| 54187 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54188 | } }, |
| 54189 | }, .{ |
| 54190 | .required_features = .{ .x87, null, null, null }, |
| 54191 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54192 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }}, |
| 54193 | .patterns = &.{ |
| 54194 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54195 | }, |
| 54196 | .extra_temps = .{ |
| 54197 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 54198 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54199 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54200 | .{ .type = .i16, .kind = .mem }, |
| 54201 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 54202 | .unused, |
| 54203 | .unused, |
| 54204 | .unused, |
| 54205 | .unused, |
| 54206 | }, |
| 54207 | .dst_temps = .{.mem}, |
| 54208 | .clobbers = .{ .eflags = true }, |
| 54209 | .each = .{ .once = &.{ |
| 54210 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 54211 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54212 | .{ .@"0:", .f_, .ld, .lea(.tmp0t), ._, ._, ._ }, |
| 54213 | .{ ._, .fi_p, .stt, .tmp3w, ._, ._, ._ }, |
| 54214 | .{ ._, ._, .movzx, .tmp4d, .tmp3b, ._, ._ }, |
| 54215 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 54216 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 54217 | .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, |
| 54218 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 54219 | } }, |
| 54220 | }, .{ |
| 54221 | .required_features = .{ .x87, null, null, null }, |
| 54222 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54223 | .dst_constraints = .{.{ .signed_or_exclusive_int = .word }}, |
| 54224 | .patterns = &.{ |
| 54225 | .{ .src = .{ .mem, .none, .none } }, |
| 54226 | .{ .src = .{ .to_x87, .none, .none } }, |
| 54227 | }, |
| 54228 | .extra_temps = .{ |
| 54229 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54230 | .unused, |
| 54231 | .unused, |
| 54232 | .unused, |
| 54233 | .unused, |
| 54234 | .unused, |
| 54235 | .unused, |
| 54236 | .unused, |
| 54237 | .unused, |
| 54238 | }, |
| 54239 | .dst_temps = .{.mem}, |
| 54240 | .each = .{ .once = &.{ |
| 54241 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 54242 | .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ }, |
| 54243 | } }, |
| 54244 | }, .{ |
| 54245 | .required_features = .{ .x87, null, null, null }, |
| 54246 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54247 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }}, |
| 54248 | .patterns = &.{ |
| 54249 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54250 | }, |
| 54251 | .extra_temps = .{ |
| 54252 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54253 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54254 | .unused, |
| 54255 | .unused, |
| 54256 | .unused, |
| 54257 | .unused, |
| 54258 | .unused, |
| 54259 | .unused, |
| 54260 | .unused, |
| 54261 | }, |
| 54262 | .dst_temps = .{.mem}, |
| 54263 | .clobbers = .{ .eflags = true }, |
| 54264 | .each = .{ .once = &.{ |
| 54265 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54266 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54267 | .{ ._, .fi_p, .stt, .memia(.dst0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54268 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 54269 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54270 | } }, |
| 54271 | }, .{ |
| 54272 | .required_features = .{ .x87, null, null, null }, |
| 54273 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54274 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }}, |
| 54275 | .patterns = &.{ |
| 54276 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54277 | }, |
| 54278 | .extra_temps = .{ |
| 54279 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54280 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54281 | .{ .type = .i32, .kind = .mem }, |
| 54282 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 54283 | .unused, |
| 54284 | .unused, |
| 54285 | .unused, |
| 54286 | .unused, |
| 54287 | .unused, |
| 54288 | }, |
| 54289 | .dst_temps = .{.mem}, |
| 54290 | .clobbers = .{ .eflags = true }, |
| 54291 | .each = .{ .once = &.{ |
| 54292 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54293 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54294 | .{ ._, .fi_p, .stt, .tmp2d, ._, ._, ._ }, |
| 54295 | .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ }, |
| 54296 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 54297 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 54298 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54299 | } }, |
| 54300 | }, .{ |
| 54301 | .required_features = .{ .x87, null, null, null }, |
| 54302 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54303 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 54304 | .patterns = &.{ |
| 54305 | .{ .src = .{ .mem, .none, .none } }, |
| 54306 | .{ .src = .{ .to_x87, .none, .none } }, |
| 54307 | }, |
| 54308 | .extra_temps = .{ |
| 54309 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54310 | .unused, |
| 54311 | .unused, |
| 54312 | .unused, |
| 54313 | .unused, |
| 54314 | .unused, |
| 54315 | .unused, |
| 54316 | .unused, |
| 54317 | .unused, |
| 54318 | }, |
| 54319 | .dst_temps = .{.mem}, |
| 54320 | .each = .{ .once = &.{ |
| 54321 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 54322 | .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ }, |
| 54323 | } }, |
| 54324 | }, .{ |
| 54325 | .required_features = .{ .x87, null, null, null }, |
| 54326 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54327 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 54328 | .patterns = &.{ |
| 54329 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54330 | }, |
| 54331 | .extra_temps = .{ |
| 54332 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54333 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54334 | .unused, |
| 54335 | .unused, |
| 54336 | .unused, |
| 54337 | .unused, |
| 54338 | .unused, |
| 54339 | .unused, |
| 54340 | .unused, |
| 54341 | }, |
| 54342 | .dst_temps = .{.mem}, |
| 54343 | .clobbers = .{ .eflags = true }, |
| 54344 | .each = .{ .once = &.{ |
| 54345 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54346 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54347 | .{ ._, .fi_p, .stt, .memia(.dst0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54348 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 54349 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54350 | } }, |
| 54351 | }, .{ |
| 54352 | .required_features = .{ .x87, null, null, null }, |
| 54353 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54354 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 54355 | .patterns = &.{ |
| 54356 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54357 | }, |
| 54358 | .extra_temps = .{ |
| 54359 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54360 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54361 | .{ .type = .i64, .kind = .mem }, |
| 54362 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 54363 | .unused, |
| 54364 | .unused, |
| 54365 | .unused, |
| 54366 | .unused, |
| 54367 | .unused, |
| 54368 | }, |
| 54369 | .dst_temps = .{.mem}, |
| 54370 | .clobbers = .{ .eflags = true }, |
| 54371 | .each = .{ .once = &.{ |
| 54372 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54373 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54374 | .{ ._, .fi_p, .stt, .tmp2q, ._, ._, ._ }, |
| 54375 | .{ ._, ._, .mov, .tmp3d, .tmp2d, ._, ._ }, |
| 54376 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 54377 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 54378 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54379 | } }, |
| 54380 | }, .{ |
| 54381 | .required_features = .{ .x87, null, null, null }, |
| 54382 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54383 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 54384 | .patterns = &.{ |
| 54385 | .{ .src = .{ .mem, .none, .none } }, |
| 54386 | .{ .src = .{ .to_x87, .none, .none } }, |
| 54387 | }, |
| 54388 | .extra_temps = .{ |
| 54389 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54390 | .unused, |
| 54391 | .unused, |
| 54392 | .unused, |
| 54393 | .unused, |
| 54394 | .unused, |
| 54395 | .unused, |
| 54396 | .unused, |
| 54397 | .unused, |
| 54398 | }, |
| 54399 | .dst_temps = .{.mem}, |
| 54400 | .each = .{ .once = &.{ |
| 54401 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 54402 | .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ }, |
| 54403 | } }, |
| 54404 | }, .{ |
| 54405 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 54406 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54407 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 54408 | .patterns = &.{ |
| 54409 | .{ .src = .{ .mem, .none, .none } }, |
| 54410 | .{ .src = .{ .to_x87, .none, .none } }, |
| 54411 | }, |
| 54412 | .extra_temps = .{ |
| 54413 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 54414 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 54415 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, |
| 54416 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 54417 | .{ .type = .i64, .kind = .mem }, |
| 54418 | .unused, |
| 54419 | .unused, |
| 54420 | .unused, |
| 54421 | .unused, |
| 54422 | }, |
| 54423 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 54424 | .clobbers = .{ .eflags = true }, |
| 54425 | .each = .{ .once = &.{ |
| 54426 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, |
| 54427 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 54428 | .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ }, |
| 54429 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 54430 | .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ }, |
| 54431 | .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ }, |
| 54432 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 54433 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, |
| 54434 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 54435 | .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, |
| 54436 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 54437 | } }, |
| 54438 | }, .{ |
| 54439 | .required_features = .{ .x87, null, null, null }, |
| 54440 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54441 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 54442 | .patterns = &.{ |
| 54443 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54444 | }, |
| 54445 | .extra_temps = .{ |
| 54446 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54447 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 54448 | .unused, |
| 54449 | .unused, |
| 54450 | .unused, |
| 54451 | .unused, |
| 54452 | .unused, |
| 54453 | .unused, |
| 54454 | .unused, |
| 54455 | }, |
| 54456 | .dst_temps = .{.mem}, |
| 54457 | .clobbers = .{ .eflags = true }, |
| 54458 | .each = .{ .once = &.{ |
| 54459 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54460 | .{ .@"0:", .f_, .ld, .memsia(.src0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54461 | .{ ._, .fi_p, .stt, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 54462 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 54463 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54464 | } }, |
| 54465 | }, .{ |
| 54466 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54467 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54468 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 54469 | .patterns = &.{ |
| 54470 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54471 | }, |
| 54472 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54473 | .extra_temps = .{ |
| 54474 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54475 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54476 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54477 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54478 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54479 | .unused, |
| 54480 | .unused, |
| 54481 | .unused, |
| 54482 | .unused, |
| 54483 | }, |
| 54484 | .dst_temps = .{.mem}, |
| 54485 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54486 | .each = .{ .once = &.{ |
| 54487 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54488 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 54489 | .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 54490 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54491 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54492 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 54493 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54494 | } }, |
| 54495 | }, .{ |
| 54496 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54497 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54498 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 54499 | .patterns = &.{ |
| 54500 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54501 | }, |
| 54502 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54503 | .extra_temps = .{ |
| 54504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54505 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54506 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54507 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54508 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54509 | .unused, |
| 54510 | .unused, |
| 54511 | .unused, |
| 54512 | .unused, |
| 54513 | }, |
| 54514 | .dst_temps = .{.mem}, |
| 54515 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54516 | .each = .{ .once = &.{ |
| 54517 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54518 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 54519 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 54520 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54521 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54522 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 54523 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54524 | } }, |
| 54525 | }, .{ |
| 54526 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 54527 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54528 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 54529 | .patterns = &.{ |
| 54530 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54531 | }, |
| 54532 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54533 | .extra_temps = .{ |
| 54534 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54535 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54536 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54537 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54538 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54539 | .unused, |
| 54540 | .unused, |
| 54541 | .unused, |
| 54542 | .unused, |
| 54543 | }, |
| 54544 | .dst_temps = .{.mem}, |
| 54545 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54546 | .each = .{ .once = &.{ |
| 54547 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 54548 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 54549 | .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 54550 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54551 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54552 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 54553 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54554 | } }, |
| 54555 | }, .{ |
| 54556 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54557 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54558 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 54559 | .patterns = &.{ |
| 54560 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54561 | }, |
| 54562 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54563 | .extra_temps = .{ |
| 54564 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54565 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54566 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 54567 | .unused, |
| 54568 | .unused, |
| 54569 | .unused, |
| 54570 | .unused, |
| 54571 | .unused, |
| 54572 | .unused, |
| 54573 | }, |
| 54574 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 54575 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54576 | .each = .{ .once = &.{ |
| 54577 | .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 54578 | .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 54579 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 54580 | } }, |
| 54581 | }, .{ |
| 54582 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54583 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54584 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 54585 | .patterns = &.{ |
| 54586 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54587 | }, |
| 54588 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54589 | .extra_temps = .{ |
| 54590 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54591 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54592 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54593 | .unused, |
| 54594 | .unused, |
| 54595 | .unused, |
| 54596 | .unused, |
| 54597 | .unused, |
| 54598 | .unused, |
| 54599 | }, |
| 54600 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 54601 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54602 | .each = .{ .once = &.{ |
| 54603 | .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 54604 | .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 54605 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 54606 | } }, |
| 54607 | }, .{ |
| 54608 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54609 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54610 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 54611 | .patterns = &.{ |
| 54612 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54613 | }, |
| 54614 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54615 | .extra_temps = .{ |
| 54616 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54617 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54618 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 54619 | .unused, |
| 54620 | .unused, |
| 54621 | .unused, |
| 54622 | .unused, |
| 54623 | .unused, |
| 54624 | .unused, |
| 54625 | }, |
| 54626 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 54627 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54628 | .each = .{ .once = &.{ |
| 54629 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 54630 | .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 54631 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 54632 | } }, |
| 54633 | }, .{ |
| 54634 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54635 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54636 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 54637 | .patterns = &.{ |
| 54638 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54639 | }, |
| 54640 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54641 | .extra_temps = .{ |
| 54642 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54643 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54644 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54645 | .unused, |
| 54646 | .unused, |
| 54647 | .unused, |
| 54648 | .unused, |
| 54649 | .unused, |
| 54650 | .unused, |
| 54651 | }, |
| 54652 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 54653 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54654 | .each = .{ .once = &.{ |
| 54655 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, |
| 54656 | .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, |
| 54657 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 54658 | } }, |
| 54659 | }, .{ |
| 54660 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 54661 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54662 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 54663 | .patterns = &.{ |
| 54664 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54665 | }, |
| 54666 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54667 | .extra_temps = .{ |
| 54668 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54669 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54670 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 54671 | .unused, |
| 54672 | .unused, |
| 54673 | .unused, |
| 54674 | .unused, |
| 54675 | .unused, |
| 54676 | .unused, |
| 54677 | }, |
| 54678 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 54679 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54680 | .each = .{ .once = &.{ |
| 54681 | .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, |
| 54682 | .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ }, |
| 54683 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 54684 | } }, |
| 54685 | }, .{ |
| 54686 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 54687 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54688 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 54689 | .patterns = &.{ |
| 54690 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54691 | }, |
| 54692 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54693 | .extra_temps = .{ |
| 54694 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54695 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54696 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54697 | .unused, |
| 54698 | .unused, |
| 54699 | .unused, |
| 54700 | .unused, |
| 54701 | .unused, |
| 54702 | .unused, |
| 54703 | }, |
| 54704 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 54705 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54706 | .each = .{ .once = &.{ |
| 54707 | .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, |
| 54708 | .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ }, |
| 54709 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 54710 | } }, |
| 54711 | }, .{ |
| 54712 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54713 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54714 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 54715 | .patterns = &.{ |
| 54716 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54717 | }, |
| 54718 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54719 | .extra_temps = .{ |
| 54720 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54721 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54722 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54723 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 54724 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54725 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 54726 | .unused, |
| 54727 | .unused, |
| 54728 | .unused, |
| 54729 | }, |
| 54730 | .dst_temps = .{.mem}, |
| 54731 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54732 | .each = .{ .once = &.{ |
| 54733 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54734 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54735 | .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 54736 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54737 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54738 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 54739 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 54740 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54741 | } }, |
| 54742 | }, .{ |
| 54743 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54744 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54745 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 54746 | .patterns = &.{ |
| 54747 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54748 | }, |
| 54749 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54750 | .extra_temps = .{ |
| 54751 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54752 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54753 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54754 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54755 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54756 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 54757 | .unused, |
| 54758 | .unused, |
| 54759 | .unused, |
| 54760 | }, |
| 54761 | .dst_temps = .{.mem}, |
| 54762 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54763 | .each = .{ .once = &.{ |
| 54764 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54765 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54766 | .{ ._, .v_dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 54767 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54768 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54769 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 54770 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 54771 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54772 | } }, |
| 54773 | }, .{ |
| 54774 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54775 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54776 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 54777 | .patterns = &.{ |
| 54778 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54779 | }, |
| 54780 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54781 | .extra_temps = .{ |
| 54782 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54783 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54784 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54785 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 54786 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54787 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 54788 | .unused, |
| 54789 | .unused, |
| 54790 | .unused, |
| 54791 | }, |
| 54792 | .dst_temps = .{.mem}, |
| 54793 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54794 | .each = .{ .once = &.{ |
| 54795 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54796 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54797 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 54798 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54799 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54800 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 54801 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 54802 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54803 | } }, |
| 54804 | }, .{ |
| 54805 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54806 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54807 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 54808 | .patterns = &.{ |
| 54809 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54810 | }, |
| 54811 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54812 | .extra_temps = .{ |
| 54813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54814 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54815 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54816 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54817 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54818 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 54819 | .unused, |
| 54820 | .unused, |
| 54821 | .unused, |
| 54822 | }, |
| 54823 | .dst_temps = .{.mem}, |
| 54824 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54825 | .each = .{ .once = &.{ |
| 54826 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54827 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54828 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| 54829 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54830 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54831 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 54832 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 54833 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54834 | } }, |
| 54835 | }, .{ |
| 54836 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 54837 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54838 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 54839 | .patterns = &.{ |
| 54840 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54841 | }, |
| 54842 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54843 | .extra_temps = .{ |
| 54844 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54845 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54846 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54847 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, |
| 54848 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54849 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 54850 | .unused, |
| 54851 | .unused, |
| 54852 | .unused, |
| 54853 | }, |
| 54854 | .dst_temps = .{.mem}, |
| 54855 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54856 | .each = .{ .once = &.{ |
| 54857 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54858 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54859 | .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 54860 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54861 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54862 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 54863 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 54864 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54865 | } }, |
| 54866 | }, .{ |
| 54867 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 54868 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 54869 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 54870 | .patterns = &.{ |
| 54871 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54872 | }, |
| 54873 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54874 | .extra_temps = .{ |
| 54875 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 54876 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54877 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54878 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, |
| 54879 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 54880 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 54881 | .unused, |
| 54882 | .unused, |
| 54883 | .unused, |
| 54884 | }, |
| 54885 | .dst_temps = .{.mem}, |
| 54886 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54887 | .each = .{ .once = &.{ |
| 54888 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 54889 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 54890 | .{ ._, ._ps, .mova, .tmp2x, .tmp1x, ._, ._ }, |
| 54891 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 54892 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4q, ._, ._ }, |
| 54893 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp5q, ._, ._ }, |
| 54894 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 54895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 54896 | } }, |
| 54897 | }, .{ |
| 54898 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54899 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54900 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 54901 | .patterns = &.{ |
| 54902 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54903 | }, |
| 54904 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54905 | .extra_temps = .{ |
| 54906 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 54907 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 54908 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54909 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54910 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 54911 | .unused, |
| 54912 | .unused, |
| 54913 | .unused, |
| 54914 | .unused, |
| 54915 | }, |
| 54916 | .dst_temps = .{.mem}, |
| 54917 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54918 | .each = .{ .once = &.{ |
| 54919 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 54920 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 54921 | .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 54922 | .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 54923 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 54924 | } }, |
| 54925 | }, .{ |
| 54926 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 54927 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54928 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 54929 | .patterns = &.{ |
| 54930 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54931 | }, |
| 54932 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54933 | .extra_temps = .{ |
| 54934 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 54935 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 54936 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54937 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54938 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 54939 | .unused, |
| 54940 | .unused, |
| 54941 | .unused, |
| 54942 | .unused, |
| 54943 | }, |
| 54944 | .dst_temps = .{.mem}, |
| 54945 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54946 | .each = .{ .once = &.{ |
| 54947 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 54948 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 54949 | .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 54950 | .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 54951 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 54952 | } }, |
| 54953 | }, .{ |
| 54954 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54955 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54956 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 54957 | .patterns = &.{ |
| 54958 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54959 | }, |
| 54960 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54961 | .extra_temps = .{ |
| 54962 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 54963 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 54964 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54965 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54966 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 54967 | .unused, |
| 54968 | .unused, |
| 54969 | .unused, |
| 54970 | .unused, |
| 54971 | }, |
| 54972 | .dst_temps = .{.mem}, |
| 54973 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 54974 | .each = .{ .once = &.{ |
| 54975 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 54976 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 54977 | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 54978 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 54979 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 54980 | } }, |
| 54981 | }, .{ |
| 54982 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 54983 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 54984 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 54985 | .patterns = &.{ |
| 54986 | .{ .src = .{ .to_mem, .none, .none } }, |
| 54987 | }, |
| 54988 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 54989 | .extra_temps = .{ |
| 54990 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 54991 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 54992 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 54993 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 54994 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 54995 | .unused, |
| 54996 | .unused, |
| 54997 | .unused, |
| 54998 | .unused, |
| 54999 | }, |
| 55000 | .dst_temps = .{.mem}, |
| 55001 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55002 | .each = .{ .once = &.{ |
| 55003 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 55004 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 55005 | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| 55006 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| 55007 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 55008 | } }, |
| 55009 | }, .{ |
| 55010 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55011 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 55012 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55013 | .patterns = &.{ |
| 55014 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55015 | }, |
| 55016 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55017 | .extra_temps = .{ |
| 55018 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55019 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55020 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55021 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55022 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 55023 | .unused, |
| 55024 | .unused, |
| 55025 | .unused, |
| 55026 | .unused, |
| 55027 | }, |
| 55028 | .dst_temps = .{.mem}, |
| 55029 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55030 | .each = .{ .once = &.{ |
| 55031 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 55032 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 55033 | .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ }, |
| 55034 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 55035 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 55036 | } }, |
| 55037 | }, .{ |
| 55038 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55039 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, |
| 55040 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55041 | .patterns = &.{ |
| 55042 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55043 | }, |
| 55044 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55045 | .extra_temps = .{ |
| 55046 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55047 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55048 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55049 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55050 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 55051 | .unused, |
| 55052 | .unused, |
| 55053 | .unused, |
| 55054 | .unused, |
| 55055 | }, |
| 55056 | .dst_temps = .{.mem}, |
| 55057 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55058 | .each = .{ .once = &.{ |
| 55059 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 55060 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 55061 | .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ }, |
| 55062 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, |
| 55063 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 55064 | } }, |
| 55065 | }, .{ |
| 55066 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 55067 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 55068 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55069 | .patterns = &.{ |
| 55070 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55071 | }, |
| 55072 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55073 | .extra_temps = .{ |
| 55074 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55075 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55076 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55077 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55078 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55079 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55080 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 55081 | .unused, |
| 55082 | .unused, |
| 55083 | }, |
| 55084 | .dst_temps = .{.mem}, |
| 55085 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55086 | .each = .{ .once = &.{ |
| 55087 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 55088 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 55089 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 55090 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 55091 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 55092 | .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, |
| 55093 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 55094 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 55095 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 55096 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55097 | } }, |
| 55098 | }, .{ |
| 55099 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 55100 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 55101 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55102 | .patterns = &.{ |
| 55103 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55104 | }, |
| 55105 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55106 | .extra_temps = .{ |
| 55107 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55108 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55109 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55110 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55111 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55112 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55113 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 55114 | .unused, |
| 55115 | .unused, |
| 55116 | }, |
| 55117 | .dst_temps = .{.mem}, |
| 55118 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55119 | .each = .{ .once = &.{ |
| 55120 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 55121 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 55122 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 55123 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 55124 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 55125 | .{ ._, .v_dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, |
| 55126 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 55127 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 55128 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 55129 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55130 | } }, |
| 55131 | }, .{ |
| 55132 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 55133 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 55134 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55135 | .patterns = &.{ |
| 55136 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55137 | }, |
| 55138 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55139 | .extra_temps = .{ |
| 55140 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55141 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55142 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55143 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55144 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55145 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55146 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 55147 | .unused, |
| 55148 | .unused, |
| 55149 | }, |
| 55150 | .dst_temps = .{.mem}, |
| 55151 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55152 | .each = .{ .once = &.{ |
| 55153 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 55154 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 55155 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 55156 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 55157 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 55158 | .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, |
| 55159 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 55160 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 55161 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 55162 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55163 | } }, |
| 55164 | }, .{ |
| 55165 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 55166 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 55167 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55168 | .patterns = &.{ |
| 55169 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55170 | }, |
| 55171 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55172 | .extra_temps = .{ |
| 55173 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55174 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55175 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55176 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55177 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55178 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55179 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 55180 | .unused, |
| 55181 | .unused, |
| 55182 | }, |
| 55183 | .dst_temps = .{.mem}, |
| 55184 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55185 | .each = .{ .once = &.{ |
| 55186 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 55187 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 55188 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 55189 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 55190 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 55191 | .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, |
| 55192 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 55193 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 55194 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 55195 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55196 | } }, |
| 55197 | }, .{ |
| 55198 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55199 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 55200 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55201 | .patterns = &.{ |
| 55202 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55203 | }, |
| 55204 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55205 | .extra_temps = .{ |
| 55206 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55207 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55208 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55209 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55210 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55211 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55212 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, |
| 55213 | .unused, |
| 55214 | .unused, |
| 55215 | }, |
| 55216 | .dst_temps = .{.mem}, |
| 55217 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55218 | .each = .{ .once = &.{ |
| 55219 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 55220 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 55221 | .{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 55222 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 55223 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 55224 | .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ }, |
| 55225 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 55226 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 55227 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 55228 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55229 | } }, |
| 55230 | }, .{ |
| 55231 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55232 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }, .any, .any }, |
| 55233 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55234 | .patterns = &.{ |
| 55235 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55236 | }, |
| 55237 | .call_frame = .{ .size = 16, .alignment = .@"16" }, |
| 55238 | .extra_temps = .{ |
| 55239 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55240 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55241 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 55242 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 55243 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, |
| 55244 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, |
| 55245 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, |
| 55246 | .unused, |
| 55247 | .unused, |
| 55248 | }, |
| 55249 | .dst_temps = .{.mem}, |
| 55250 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55251 | .each = .{ .once = &.{ |
| 55252 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 55253 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 55254 | .{ .@"0:", ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 55255 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 55256 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 55257 | .{ ._, ._ps, .mova, .tmp5x, .tmp4x, ._, ._ }, |
| 55258 | .{ ._, ._, .call, .tmp6d, ._, ._, ._ }, |
| 55259 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 55260 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 55261 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55262 | } }, |
| 55263 | }, .{ |
| 55264 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 55265 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55266 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 55267 | .patterns = &.{ |
| 55268 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55269 | }, |
| 55270 | .call_frame = .{ .alignment = .@"16" }, |
| 55271 | .extra_temps = .{ |
| 55272 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55273 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55274 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55275 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55276 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55277 | .unused, |
| 55278 | .unused, |
| 55279 | .unused, |
| 55280 | .unused, |
| 55281 | }, |
| 55282 | .dst_temps = .{.mem}, |
| 55283 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55284 | .each = .{ .once = &.{ |
| 55285 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 55286 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55287 | .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 55288 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 55289 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 55290 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 55291 | .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, |
| 55292 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55293 | } }, |
| 55294 | }, .{ |
| 55295 | .required_features = .{ .avx, null, null, null }, |
| 55296 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55297 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 55298 | .patterns = &.{ |
| 55299 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55300 | }, |
| 55301 | .call_frame = .{ .alignment = .@"16" }, |
| 55302 | .extra_temps = .{ |
| 55303 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55304 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55305 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55306 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55307 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55308 | .unused, |
| 55309 | .unused, |
| 55310 | .unused, |
| 55311 | .unused, |
| 55312 | }, |
| 55313 | .dst_temps = .{.mem}, |
| 55314 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55315 | .each = .{ .once = &.{ |
| 55316 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 55317 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55318 | .{ .@"0:", .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 55319 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 55320 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 55321 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 55322 | .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, |
| 55323 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 55324 | } }, |
| 55325 | }, .{ |
| 55326 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 55327 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55328 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 55329 | .patterns = &.{ |
| 55330 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55331 | }, |
| 55332 | .call_frame = .{ .alignment = .@"16" }, |
| 55333 | .extra_temps = .{ |
| 55334 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55335 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55336 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55337 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55338 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55339 | .unused, |
| 55340 | .unused, |
| 55341 | .unused, |
| 55342 | .unused, |
| 55343 | }, |
| 55344 | .dst_temps = .{.mem}, |
| 55345 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55346 | .each = .{ .once = &.{ |
| 55347 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 55348 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55349 | .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 55350 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 55351 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 55352 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 55353 | .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, |
| 55354 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55355 | } }, |
| 55356 | }, .{ |
| 55357 | .required_features = .{ .sse2, null, null, null }, |
| 55358 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55359 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 55360 | .patterns = &.{ |
| 55361 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55362 | }, |
| 55363 | .call_frame = .{ .alignment = .@"16" }, |
| 55364 | .extra_temps = .{ |
| 55365 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55366 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55367 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55368 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55369 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55370 | .unused, |
| 55371 | .unused, |
| 55372 | .unused, |
| 55373 | .unused, |
| 55374 | }, |
| 55375 | .dst_temps = .{.mem}, |
| 55376 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55377 | .each = .{ .once = &.{ |
| 55378 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 55379 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55380 | .{ .@"0:", ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 55381 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 55382 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 55383 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 55384 | .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, |
| 55385 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 55386 | } }, |
| 55387 | }, .{ |
| 55388 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 55389 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55390 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 55391 | .patterns = &.{ |
| 55392 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55393 | }, |
| 55394 | .call_frame = .{ .alignment = .@"16" }, |
| 55395 | .extra_temps = .{ |
| 55396 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55397 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55398 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55399 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55400 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55401 | .unused, |
| 55402 | .unused, |
| 55403 | .unused, |
| 55404 | .unused, |
| 55405 | }, |
| 55406 | .dst_temps = .{.mem}, |
| 55407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55408 | .each = .{ .once = &.{ |
| 55409 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 55410 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55411 | .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 55412 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 55413 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 55414 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 55415 | .{ ._, ._, .add, .tmp1p, .si(1), ._, ._ }, |
| 55416 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55417 | } }, |
| 55418 | }, .{ |
| 55419 | .required_features = .{ .sse, null, null, null }, |
| 55420 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55421 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 55422 | .patterns = &.{ |
| 55423 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55424 | }, |
| 55425 | .call_frame = .{ .alignment = .@"16" }, |
| 55426 | .extra_temps = .{ |
| 55427 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 55428 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55429 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55430 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55431 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55432 | .unused, |
| 55433 | .unused, |
| 55434 | .unused, |
| 55435 | .unused, |
| 55436 | }, |
| 55437 | .dst_temps = .{.mem}, |
| 55438 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55439 | .each = .{ .once = &.{ |
| 55440 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 55441 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55442 | .{ .@"0:", ._ps, .mova, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 55443 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 55444 | .{ ._, ._, .mov, .memia(.dst0b, .tmp1, .add_unaligned_size), .tmp4b, ._, ._ }, |
| 55445 | .{ ._, ._, .lea, .tmp0p, .lead(.tmp0, 16), ._, ._ }, |
| 55446 | .{ ._, ._c, .in, .tmp1p, ._, ._, ._ }, |
| 55447 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 55448 | } }, |
| 55449 | }, .{ |
| 55450 | .required_features = .{ .avx, null, null, null }, |
| 55451 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55452 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 55453 | .patterns = &.{ |
| 55454 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55455 | }, |
| 55456 | .call_frame = .{ .alignment = .@"16" }, |
| 55457 | .extra_temps = .{ |
| 55458 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55459 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55460 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55461 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55462 | .unused, |
| 55463 | .unused, |
| 55464 | .unused, |
| 55465 | .unused, |
| 55466 | .unused, |
| 55467 | }, |
| 55468 | .dst_temps = .{.mem}, |
| 55469 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55470 | .each = .{ .once = &.{ |
| 55471 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55472 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55473 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55474 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 55475 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 55476 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55477 | } }, |
| 55478 | }, .{ |
| 55479 | .required_features = .{ .sse2, null, null, null }, |
| 55480 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55481 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 55482 | .patterns = &.{ |
| 55483 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55484 | }, |
| 55485 | .call_frame = .{ .alignment = .@"16" }, |
| 55486 | .extra_temps = .{ |
| 55487 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55488 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55489 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55490 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55491 | .unused, |
| 55492 | .unused, |
| 55493 | .unused, |
| 55494 | .unused, |
| 55495 | .unused, |
| 55496 | }, |
| 55497 | .dst_temps = .{.mem}, |
| 55498 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55499 | .each = .{ .once = &.{ |
| 55500 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55501 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55502 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55503 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 55504 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 55505 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55506 | } }, |
| 55507 | }, .{ |
| 55508 | .required_features = .{ .sse, null, null, null }, |
| 55509 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55510 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 55511 | .patterns = &.{ |
| 55512 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55513 | }, |
| 55514 | .call_frame = .{ .alignment = .@"16" }, |
| 55515 | .extra_temps = .{ |
| 55516 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55517 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55518 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55519 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55520 | .unused, |
| 55521 | .unused, |
| 55522 | .unused, |
| 55523 | .unused, |
| 55524 | .unused, |
| 55525 | }, |
| 55526 | .dst_temps = .{.mem}, |
| 55527 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55528 | .each = .{ .once = &.{ |
| 55529 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55530 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55531 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55532 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3w, ._, ._ }, |
| 55533 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 55534 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55535 | } }, |
| 55536 | }, .{ |
| 55537 | .required_features = .{ .sse, null, null, null }, |
| 55538 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 55539 | .dst_constraints = .{.{ .signed_int = .dword }}, |
| 55540 | .patterns = &.{ |
| 55541 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 55542 | }, |
| 55543 | .call_frame = .{ .alignment = .@"16" }, |
| 55544 | .extra_temps = .{ |
| 55545 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55546 | .unused, |
| 55547 | .unused, |
| 55548 | .unused, |
| 55549 | .unused, |
| 55550 | .unused, |
| 55551 | .unused, |
| 55552 | .unused, |
| 55553 | .unused, |
| 55554 | }, |
| 55555 | .dst_temps = .{.{ .reg = .eax }}, |
| 55556 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55557 | .each = .{ .once = &.{ |
| 55558 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 55559 | } }, |
| 55560 | }, .{ |
| 55561 | .required_features = .{ .sse, null, null, null }, |
| 55562 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 55563 | .dst_constraints = .{.{ .unsigned_int = .dword }}, |
| 55564 | .patterns = &.{ |
| 55565 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 55566 | }, |
| 55567 | .call_frame = .{ .alignment = .@"16" }, |
| 55568 | .extra_temps = .{ |
| 55569 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } }, |
| 55570 | .unused, |
| 55571 | .unused, |
| 55572 | .unused, |
| 55573 | .unused, |
| 55574 | .unused, |
| 55575 | .unused, |
| 55576 | .unused, |
| 55577 | .unused, |
| 55578 | }, |
| 55579 | .dst_temps = .{.{ .reg = .eax }}, |
| 55580 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55581 | .each = .{ .once = &.{ |
| 55582 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 55583 | } }, |
| 55584 | }, .{ |
| 55585 | .required_features = .{ .avx, null, null, null }, |
| 55586 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55587 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55588 | .patterns = &.{ |
| 55589 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55590 | }, |
| 55591 | .call_frame = .{ .alignment = .@"16" }, |
| 55592 | .extra_temps = .{ |
| 55593 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55594 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55595 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55596 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55597 | .unused, |
| 55598 | .unused, |
| 55599 | .unused, |
| 55600 | .unused, |
| 55601 | .unused, |
| 55602 | }, |
| 55603 | .dst_temps = .{.mem}, |
| 55604 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55605 | .each = .{ .once = &.{ |
| 55606 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55607 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55608 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55609 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 55610 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 55611 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55612 | } }, |
| 55613 | }, .{ |
| 55614 | .required_features = .{ .avx, null, null, null }, |
| 55615 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55616 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55617 | .patterns = &.{ |
| 55618 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55619 | }, |
| 55620 | .call_frame = .{ .alignment = .@"16" }, |
| 55621 | .extra_temps = .{ |
| 55622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55623 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55624 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } }, |
| 55625 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 55626 | .unused, |
| 55627 | .unused, |
| 55628 | .unused, |
| 55629 | .unused, |
| 55630 | .unused, |
| 55631 | }, |
| 55632 | .dst_temps = .{.mem}, |
| 55633 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55634 | .each = .{ .once = &.{ |
| 55635 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55636 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55637 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55638 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 55639 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 55640 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55641 | } }, |
| 55642 | }, .{ |
| 55643 | .required_features = .{ .sse2, null, null, null }, |
| 55644 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55645 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55646 | .patterns = &.{ |
| 55647 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55648 | }, |
| 55649 | .call_frame = .{ .alignment = .@"16" }, |
| 55650 | .extra_temps = .{ |
| 55651 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55652 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55653 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55654 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55655 | .unused, |
| 55656 | .unused, |
| 55657 | .unused, |
| 55658 | .unused, |
| 55659 | .unused, |
| 55660 | }, |
| 55661 | .dst_temps = .{.mem}, |
| 55662 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55663 | .each = .{ .once = &.{ |
| 55664 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55665 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55666 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55667 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 55668 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 55669 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55670 | } }, |
| 55671 | }, .{ |
| 55672 | .required_features = .{ .sse2, null, null, null }, |
| 55673 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55674 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55675 | .patterns = &.{ |
| 55676 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55677 | }, |
| 55678 | .call_frame = .{ .alignment = .@"16" }, |
| 55679 | .extra_temps = .{ |
| 55680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55681 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55682 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } }, |
| 55683 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 55684 | .unused, |
| 55685 | .unused, |
| 55686 | .unused, |
| 55687 | .unused, |
| 55688 | .unused, |
| 55689 | }, |
| 55690 | .dst_temps = .{.mem}, |
| 55691 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55692 | .each = .{ .once = &.{ |
| 55693 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55694 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55695 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55696 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 55697 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 55698 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55699 | } }, |
| 55700 | }, .{ |
| 55701 | .required_features = .{ .sse, null, null, null }, |
| 55702 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55703 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 55704 | .patterns = &.{ |
| 55705 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55706 | }, |
| 55707 | .call_frame = .{ .alignment = .@"16" }, |
| 55708 | .extra_temps = .{ |
| 55709 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55710 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55711 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, |
| 55712 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 55713 | .unused, |
| 55714 | .unused, |
| 55715 | .unused, |
| 55716 | .unused, |
| 55717 | .unused, |
| 55718 | }, |
| 55719 | .dst_temps = .{.mem}, |
| 55720 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55721 | .each = .{ .once = &.{ |
| 55722 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55723 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55724 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55725 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 55726 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 55727 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55728 | } }, |
| 55729 | }, .{ |
| 55730 | .required_features = .{ .sse, null, null, null }, |
| 55731 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55732 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 55733 | .patterns = &.{ |
| 55734 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55735 | }, |
| 55736 | .call_frame = .{ .alignment = .@"16" }, |
| 55737 | .extra_temps = .{ |
| 55738 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55739 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55740 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } }, |
| 55741 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 55742 | .unused, |
| 55743 | .unused, |
| 55744 | .unused, |
| 55745 | .unused, |
| 55746 | .unused, |
| 55747 | }, |
| 55748 | .dst_temps = .{.mem}, |
| 55749 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55750 | .each = .{ .once = &.{ |
| 55751 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55752 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55753 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55754 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 55755 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 55756 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55757 | } }, |
| 55758 | }, .{ |
| 55759 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55760 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 55761 | .dst_constraints = .{.{ .signed_int = .qword }}, |
| 55762 | .patterns = &.{ |
| 55763 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 55764 | }, |
| 55765 | .call_frame = .{ .alignment = .@"16" }, |
| 55766 | .extra_temps = .{ |
| 55767 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } }, |
| 55768 | .unused, |
| 55769 | .unused, |
| 55770 | .unused, |
| 55771 | .unused, |
| 55772 | .unused, |
| 55773 | .unused, |
| 55774 | .unused, |
| 55775 | .unused, |
| 55776 | }, |
| 55777 | .dst_temps = .{.{ .reg = .rax }}, |
| 55778 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55779 | .each = .{ .once = &.{ |
| 55780 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 55781 | } }, |
| 55782 | }, .{ |
| 55783 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55784 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 55785 | .dst_constraints = .{.{ .unsigned_int = .qword }}, |
| 55786 | .patterns = &.{ |
| 55787 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 55788 | }, |
| 55789 | .call_frame = .{ .alignment = .@"16" }, |
| 55790 | .extra_temps = .{ |
| 55791 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } }, |
| 55792 | .unused, |
| 55793 | .unused, |
| 55794 | .unused, |
| 55795 | .unused, |
| 55796 | .unused, |
| 55797 | .unused, |
| 55798 | .unused, |
| 55799 | .unused, |
| 55800 | }, |
| 55801 | .dst_temps = .{.{ .reg = .rax }}, |
| 55802 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55803 | .each = .{ .once = &.{ |
| 55804 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 55805 | } }, |
| 55806 | }, .{ |
| 55807 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 55808 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55809 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 55810 | .patterns = &.{ |
| 55811 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55812 | }, |
| 55813 | .call_frame = .{ .alignment = .@"16" }, |
| 55814 | .extra_temps = .{ |
| 55815 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55816 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55817 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } }, |
| 55818 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 55819 | .unused, |
| 55820 | .unused, |
| 55821 | .unused, |
| 55822 | .unused, |
| 55823 | .unused, |
| 55824 | }, |
| 55825 | .dst_temps = .{.mem}, |
| 55826 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55827 | .each = .{ .once = &.{ |
| 55828 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55829 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55830 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55831 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 55832 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 55833 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55834 | } }, |
| 55835 | }, .{ |
| 55836 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 55837 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55838 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 55839 | .patterns = &.{ |
| 55840 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55841 | }, |
| 55842 | .call_frame = .{ .alignment = .@"16" }, |
| 55843 | .extra_temps = .{ |
| 55844 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55845 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55846 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } }, |
| 55847 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 55848 | .unused, |
| 55849 | .unused, |
| 55850 | .unused, |
| 55851 | .unused, |
| 55852 | .unused, |
| 55853 | }, |
| 55854 | .dst_temps = .{.mem}, |
| 55855 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55856 | .each = .{ .once = &.{ |
| 55857 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55858 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55859 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55860 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 55861 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 55862 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55863 | } }, |
| 55864 | }, .{ |
| 55865 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 55866 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55867 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 55868 | .patterns = &.{ |
| 55869 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55870 | }, |
| 55871 | .call_frame = .{ .alignment = .@"16" }, |
| 55872 | .extra_temps = .{ |
| 55873 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55874 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55875 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } }, |
| 55876 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 55877 | .unused, |
| 55878 | .unused, |
| 55879 | .unused, |
| 55880 | .unused, |
| 55881 | .unused, |
| 55882 | }, |
| 55883 | .dst_temps = .{.mem}, |
| 55884 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55885 | .each = .{ .once = &.{ |
| 55886 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55887 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55888 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55889 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 55890 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 55891 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55892 | } }, |
| 55893 | }, .{ |
| 55894 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 55895 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55896 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 55897 | .patterns = &.{ |
| 55898 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55899 | }, |
| 55900 | .call_frame = .{ .alignment = .@"16" }, |
| 55901 | .extra_temps = .{ |
| 55902 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55903 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55904 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } }, |
| 55905 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 55906 | .unused, |
| 55907 | .unused, |
| 55908 | .unused, |
| 55909 | .unused, |
| 55910 | .unused, |
| 55911 | }, |
| 55912 | .dst_temps = .{.mem}, |
| 55913 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55914 | .each = .{ .once = &.{ |
| 55915 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55916 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55917 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55918 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 55919 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 55920 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55921 | } }, |
| 55922 | }, .{ |
| 55923 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55924 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55925 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 55926 | .patterns = &.{ |
| 55927 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55928 | }, |
| 55929 | .call_frame = .{ .alignment = .@"16" }, |
| 55930 | .extra_temps = .{ |
| 55931 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55932 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55933 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } }, |
| 55934 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 55935 | .unused, |
| 55936 | .unused, |
| 55937 | .unused, |
| 55938 | .unused, |
| 55939 | .unused, |
| 55940 | }, |
| 55941 | .dst_temps = .{.mem}, |
| 55942 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55943 | .each = .{ .once = &.{ |
| 55944 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55945 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55946 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55947 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 55948 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 55949 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55950 | } }, |
| 55951 | }, .{ |
| 55952 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55953 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 55954 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 55955 | .patterns = &.{ |
| 55956 | .{ .src = .{ .to_mem, .none, .none } }, |
| 55957 | }, |
| 55958 | .call_frame = .{ .alignment = .@"16" }, |
| 55959 | .extra_temps = .{ |
| 55960 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 55961 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 55962 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } }, |
| 55963 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 55964 | .unused, |
| 55965 | .unused, |
| 55966 | .unused, |
| 55967 | .unused, |
| 55968 | .unused, |
| 55969 | }, |
| 55970 | .dst_temps = .{.mem}, |
| 55971 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 55972 | .each = .{ .once = &.{ |
| 55973 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 55974 | .{ .@"0:", ._ps, .mova, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 55975 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 55976 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 55977 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 55978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 55979 | } }, |
| 55980 | }, .{ |
| 55981 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 55982 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 55983 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 55984 | .patterns = &.{ |
| 55985 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 55986 | }, |
| 55987 | .call_frame = .{ .alignment = .@"16" }, |
| 55988 | .extra_temps = .{ |
| 55989 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } }, |
| 55990 | .unused, |
| 55991 | .unused, |
| 55992 | .unused, |
| 55993 | .unused, |
| 55994 | .unused, |
| 55995 | .unused, |
| 55996 | .unused, |
| 55997 | .unused, |
| 55998 | }, |
| 55999 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 56000 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56001 | .each = .{ .once = &.{ |
| 56002 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56003 | } }, |
| 56004 | }, .{ |
| 56005 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56006 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 56007 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 56008 | .patterns = &.{ |
| 56009 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 56010 | }, |
| 56011 | .call_frame = .{ .alignment = .@"16" }, |
| 56012 | .extra_temps = .{ |
| 56013 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } }, |
| 56014 | .unused, |
| 56015 | .unused, |
| 56016 | .unused, |
| 56017 | .unused, |
| 56018 | .unused, |
| 56019 | .unused, |
| 56020 | .unused, |
| 56021 | .unused, |
| 56022 | }, |
| 56023 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, |
| 56024 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56025 | .each = .{ .once = &.{ |
| 56026 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56027 | } }, |
| 56028 | }, .{ |
| 56029 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 56030 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56031 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 56032 | .patterns = &.{ |
| 56033 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56034 | }, |
| 56035 | .call_frame = .{ .alignment = .@"16" }, |
| 56036 | .extra_temps = .{ |
| 56037 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56038 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56039 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } }, |
| 56040 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 56041 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 56042 | .unused, |
| 56043 | .unused, |
| 56044 | .unused, |
| 56045 | .unused, |
| 56046 | }, |
| 56047 | .dst_temps = .{.mem}, |
| 56048 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56049 | .each = .{ .once = &.{ |
| 56050 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56051 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56052 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56053 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 56054 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 56055 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56056 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56057 | } }, |
| 56058 | }, .{ |
| 56059 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 56060 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56061 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 56062 | .patterns = &.{ |
| 56063 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56064 | }, |
| 56065 | .call_frame = .{ .alignment = .@"16" }, |
| 56066 | .extra_temps = .{ |
| 56067 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56068 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56069 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } }, |
| 56070 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 56071 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 56072 | .unused, |
| 56073 | .unused, |
| 56074 | .unused, |
| 56075 | .unused, |
| 56076 | }, |
| 56077 | .dst_temps = .{.mem}, |
| 56078 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56079 | .each = .{ .once = &.{ |
| 56080 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56081 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56082 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56083 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 56084 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 56085 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56086 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56087 | } }, |
| 56088 | }, .{ |
| 56089 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 56090 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56091 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 56092 | .patterns = &.{ |
| 56093 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56094 | }, |
| 56095 | .call_frame = .{ .alignment = .@"16" }, |
| 56096 | .extra_temps = .{ |
| 56097 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56098 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56099 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } }, |
| 56100 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 56101 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 56102 | .unused, |
| 56103 | .unused, |
| 56104 | .unused, |
| 56105 | .unused, |
| 56106 | }, |
| 56107 | .dst_temps = .{.mem}, |
| 56108 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56109 | .each = .{ .once = &.{ |
| 56110 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56111 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56112 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56113 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 56114 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 56115 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56116 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56117 | } }, |
| 56118 | }, .{ |
| 56119 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 56120 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56121 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 56122 | .patterns = &.{ |
| 56123 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56124 | }, |
| 56125 | .call_frame = .{ .alignment = .@"16" }, |
| 56126 | .extra_temps = .{ |
| 56127 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56128 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56129 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } }, |
| 56130 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 56131 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 56132 | .unused, |
| 56133 | .unused, |
| 56134 | .unused, |
| 56135 | .unused, |
| 56136 | }, |
| 56137 | .dst_temps = .{.mem}, |
| 56138 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56139 | .each = .{ .once = &.{ |
| 56140 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56141 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56142 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56143 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 56144 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 56145 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56146 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56147 | } }, |
| 56148 | }, .{ |
| 56149 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56150 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56151 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 56152 | .patterns = &.{ |
| 56153 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56154 | }, |
| 56155 | .call_frame = .{ .alignment = .@"16" }, |
| 56156 | .extra_temps = .{ |
| 56157 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56158 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56159 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } }, |
| 56160 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 56161 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 56162 | .unused, |
| 56163 | .unused, |
| 56164 | .unused, |
| 56165 | .unused, |
| 56166 | }, |
| 56167 | .dst_temps = .{.mem}, |
| 56168 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56169 | .each = .{ .once = &.{ |
| 56170 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56171 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56172 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56173 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 56174 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 56175 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56176 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56177 | } }, |
| 56178 | }, .{ |
| 56179 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56180 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56181 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 56182 | .patterns = &.{ |
| 56183 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56184 | }, |
| 56185 | .call_frame = .{ .alignment = .@"16" }, |
| 56186 | .extra_temps = .{ |
| 56187 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56188 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56189 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } }, |
| 56190 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 56191 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 56192 | .unused, |
| 56193 | .unused, |
| 56194 | .unused, |
| 56195 | .unused, |
| 56196 | }, |
| 56197 | .dst_temps = .{.mem}, |
| 56198 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56199 | .each = .{ .once = &.{ |
| 56200 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56201 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56202 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56203 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3q, ._, ._ }, |
| 56204 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp4q, ._, ._ }, |
| 56205 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56206 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56207 | } }, |
| 56208 | }, .{ |
| 56209 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56210 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 56211 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 56212 | .patterns = &.{ |
| 56213 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 56214 | }, |
| 56215 | .call_frame = .{ .alignment = .@"16" }, |
| 56216 | .extra_temps = .{ |
| 56217 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56218 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56219 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } }, |
| 56220 | .unused, |
| 56221 | .unused, |
| 56222 | .unused, |
| 56223 | .unused, |
| 56224 | .unused, |
| 56225 | .unused, |
| 56226 | }, |
| 56227 | .dst_temps = .{.mem}, |
| 56228 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56229 | .each = .{ .once = &.{ |
| 56230 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 56231 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 56232 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56233 | } }, |
| 56234 | }, .{ |
| 56235 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56236 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, |
| 56237 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 56238 | .patterns = &.{ |
| 56239 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 56240 | }, |
| 56241 | .call_frame = .{ .alignment = .@"16" }, |
| 56242 | .extra_temps = .{ |
| 56243 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56244 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56245 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } }, |
| 56246 | .unused, |
| 56247 | .unused, |
| 56248 | .unused, |
| 56249 | .unused, |
| 56250 | .unused, |
| 56251 | .unused, |
| 56252 | }, |
| 56253 | .dst_temps = .{.mem}, |
| 56254 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56255 | .each = .{ .once = &.{ |
| 56256 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 56257 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, |
| 56258 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56259 | } }, |
| 56260 | }, .{ |
| 56261 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 56262 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56263 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 56264 | .patterns = &.{ |
| 56265 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56266 | }, |
| 56267 | .call_frame = .{ .alignment = .@"16" }, |
| 56268 | .extra_temps = .{ |
| 56269 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56270 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 56271 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56272 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56273 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56274 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } }, |
| 56275 | .unused, |
| 56276 | .unused, |
| 56277 | .unused, |
| 56278 | }, |
| 56279 | .dst_temps = .{.mem}, |
| 56280 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56281 | .each = .{ .once = &.{ |
| 56282 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56283 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 56284 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 56285 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 56286 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56287 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 56288 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 56289 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56290 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56291 | } }, |
| 56292 | }, .{ |
| 56293 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 56294 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56295 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 56296 | .patterns = &.{ |
| 56297 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56298 | }, |
| 56299 | .call_frame = .{ .alignment = .@"16" }, |
| 56300 | .extra_temps = .{ |
| 56301 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56302 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 56303 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56304 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56305 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56306 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } }, |
| 56307 | .unused, |
| 56308 | .unused, |
| 56309 | .unused, |
| 56310 | }, |
| 56311 | .dst_temps = .{.mem}, |
| 56312 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56313 | .each = .{ .once = &.{ |
| 56314 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56315 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 56316 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 56317 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 56318 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56319 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 56320 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 56321 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56322 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56323 | } }, |
| 56324 | }, .{ |
| 56325 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 56326 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56327 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 56328 | .patterns = &.{ |
| 56329 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56330 | }, |
| 56331 | .call_frame = .{ .alignment = .@"16" }, |
| 56332 | .extra_temps = .{ |
| 56333 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56334 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 56335 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56336 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56337 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56338 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } }, |
| 56339 | .unused, |
| 56340 | .unused, |
| 56341 | .unused, |
| 56342 | }, |
| 56343 | .dst_temps = .{.mem}, |
| 56344 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56345 | .each = .{ .once = &.{ |
| 56346 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56347 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 56348 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 56349 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 56350 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56351 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 56352 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 56353 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56354 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56355 | } }, |
| 56356 | }, .{ |
| 56357 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 56358 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56359 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 56360 | .patterns = &.{ |
| 56361 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56362 | }, |
| 56363 | .call_frame = .{ .alignment = .@"16" }, |
| 56364 | .extra_temps = .{ |
| 56365 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56366 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 56367 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56368 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56369 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56370 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } }, |
| 56371 | .unused, |
| 56372 | .unused, |
| 56373 | .unused, |
| 56374 | }, |
| 56375 | .dst_temps = .{.mem}, |
| 56376 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56377 | .each = .{ .once = &.{ |
| 56378 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56379 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 56380 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 56381 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 56382 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56383 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 56384 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 56385 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56386 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56387 | } }, |
| 56388 | }, .{ |
| 56389 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56390 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56391 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 56392 | .patterns = &.{ |
| 56393 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56394 | }, |
| 56395 | .call_frame = .{ .alignment = .@"16" }, |
| 56396 | .extra_temps = .{ |
| 56397 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56398 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 56399 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56400 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56401 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56402 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } }, |
| 56403 | .unused, |
| 56404 | .unused, |
| 56405 | .unused, |
| 56406 | }, |
| 56407 | .dst_temps = .{.mem}, |
| 56408 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56409 | .each = .{ .once = &.{ |
| 56410 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56411 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 56412 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 56413 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 56414 | .{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56415 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 56416 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 56417 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56418 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56419 | } }, |
| 56420 | }, .{ |
| 56421 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56422 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 56423 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 56424 | .patterns = &.{ |
| 56425 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56426 | }, |
| 56427 | .call_frame = .{ .alignment = .@"16" }, |
| 56428 | .extra_temps = .{ |
| 56429 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 56430 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 56431 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56432 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56433 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 56434 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } }, |
| 56435 | .unused, |
| 56436 | .unused, |
| 56437 | .unused, |
| 56438 | }, |
| 56439 | .dst_temps = .{.mem}, |
| 56440 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56441 | .each = .{ .once = &.{ |
| 56442 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 56443 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 56444 | .{ .@"0:", ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 56445 | .{ ._, ._, .mov, .tmp3d, .sa(.dst0, .add_8_elem_size), ._, ._ }, |
| 56446 | .{ ._, ._ps, .mova, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 56447 | .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, |
| 56448 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp1, .add_dst0_elem_size), ._, ._ }, |
| 56449 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 56450 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 56451 | } }, |
| 56452 | } }) catch |err| switch (err) { |
| 56453 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 56454 | @tagName(air_tag), |
| 56455 | ty_op.ty.toType().fmt(pt), |
| 56456 | cg.typeOf(ty_op.operand).fmt(pt), |
| 56457 | ops[0].tracking(cg), |
| 56458 | }), |
| 56459 | else => |e| return e, |
| 56460 | }; |
| 56461 | try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); |
| 56462 | }, |
| 56463 | .float_from_int => |air_tag| if (use_old) try cg.airFloatFromInt(inst) else { |
| 56464 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; |
| 56465 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 56466 | var res: [1]Temp = undefined; |
| 56467 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ |
| 56468 | .required_features = .{ .f16c, null, null, null }, |
| 56469 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 56470 | .dst_constraints = .{.{ .float = .word }}, |
| 56471 | .patterns = &.{ |
| 56472 | .{ .src = .{ .mem, .none, .none } }, |
| 56473 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56474 | }, |
| 56475 | .extra_temps = .{ |
| 56476 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 56477 | .unused, |
| 56478 | .unused, |
| 56479 | .unused, |
| 56480 | .unused, |
| 56481 | .unused, |
| 56482 | .unused, |
| 56483 | .unused, |
| 56484 | .unused, |
| 56485 | }, |
| 56486 | .dst_temps = .{.{ .rc = .sse }}, |
| 56487 | .each = .{ .once = &.{ |
| 56488 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 56489 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56490 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 56491 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56492 | } }, |
| 56493 | }, .{ |
| 56494 | .required_features = .{ .f16c, null, null, null }, |
| 56495 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 56496 | .dst_constraints = .{.{ .float = .word }}, |
| 56497 | .patterns = &.{ |
| 56498 | .{ .src = .{ .mem, .none, .none } }, |
| 56499 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56500 | }, |
| 56501 | .extra_temps = .{ |
| 56502 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 56503 | .unused, |
| 56504 | .unused, |
| 56505 | .unused, |
| 56506 | .unused, |
| 56507 | .unused, |
| 56508 | .unused, |
| 56509 | .unused, |
| 56510 | .unused, |
| 56511 | }, |
| 56512 | .dst_temps = .{.{ .rc = .sse }}, |
| 56513 | .each = .{ .once = &.{ |
| 56514 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 56515 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56516 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 56517 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56518 | } }, |
| 56519 | }, .{ |
| 56520 | .required_features = .{ .f16c, null, null, null }, |
| 56521 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 56522 | .dst_constraints = .{.{ .float = .word }}, |
| 56523 | .patterns = &.{ |
| 56524 | .{ .src = .{ .mem, .none, .none } }, |
| 56525 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56526 | }, |
| 56527 | .extra_temps = .{ |
| 56528 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 56529 | .unused, |
| 56530 | .unused, |
| 56531 | .unused, |
| 56532 | .unused, |
| 56533 | .unused, |
| 56534 | .unused, |
| 56535 | .unused, |
| 56536 | .unused, |
| 56537 | }, |
| 56538 | .dst_temps = .{.{ .rc = .sse }}, |
| 56539 | .each = .{ .once = &.{ |
| 56540 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 56541 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56542 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 56543 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56544 | } }, |
| 56545 | }, .{ |
| 56546 | .required_features = .{ .f16c, null, null, null }, |
| 56547 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 56548 | .dst_constraints = .{.{ .float = .word }}, |
| 56549 | .patterns = &.{ |
| 56550 | .{ .src = .{ .mem, .none, .none } }, |
| 56551 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56552 | }, |
| 56553 | .extra_temps = .{ |
| 56554 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 56555 | .unused, |
| 56556 | .unused, |
| 56557 | .unused, |
| 56558 | .unused, |
| 56559 | .unused, |
| 56560 | .unused, |
| 56561 | .unused, |
| 56562 | .unused, |
| 56563 | }, |
| 56564 | .dst_temps = .{.{ .rc = .sse }}, |
| 56565 | .each = .{ .once = &.{ |
| 56566 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 56567 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56568 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 56569 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56570 | } }, |
| 56571 | }, .{ |
| 56572 | .required_features = .{ .f16c, null, null, null }, |
| 56573 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 56574 | .dst_constraints = .{.{ .float = .word }}, |
| 56575 | .patterns = &.{ |
| 56576 | .{ .src = .{ .mem, .none, .none } }, |
| 56577 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56578 | }, |
| 56579 | .dst_temps = .{.{ .rc = .sse }}, |
| 56580 | .each = .{ .once = &.{ |
| 56581 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56582 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, |
| 56583 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56584 | } }, |
| 56585 | }, .{ |
| 56586 | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 56587 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 56588 | .dst_constraints = .{.{ .float = .word }}, |
| 56589 | .patterns = &.{ |
| 56590 | .{ .src = .{ .mem, .none, .none } }, |
| 56591 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56592 | }, |
| 56593 | .extra_temps = .{ |
| 56594 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 56595 | .unused, |
| 56596 | .unused, |
| 56597 | .unused, |
| 56598 | .unused, |
| 56599 | .unused, |
| 56600 | .unused, |
| 56601 | .unused, |
| 56602 | .unused, |
| 56603 | }, |
| 56604 | .dst_temps = .{.{ .rc = .sse }}, |
| 56605 | .each = .{ .once = &.{ |
| 56606 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 56607 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56608 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, |
| 56609 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56610 | } }, |
| 56611 | }, .{ |
| 56612 | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 56613 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 56614 | .dst_constraints = .{.{ .float = .word }}, |
| 56615 | .patterns = &.{ |
| 56616 | .{ .src = .{ .mem, .none, .none } }, |
| 56617 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 56618 | }, |
| 56619 | .dst_temps = .{.{ .rc = .sse }}, |
| 56620 | .each = .{ .once = &.{ |
| 56621 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56622 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 56623 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56624 | } }, |
| 56625 | }, .{ |
| 56626 | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 56627 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 50689 | 56628 | .dst_constraints = .{.{ .float = .word }}, |
| 50690 | 56629 | .patterns = &.{ |
| 50691 | | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 56630 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 56631 | }, |
| 56632 | .extra_temps = .{ |
| 56633 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 56634 | .unused, |
| 56635 | .unused, |
| 56636 | .unused, |
| 56637 | .unused, |
| 56638 | .unused, |
| 56639 | .unused, |
| 56640 | .unused, |
| 56641 | .unused, |
| 56642 | }, |
| 56643 | .dst_temps = .{.{ .rc = .sse }}, |
| 56644 | .clobbers = .{ .eflags = true }, |
| 56645 | .each = .{ .once = &.{ |
| 56646 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 56647 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 56648 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 56649 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 56650 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 56651 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 56652 | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 56653 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 56654 | .{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ }, |
| 56655 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 56656 | .{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 56657 | .{ .@"0:", .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56658 | } }, |
| 56659 | }, .{ |
| 56660 | .required_features = .{ .sse, null, null, null }, |
| 56661 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 56662 | .dst_constraints = .{.{ .float = .word }}, |
| 56663 | .patterns = &.{ |
| 56664 | .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, |
| 56665 | }, |
| 56666 | .call_frame = .{ .alignment = .@"16" }, |
| 56667 | .extra_temps = .{ |
| 56668 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 56669 | .unused, |
| 56670 | .unused, |
| 56671 | .unused, |
| 56672 | .unused, |
| 56673 | .unused, |
| 56674 | .unused, |
| 56675 | .unused, |
| 56676 | .unused, |
| 56677 | }, |
| 56678 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56679 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56680 | .each = .{ .once = &.{ |
| 56681 | .{ ._, ._, .movsx, .src0d, .src0b, ._, ._ }, |
| 56682 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56683 | } }, |
| 56684 | }, .{ |
| 56685 | .required_features = .{ .sse, null, null, null }, |
| 56686 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 56687 | .dst_constraints = .{.{ .float = .word }}, |
| 56688 | .patterns = &.{ |
| 56689 | .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, |
| 56690 | }, |
| 56691 | .call_frame = .{ .alignment = .@"16" }, |
| 56692 | .extra_temps = .{ |
| 56693 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 56694 | .unused, |
| 56695 | .unused, |
| 56696 | .unused, |
| 56697 | .unused, |
| 56698 | .unused, |
| 56699 | .unused, |
| 56700 | .unused, |
| 56701 | .unused, |
| 56702 | }, |
| 56703 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56704 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56705 | .each = .{ .once = &.{ |
| 56706 | .{ ._, ._, .movzx, .src0d, .src0b, ._, ._ }, |
| 56707 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56708 | } }, |
| 56709 | }, .{ |
| 56710 | .required_features = .{ .sse, null, null, null }, |
| 56711 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 56712 | .dst_constraints = .{.{ .float = .word }}, |
| 56713 | .patterns = &.{ |
| 56714 | .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, |
| 56715 | }, |
| 56716 | .call_frame = .{ .alignment = .@"16" }, |
| 56717 | .extra_temps = .{ |
| 56718 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 56719 | .unused, |
| 56720 | .unused, |
| 56721 | .unused, |
| 56722 | .unused, |
| 56723 | .unused, |
| 56724 | .unused, |
| 56725 | .unused, |
| 56726 | .unused, |
| 56727 | }, |
| 56728 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56729 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56730 | .each = .{ .once = &.{ |
| 56731 | .{ ._, ._, .movsx, .src0d, .src0w, ._, ._ }, |
| 56732 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56733 | } }, |
| 56734 | }, .{ |
| 56735 | .required_features = .{ .sse, null, null, null }, |
| 56736 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 56737 | .dst_constraints = .{.{ .float = .word }}, |
| 56738 | .patterns = &.{ |
| 56739 | .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, |
| 56740 | }, |
| 56741 | .call_frame = .{ .alignment = .@"16" }, |
| 56742 | .extra_temps = .{ |
| 56743 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 56744 | .unused, |
| 56745 | .unused, |
| 56746 | .unused, |
| 56747 | .unused, |
| 56748 | .unused, |
| 56749 | .unused, |
| 56750 | .unused, |
| 56751 | .unused, |
| 56752 | }, |
| 56753 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56754 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56755 | .each = .{ .once = &.{ |
| 56756 | .{ ._, ._, .movzx, .src0d, .src0w, ._, ._ }, |
| 56757 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56758 | } }, |
| 56759 | }, .{ |
| 56760 | .required_features = .{ .sse, null, null, null }, |
| 56761 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 56762 | .dst_constraints = .{.{ .float = .word }}, |
| 56763 | .patterns = &.{ |
| 56764 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 56765 | }, |
| 56766 | .call_frame = .{ .alignment = .@"16" }, |
| 56767 | .extra_temps = .{ |
| 56768 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 56769 | .unused, |
| 56770 | .unused, |
| 56771 | .unused, |
| 56772 | .unused, |
| 56773 | .unused, |
| 56774 | .unused, |
| 56775 | .unused, |
| 56776 | .unused, |
| 56777 | }, |
| 56778 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56779 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56780 | .each = .{ .once = &.{ |
| 56781 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56782 | } }, |
| 56783 | }, .{ |
| 56784 | .required_features = .{ .sse, null, null, null }, |
| 56785 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 56786 | .dst_constraints = .{.{ .float = .word }}, |
| 56787 | .patterns = &.{ |
| 56788 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 56789 | }, |
| 56790 | .call_frame = .{ .alignment = .@"16" }, |
| 56791 | .extra_temps = .{ |
| 56792 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 56793 | .unused, |
| 56794 | .unused, |
| 56795 | .unused, |
| 56796 | .unused, |
| 56797 | .unused, |
| 56798 | .unused, |
| 56799 | .unused, |
| 56800 | .unused, |
| 56801 | }, |
| 56802 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56803 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56804 | .each = .{ .once = &.{ |
| 56805 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56806 | } }, |
| 56807 | }, .{ |
| 56808 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56809 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 56810 | .dst_constraints = .{.{ .float = .word }}, |
| 56811 | .patterns = &.{ |
| 56812 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 56813 | }, |
| 56814 | .call_frame = .{ .alignment = .@"16" }, |
| 56815 | .extra_temps = .{ |
| 56816 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, |
| 56817 | .unused, |
| 56818 | .unused, |
| 56819 | .unused, |
| 56820 | .unused, |
| 56821 | .unused, |
| 56822 | .unused, |
| 56823 | .unused, |
| 56824 | .unused, |
| 56825 | }, |
| 56826 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56827 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56828 | .each = .{ .once = &.{ |
| 56829 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56830 | } }, |
| 56831 | }, .{ |
| 56832 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56833 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 56834 | .dst_constraints = .{.{ .float = .word }}, |
| 56835 | .patterns = &.{ |
| 56836 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 56837 | }, |
| 56838 | .call_frame = .{ .alignment = .@"16" }, |
| 56839 | .extra_temps = .{ |
| 56840 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, |
| 56841 | .unused, |
| 56842 | .unused, |
| 56843 | .unused, |
| 56844 | .unused, |
| 56845 | .unused, |
| 56846 | .unused, |
| 56847 | .unused, |
| 56848 | .unused, |
| 56849 | }, |
| 56850 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56851 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56852 | .each = .{ .once = &.{ |
| 56853 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56854 | } }, |
| 56855 | }, .{ |
| 56856 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56857 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 56858 | .dst_constraints = .{.{ .float = .word }}, |
| 56859 | .patterns = &.{ |
| 56860 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 56861 | }, |
| 56862 | .call_frame = .{ .alignment = .@"16" }, |
| 56863 | .extra_temps = .{ |
| 56864 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, |
| 56865 | .unused, |
| 56866 | .unused, |
| 56867 | .unused, |
| 56868 | .unused, |
| 56869 | .unused, |
| 56870 | .unused, |
| 56871 | .unused, |
| 56872 | .unused, |
| 56873 | }, |
| 56874 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56875 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56876 | .each = .{ .once = &.{ |
| 56877 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56878 | } }, |
| 56879 | }, .{ |
| 56880 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56881 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 56882 | .dst_constraints = .{.{ .float = .word }}, |
| 56883 | .patterns = &.{ |
| 56884 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 56885 | }, |
| 56886 | .call_frame = .{ .alignment = .@"16" }, |
| 56887 | .extra_temps = .{ |
| 56888 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, |
| 56889 | .unused, |
| 56890 | .unused, |
| 56891 | .unused, |
| 56892 | .unused, |
| 56893 | .unused, |
| 56894 | .unused, |
| 56895 | .unused, |
| 56896 | .unused, |
| 56897 | }, |
| 56898 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56899 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56900 | .each = .{ .once = &.{ |
| 56901 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 56902 | } }, |
| 56903 | }, .{ |
| 56904 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56905 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 56906 | .dst_constraints = .{.{ .float = .word }}, |
| 56907 | .patterns = &.{ |
| 56908 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56909 | }, |
| 56910 | .call_frame = .{ .alignment = .@"16" }, |
| 56911 | .extra_temps = .{ |
| 56912 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56913 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56914 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, |
| 56915 | .unused, |
| 56916 | .unused, |
| 56917 | .unused, |
| 56918 | .unused, |
| 56919 | .unused, |
| 56920 | .unused, |
| 56921 | }, |
| 56922 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56923 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56924 | .each = .{ .once = &.{ |
| 56925 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 56926 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 56927 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56928 | } }, |
| 56929 | }, .{ |
| 56930 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 56931 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 56932 | .dst_constraints = .{.{ .float = .word }}, |
| 56933 | .patterns = &.{ |
| 56934 | .{ .src = .{ .to_mem, .none, .none } }, |
| 56935 | }, |
| 56936 | .call_frame = .{ .alignment = .@"16" }, |
| 56937 | .extra_temps = .{ |
| 56938 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 56939 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 56940 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, |
| 56941 | .unused, |
| 56942 | .unused, |
| 56943 | .unused, |
| 56944 | .unused, |
| 56945 | .unused, |
| 56946 | .unused, |
| 56947 | }, |
| 56948 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 56949 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 56950 | .each = .{ .once = &.{ |
| 56951 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 56952 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 56953 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 56954 | } }, |
| 56955 | }, .{ |
| 56956 | .required_features = .{ .f16c, null, null, null }, |
| 56957 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 56958 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 56959 | .patterns = &.{ |
| 56960 | .{ .src = .{ .mem, .none, .none } }, |
| 56961 | .{ .src = .{ .to_sse, .none, .none } }, |
| 56962 | }, |
| 56963 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 56964 | .each = .{ .once = &.{ |
| 56965 | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 56966 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 56967 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56968 | } }, |
| 56969 | }, .{ |
| 56970 | .required_features = .{ .f16c, .avx2, null, null }, |
| 56971 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 56972 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 56973 | .patterns = &.{ |
| 56974 | .{ .src = .{ .mem, .none, .none } }, |
| 56975 | .{ .src = .{ .to_sse, .none, .none } }, |
| 56976 | }, |
| 56977 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 56978 | .each = .{ .once = &.{ |
| 56979 | .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ }, |
| 56980 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 56981 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 56982 | } }, |
| 56983 | }, .{ |
| 56984 | .required_features = .{ .f16c, null, null, null }, |
| 56985 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 56986 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 56987 | .patterns = &.{ |
| 56988 | .{ .src = .{ .mem, .none, .none } }, |
| 56989 | .{ .src = .{ .to_sse, .none, .none } }, |
| 56990 | }, |
| 56991 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 56992 | .each = .{ .once = &.{ |
| 56993 | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 56994 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 56995 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 56996 | } }, |
| 56997 | }, .{ |
| 56998 | .required_features = .{ .f16c, .avx2, null, null }, |
| 56999 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 57000 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57001 | .patterns = &.{ |
| 57002 | .{ .src = .{ .mem, .none, .none } }, |
| 57003 | .{ .src = .{ .to_sse, .none, .none } }, |
| 57004 | }, |
| 57005 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 57006 | .each = .{ .once = &.{ |
| 57007 | .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ }, |
| 57008 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 57009 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 57010 | } }, |
| 57011 | }, .{ |
| 57012 | .required_features = .{ .f16c, .avx2, null, null }, |
| 57013 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 57014 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57015 | .patterns = &.{ |
| 57016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57017 | }, |
| 57018 | .extra_temps = .{ |
| 57019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57020 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 57021 | .unused, |
| 57022 | .unused, |
| 57023 | .unused, |
| 57024 | .unused, |
| 57025 | .unused, |
| 57026 | .unused, |
| 57027 | .unused, |
| 57028 | }, |
| 57029 | .dst_temps = .{.mem}, |
| 57030 | .clobbers = .{ .eflags = true }, |
| 57031 | .each = .{ .once = &.{ |
| 57032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57033 | .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57034 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 57035 | .{ ._, .v_, .cvtps2ph, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 57036 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 57037 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57038 | } }, |
| 57039 | }, .{ |
| 57040 | .required_features = .{ .f16c, null, null, null }, |
| 57041 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 57042 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }}, |
| 57043 | .patterns = &.{ |
| 57044 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57045 | }, |
| 57046 | .extra_temps = .{ |
| 57047 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57048 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 57049 | .unused, |
| 57050 | .unused, |
| 57051 | .unused, |
| 57052 | .unused, |
| 57053 | .unused, |
| 57054 | .unused, |
| 57055 | .unused, |
| 57056 | }, |
| 57057 | .dst_temps = .{.mem}, |
| 57058 | .clobbers = .{ .eflags = true }, |
| 57059 | .each = .{ .once = &.{ |
| 57060 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57061 | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57062 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 57063 | .{ ._, .v_, .cvtps2ph, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, |
| 57064 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 57065 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57066 | } }, |
| 57067 | }, .{ |
| 57068 | .required_features = .{ .f16c, .avx2, null, null }, |
| 57069 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 57070 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57071 | .patterns = &.{ |
| 57072 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57073 | }, |
| 57074 | .extra_temps = .{ |
| 57075 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57076 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 57077 | .unused, |
| 57078 | .unused, |
| 57079 | .unused, |
| 57080 | .unused, |
| 57081 | .unused, |
| 57082 | .unused, |
| 57083 | .unused, |
| 57084 | }, |
| 57085 | .dst_temps = .{.mem}, |
| 57086 | .clobbers = .{ .eflags = true }, |
| 57087 | .each = .{ .once = &.{ |
| 57088 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57089 | .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57090 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 57091 | .{ ._, .v_, .cvtps2ph, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 57092 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 57093 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57094 | } }, |
| 57095 | }, .{ |
| 57096 | .required_features = .{ .f16c, null, null, null }, |
| 57097 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 57098 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }}, |
| 57099 | .patterns = &.{ |
| 57100 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57101 | }, |
| 57102 | .extra_temps = .{ |
| 57103 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57104 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 57105 | .unused, |
| 57106 | .unused, |
| 57107 | .unused, |
| 57108 | .unused, |
| 57109 | .unused, |
| 57110 | .unused, |
| 57111 | .unused, |
| 57112 | }, |
| 57113 | .dst_temps = .{.mem}, |
| 57114 | .clobbers = .{ .eflags = true }, |
| 57115 | .each = .{ .once = &.{ |
| 57116 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57117 | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57118 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 57119 | .{ ._, .v_, .cvtps2ph, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, |
| 57120 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 57121 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57122 | } }, |
| 57123 | }, .{ |
| 57124 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 57125 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57126 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57127 | .patterns = &.{ |
| 57128 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57129 | }, |
| 57130 | .call_frame = .{ .alignment = .@"16" }, |
| 57131 | .extra_temps = .{ |
| 57132 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57133 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57134 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57135 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57136 | .unused, |
| 57137 | .unused, |
| 57138 | .unused, |
| 57139 | .unused, |
| 57140 | .unused, |
| 57141 | }, |
| 57142 | .dst_temps = .{.mem}, |
| 57143 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57144 | .each = .{ .once = &.{ |
| 57145 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57146 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57147 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57148 | .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57149 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57150 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57151 | } }, |
| 57152 | }, .{ |
| 57153 | .required_features = .{ .avx, null, null, null }, |
| 57154 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57155 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57156 | .patterns = &.{ |
| 57157 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57158 | }, |
| 57159 | .call_frame = .{ .alignment = .@"16" }, |
| 57160 | .extra_temps = .{ |
| 57161 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57162 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57163 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57164 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57165 | .unused, |
| 57166 | .unused, |
| 57167 | .unused, |
| 57168 | .unused, |
| 57169 | .unused, |
| 57170 | }, |
| 57171 | .dst_temps = .{.mem}, |
| 57172 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57173 | .each = .{ .once = &.{ |
| 57174 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57175 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57176 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57177 | .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57178 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57179 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57180 | } }, |
| 57181 | }, .{ |
| 57182 | .required_features = .{ .sse4_1, .slow_incdec, null, null }, |
| 57183 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57184 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57185 | .patterns = &.{ |
| 57186 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57187 | }, |
| 57188 | .call_frame = .{ .alignment = .@"16" }, |
| 57189 | .extra_temps = .{ |
| 57190 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57191 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57192 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57193 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57194 | .unused, |
| 57195 | .unused, |
| 57196 | .unused, |
| 57197 | .unused, |
| 57198 | .unused, |
| 57199 | }, |
| 57200 | .dst_temps = .{.mem}, |
| 57201 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57202 | .each = .{ .once = &.{ |
| 57203 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57204 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57205 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57206 | .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57207 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57208 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57209 | } }, |
| 57210 | }, .{ |
| 57211 | .required_features = .{ .sse4_1, null, null, null }, |
| 57212 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57213 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57214 | .patterns = &.{ |
| 57215 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57216 | }, |
| 57217 | .call_frame = .{ .alignment = .@"16" }, |
| 57218 | .extra_temps = .{ |
| 57219 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57220 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57221 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57222 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57223 | .unused, |
| 57224 | .unused, |
| 57225 | .unused, |
| 57226 | .unused, |
| 57227 | .unused, |
| 57228 | }, |
| 57229 | .dst_temps = .{.mem}, |
| 57230 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57231 | .each = .{ .once = &.{ |
| 57232 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57233 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57234 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57235 | .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57236 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57237 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57238 | } }, |
| 57239 | }, .{ |
| 57240 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 57241 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57242 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57243 | .patterns = &.{ |
| 57244 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57245 | }, |
| 57246 | .call_frame = .{ .alignment = .@"16" }, |
| 57247 | .extra_temps = .{ |
| 57248 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57249 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57250 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57251 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57252 | .unused, |
| 57253 | .unused, |
| 57254 | .unused, |
| 57255 | .unused, |
| 57256 | .unused, |
| 57257 | }, |
| 57258 | .dst_temps = .{.mem}, |
| 57259 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57260 | .each = .{ .once = &.{ |
| 57261 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57262 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57263 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57264 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 57265 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57266 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57267 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57268 | } }, |
| 57269 | }, .{ |
| 57270 | .required_features = .{ .sse2, null, null, null }, |
| 57271 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57272 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57273 | .patterns = &.{ |
| 57274 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57275 | }, |
| 57276 | .call_frame = .{ .alignment = .@"16" }, |
| 57277 | .extra_temps = .{ |
| 57278 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57279 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57280 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57281 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57282 | .unused, |
| 57283 | .unused, |
| 57284 | .unused, |
| 57285 | .unused, |
| 57286 | .unused, |
| 57287 | }, |
| 57288 | .dst_temps = .{.mem}, |
| 57289 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57290 | .each = .{ .once = &.{ |
| 57291 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57292 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57293 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57294 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 57295 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57296 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57297 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57298 | } }, |
| 57299 | }, .{ |
| 57300 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 57301 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57302 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57303 | .patterns = &.{ |
| 57304 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57305 | }, |
| 57306 | .call_frame = .{ .alignment = .@"16" }, |
| 57307 | .extra_temps = .{ |
| 57308 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57309 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57310 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57311 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57312 | .{ .type = .f32, .kind = .mem }, |
| 57313 | .unused, |
| 57314 | .unused, |
| 57315 | .unused, |
| 57316 | .unused, |
| 57317 | }, |
| 57318 | .dst_temps = .{.mem}, |
| 57319 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57320 | .each = .{ .once = &.{ |
| 57321 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57322 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57323 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57324 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 57325 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 57326 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57327 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57328 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57329 | } }, |
| 57330 | }, .{ |
| 57331 | .required_features = .{ .sse, null, null, null }, |
| 57332 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57333 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57334 | .patterns = &.{ |
| 57335 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57336 | }, |
| 57337 | .call_frame = .{ .alignment = .@"16" }, |
| 57338 | .extra_temps = .{ |
| 57339 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57340 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57341 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57342 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57343 | .{ .type = .f32, .kind = .mem }, |
| 57344 | .unused, |
| 57345 | .unused, |
| 57346 | .unused, |
| 57347 | .unused, |
| 57348 | }, |
| 57349 | .dst_temps = .{.mem}, |
| 57350 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57351 | .each = .{ .once = &.{ |
| 57352 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57353 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57354 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57355 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 57356 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 57357 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57358 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57359 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57360 | } }, |
| 57361 | }, .{ |
| 57362 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 57363 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57364 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57365 | .patterns = &.{ |
| 57366 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57367 | }, |
| 57368 | .call_frame = .{ .alignment = .@"16" }, |
| 57369 | .extra_temps = .{ |
| 57370 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57371 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57372 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57373 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57374 | .unused, |
| 57375 | .unused, |
| 57376 | .unused, |
| 57377 | .unused, |
| 57378 | .unused, |
| 57379 | }, |
| 57380 | .dst_temps = .{.mem}, |
| 57381 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57382 | .each = .{ .once = &.{ |
| 57383 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57384 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57385 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57386 | .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57387 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57388 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57389 | } }, |
| 57390 | }, .{ |
| 57391 | .required_features = .{ .avx, null, null, null }, |
| 57392 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57393 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57394 | .patterns = &.{ |
| 57395 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57396 | }, |
| 57397 | .call_frame = .{ .alignment = .@"16" }, |
| 57398 | .extra_temps = .{ |
| 57399 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57400 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57401 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57402 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57403 | .unused, |
| 57404 | .unused, |
| 57405 | .unused, |
| 57406 | .unused, |
| 57407 | .unused, |
| 57408 | }, |
| 57409 | .dst_temps = .{.mem}, |
| 57410 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57411 | .each = .{ .once = &.{ |
| 57412 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57413 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57414 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57415 | .{ ._, .vp_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57416 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57417 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57418 | } }, |
| 57419 | }, .{ |
| 57420 | .required_features = .{ .sse4_1, .slow_incdec, null, null }, |
| 57421 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57422 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57423 | .patterns = &.{ |
| 57424 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57425 | }, |
| 57426 | .call_frame = .{ .alignment = .@"16" }, |
| 57427 | .extra_temps = .{ |
| 57428 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57429 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57430 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57431 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57432 | .unused, |
| 57433 | .unused, |
| 57434 | .unused, |
| 57435 | .unused, |
| 57436 | .unused, |
| 57437 | }, |
| 57438 | .dst_temps = .{.mem}, |
| 57439 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57440 | .each = .{ .once = &.{ |
| 57441 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57442 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57443 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57444 | .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57445 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57446 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57447 | } }, |
| 57448 | }, .{ |
| 57449 | .required_features = .{ .sse4_1, null, null, null }, |
| 57450 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57451 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57452 | .patterns = &.{ |
| 57453 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57454 | }, |
| 57455 | .call_frame = .{ .alignment = .@"16" }, |
| 57456 | .extra_temps = .{ |
| 57457 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57458 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57459 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57460 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57461 | .unused, |
| 57462 | .unused, |
| 57463 | .unused, |
| 57464 | .unused, |
| 57465 | .unused, |
| 57466 | }, |
| 57467 | .dst_temps = .{.mem}, |
| 57468 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57469 | .each = .{ .once = &.{ |
| 57470 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57471 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57472 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57473 | .{ ._, .p_w, .extr, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57474 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57475 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57476 | } }, |
| 57477 | }, .{ |
| 57478 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 57479 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57480 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57481 | .patterns = &.{ |
| 57482 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57483 | }, |
| 57484 | .call_frame = .{ .alignment = .@"16" }, |
| 57485 | .extra_temps = .{ |
| 57486 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57487 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57488 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57489 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57490 | .unused, |
| 57491 | .unused, |
| 57492 | .unused, |
| 57493 | .unused, |
| 57494 | .unused, |
| 57495 | }, |
| 57496 | .dst_temps = .{.mem}, |
| 57497 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57498 | .each = .{ .once = &.{ |
| 57499 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57500 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57501 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57502 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 57503 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57504 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57505 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57506 | } }, |
| 57507 | }, .{ |
| 57508 | .required_features = .{ .sse2, null, null, null }, |
| 57509 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57510 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57511 | .patterns = &.{ |
| 57512 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57513 | }, |
| 57514 | .call_frame = .{ .alignment = .@"16" }, |
| 57515 | .extra_temps = .{ |
| 57516 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57517 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57518 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57519 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57520 | .unused, |
| 57521 | .unused, |
| 57522 | .unused, |
| 57523 | .unused, |
| 57524 | .unused, |
| 57525 | }, |
| 57526 | .dst_temps = .{.mem}, |
| 57527 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57528 | .each = .{ .once = &.{ |
| 57529 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57530 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57531 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57532 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 57533 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57534 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57535 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57536 | } }, |
| 57537 | }, .{ |
| 57538 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 57539 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57540 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57541 | .patterns = &.{ |
| 57542 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57543 | }, |
| 57544 | .call_frame = .{ .alignment = .@"16" }, |
| 57545 | .extra_temps = .{ |
| 57546 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57547 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57548 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57549 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57550 | .{ .type = .f32, .kind = .mem }, |
| 57551 | .unused, |
| 57552 | .unused, |
| 57553 | .unused, |
| 57554 | .unused, |
| 57555 | }, |
| 57556 | .dst_temps = .{.mem}, |
| 57557 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57558 | .each = .{ .once = &.{ |
| 57559 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57560 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57561 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57562 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 57563 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 57564 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57565 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 57566 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57567 | } }, |
| 57568 | }, .{ |
| 57569 | .required_features = .{ .sse, null, null, null }, |
| 57570 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 57571 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57572 | .patterns = &.{ |
| 57573 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57574 | }, |
| 57575 | .call_frame = .{ .alignment = .@"16" }, |
| 57576 | .extra_temps = .{ |
| 57577 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57578 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57579 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57580 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57581 | .{ .type = .f32, .kind = .mem }, |
| 57582 | .unused, |
| 57583 | .unused, |
| 57584 | .unused, |
| 57585 | .unused, |
| 57586 | }, |
| 57587 | .dst_temps = .{.mem}, |
| 57588 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57589 | .each = .{ .once = &.{ |
| 57590 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57591 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57592 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57593 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 57594 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 57595 | .{ ._, ._, .mov, .memsia(.dst0w, .@"2", .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57596 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 57597 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 57598 | } }, |
| 57599 | }, .{ |
| 57600 | .required_features = .{ .f16c, null, null, null }, |
| 57601 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 57602 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 57603 | .patterns = &.{ |
| 57604 | .{ .src = .{ .mem, .none, .none } }, |
| 57605 | .{ .src = .{ .to_sse, .none, .none } }, |
| 57606 | }, |
| 57607 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 57608 | .each = .{ .once = &.{ |
| 57609 | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 57610 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 57611 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 57612 | } }, |
| 57613 | }, .{ |
| 57614 | .required_features = .{ .f16c, .avx2, null, null }, |
| 57615 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 57616 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57617 | .patterns = &.{ |
| 57618 | .{ .src = .{ .mem, .none, .none } }, |
| 57619 | .{ .src = .{ .to_sse, .none, .none } }, |
| 57620 | }, |
| 57621 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 57622 | .each = .{ .once = &.{ |
| 57623 | .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ }, |
| 57624 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 57625 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 57626 | } }, |
| 57627 | }, .{ |
| 57628 | .required_features = .{ .f16c, null, null, null }, |
| 57629 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 57630 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 57631 | .patterns = &.{ |
| 57632 | .{ .src = .{ .mem, .none, .none } }, |
| 57633 | .{ .src = .{ .to_sse, .none, .none } }, |
| 57634 | }, |
| 57635 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 57636 | .each = .{ .once = &.{ |
| 57637 | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 57638 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 57639 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 57640 | } }, |
| 57641 | }, .{ |
| 57642 | .required_features = .{ .f16c, .avx2, null, null }, |
| 57643 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 57644 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57645 | .patterns = &.{ |
| 57646 | .{ .src = .{ .mem, .none, .none } }, |
| 57647 | .{ .src = .{ .to_sse, .none, .none } }, |
| 57648 | }, |
| 57649 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 57650 | .each = .{ .once = &.{ |
| 57651 | .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ }, |
| 57652 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 57653 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 57654 | } }, |
| 57655 | }, .{ |
| 57656 | .required_features = .{ .f16c, .avx2, null, null }, |
| 57657 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 57658 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57659 | .patterns = &.{ |
| 57660 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57661 | }, |
| 57662 | .extra_temps = .{ |
| 57663 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57664 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 57665 | .unused, |
| 57666 | .unused, |
| 57667 | .unused, |
| 57668 | .unused, |
| 57669 | .unused, |
| 57670 | .unused, |
| 57671 | .unused, |
| 57672 | }, |
| 57673 | .dst_temps = .{.mem}, |
| 57674 | .clobbers = .{ .eflags = true }, |
| 57675 | .each = .{ .once = &.{ |
| 57676 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57677 | .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57678 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 57679 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 57680 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 57681 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57682 | } }, |
| 57683 | }, .{ |
| 57684 | .required_features = .{ .f16c, null, null, null }, |
| 57685 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 57686 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }}, |
| 57687 | .patterns = &.{ |
| 57688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57689 | }, |
| 57690 | .extra_temps = .{ |
| 57691 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57692 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 57693 | .unused, |
| 57694 | .unused, |
| 57695 | .unused, |
| 57696 | .unused, |
| 57697 | .unused, |
| 57698 | .unused, |
| 57699 | .unused, |
| 57700 | }, |
| 57701 | .dst_temps = .{.mem}, |
| 57702 | .clobbers = .{ .eflags = true }, |
| 57703 | .each = .{ .once = &.{ |
| 57704 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57705 | .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57706 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 57707 | .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, |
| 57708 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 57709 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57710 | } }, |
| 57711 | }, .{ |
| 57712 | .required_features = .{ .f16c, .avx2, null, null }, |
| 57713 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 57714 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 57715 | .patterns = &.{ |
| 57716 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57717 | }, |
| 57718 | .extra_temps = .{ |
| 57719 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57720 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 57721 | .unused, |
| 57722 | .unused, |
| 57723 | .unused, |
| 57724 | .unused, |
| 57725 | .unused, |
| 57726 | .unused, |
| 57727 | .unused, |
| 57728 | }, |
| 57729 | .dst_temps = .{.mem}, |
| 57730 | .clobbers = .{ .eflags = true }, |
| 57731 | .each = .{ .once = &.{ |
| 57732 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57733 | .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57734 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 57735 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 57736 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 57737 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57738 | } }, |
| 57739 | }, .{ |
| 57740 | .required_features = .{ .f16c, null, null, null }, |
| 57741 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 57742 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }}, |
| 57743 | .patterns = &.{ |
| 57744 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57745 | }, |
| 57746 | .extra_temps = .{ |
| 57747 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57748 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 57749 | .unused, |
| 57750 | .unused, |
| 57751 | .unused, |
| 57752 | .unused, |
| 57753 | .unused, |
| 57754 | .unused, |
| 57755 | .unused, |
| 57756 | }, |
| 57757 | .dst_temps = .{.mem}, |
| 57758 | .clobbers = .{ .eflags = true }, |
| 57759 | .each = .{ .once = &.{ |
| 57760 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57761 | .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57762 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 57763 | .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, |
| 57764 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 57765 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57766 | } }, |
| 57767 | }, .{ |
| 57768 | .required_features = .{ .avx, null, null, null }, |
| 57769 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57770 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57771 | .patterns = &.{ |
| 57772 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57773 | }, |
| 57774 | .call_frame = .{ .alignment = .@"16" }, |
| 57775 | .extra_temps = .{ |
| 57776 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57777 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57778 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57779 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57780 | .unused, |
| 57781 | .unused, |
| 57782 | .unused, |
| 57783 | .unused, |
| 57784 | .unused, |
| 57785 | }, |
| 57786 | .dst_temps = .{.mem}, |
| 57787 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57788 | .each = .{ .once = &.{ |
| 57789 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57790 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57791 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57792 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57793 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57794 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57795 | } }, |
| 57796 | }, .{ |
| 57797 | .required_features = .{ .sse4_1, null, null, null }, |
| 57798 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57799 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57800 | .patterns = &.{ |
| 57801 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57802 | }, |
| 57803 | .call_frame = .{ .alignment = .@"16" }, |
| 57804 | .extra_temps = .{ |
| 57805 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57806 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57807 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57808 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57809 | .unused, |
| 57810 | .unused, |
| 57811 | .unused, |
| 57812 | .unused, |
| 57813 | .unused, |
| 57814 | }, |
| 57815 | .dst_temps = .{.mem}, |
| 57816 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57817 | .each = .{ .once = &.{ |
| 57818 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57819 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57820 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57821 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57822 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57823 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57824 | } }, |
| 57825 | }, .{ |
| 57826 | .required_features = .{ .sse2, null, null, null }, |
| 57827 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57828 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57829 | .patterns = &.{ |
| 57830 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57831 | }, |
| 57832 | .call_frame = .{ .alignment = .@"16" }, |
| 57833 | .extra_temps = .{ |
| 57834 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57835 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57836 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57837 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57838 | .unused, |
| 57839 | .unused, |
| 57840 | .unused, |
| 57841 | .unused, |
| 57842 | .unused, |
| 57843 | }, |
| 57844 | .dst_temps = .{.mem}, |
| 57845 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57846 | .each = .{ .once = &.{ |
| 57847 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57848 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57849 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57850 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 57851 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57852 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57853 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57854 | } }, |
| 57855 | }, .{ |
| 57856 | .required_features = .{ .sse, null, null, null }, |
| 57857 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57858 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57859 | .patterns = &.{ |
| 57860 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57861 | }, |
| 57862 | .call_frame = .{ .alignment = .@"16" }, |
| 57863 | .extra_temps = .{ |
| 57864 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57865 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 57866 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 57867 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57868 | .{ .type = .f32, .kind = .mem }, |
| 57869 | .unused, |
| 57870 | .unused, |
| 57871 | .unused, |
| 57872 | .unused, |
| 57873 | }, |
| 57874 | .dst_temps = .{.mem}, |
| 57875 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57876 | .each = .{ .once = &.{ |
| 57877 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57878 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57879 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57880 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 57881 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 57882 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57883 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57884 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57885 | } }, |
| 57886 | }, .{ |
| 57887 | .required_features = .{ .avx, null, null, null }, |
| 57888 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57889 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57890 | .patterns = &.{ |
| 57891 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57892 | }, |
| 57893 | .call_frame = .{ .alignment = .@"16" }, |
| 57894 | .extra_temps = .{ |
| 57895 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57896 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57897 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57898 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57899 | .unused, |
| 57900 | .unused, |
| 57901 | .unused, |
| 57902 | .unused, |
| 57903 | .unused, |
| 57904 | }, |
| 57905 | .dst_temps = .{.mem}, |
| 57906 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57907 | .each = .{ .once = &.{ |
| 57908 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57909 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57910 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57911 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57912 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57913 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57914 | } }, |
| 57915 | }, .{ |
| 57916 | .required_features = .{ .sse4_1, null, null, null }, |
| 57917 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57918 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57919 | .patterns = &.{ |
| 57920 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57921 | }, |
| 57922 | .call_frame = .{ .alignment = .@"16" }, |
| 57923 | .extra_temps = .{ |
| 57924 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57925 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57926 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57927 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57928 | .unused, |
| 57929 | .unused, |
| 57930 | .unused, |
| 57931 | .unused, |
| 57932 | .unused, |
| 57933 | }, |
| 57934 | .dst_temps = .{.mem}, |
| 57935 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57936 | .each = .{ .once = &.{ |
| 57937 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57938 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57939 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57940 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 57941 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57942 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57943 | } }, |
| 57944 | }, .{ |
| 57945 | .required_features = .{ .sse2, null, null, null }, |
| 57946 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57947 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57948 | .patterns = &.{ |
| 57949 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57950 | }, |
| 57951 | .call_frame = .{ .alignment = .@"16" }, |
| 57952 | .extra_temps = .{ |
| 57953 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57954 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57955 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57956 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57957 | .unused, |
| 57958 | .unused, |
| 57959 | .unused, |
| 57960 | .unused, |
| 57961 | .unused, |
| 57962 | }, |
| 57963 | .dst_temps = .{.mem}, |
| 57964 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57965 | .each = .{ .once = &.{ |
| 57966 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57967 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57968 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57969 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 57970 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 57971 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 57972 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 57973 | } }, |
| 57974 | }, .{ |
| 57975 | .required_features = .{ .sse, null, null, null }, |
| 57976 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 57977 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 57978 | .patterns = &.{ |
| 57979 | .{ .src = .{ .to_mem, .none, .none } }, |
| 57980 | }, |
| 57981 | .call_frame = .{ .alignment = .@"16" }, |
| 57982 | .extra_temps = .{ |
| 57983 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 57984 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 57985 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 57986 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 57987 | .{ .type = .f32, .kind = .mem }, |
| 57988 | .unused, |
| 57989 | .unused, |
| 57990 | .unused, |
| 57991 | .unused, |
| 57992 | }, |
| 57993 | .dst_temps = .{.mem}, |
| 57994 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 57995 | .each = .{ .once = &.{ |
| 57996 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 57997 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 57998 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 57999 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 58000 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 58001 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58002 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58003 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58004 | } }, |
| 58005 | }, .{ |
| 58006 | .required_features = .{ .f16c, null, null, null }, |
| 58007 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 58008 | .dst_constraints = .{.{ .scalar_float = .{ .of = .qword, .is = .word } }}, |
| 58009 | .patterns = &.{ |
| 58010 | .{ .src = .{ .mem, .none, .none } }, |
| 58011 | .{ .src = .{ .to_sse, .none, .none } }, |
| 58012 | }, |
| 58013 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 58014 | .each = .{ .once = &.{ |
| 58015 | .{ ._, .v_ps, .cvtdq2, .dst0x, .src0x, ._, ._ }, |
| 58016 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, |
| 58017 | } }, |
| 58018 | }, .{ |
| 58019 | .required_features = .{ .f16c, .avx2, null, null }, |
| 58020 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 58021 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .word } }}, |
| 58022 | .patterns = &.{ |
| 58023 | .{ .src = .{ .mem, .none, .none } }, |
| 58024 | .{ .src = .{ .to_sse, .none, .none } }, |
| 58025 | }, |
| 58026 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 58027 | .each = .{ .once = &.{ |
| 58028 | .{ ._, .v_ps, .cvtdq2, .dst0y, .src0y, ._, ._ }, |
| 58029 | .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ }, |
| 58030 | } }, |
| 58031 | }, .{ |
| 58032 | .required_features = .{ .f16c, .avx2, null, null }, |
| 58033 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 58034 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .word } }}, |
| 58035 | .patterns = &.{ |
| 58036 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58037 | }, |
| 58038 | .extra_temps = .{ |
| 58039 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58040 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 58041 | .unused, |
| 58042 | .unused, |
| 58043 | .unused, |
| 58044 | .unused, |
| 58045 | .unused, |
| 58046 | .unused, |
| 58047 | .unused, |
| 58048 | }, |
| 58049 | .dst_temps = .{.mem}, |
| 58050 | .clobbers = .{ .eflags = true }, |
| 58051 | .each = .{ .once = &.{ |
| 58052 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58053 | .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memsia(.src0y, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58054 | .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ }, |
| 58055 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 58056 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58057 | } }, |
| 58058 | }, .{ |
| 58059 | .required_features = .{ .f16c, null, null, null }, |
| 58060 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 58061 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }}, |
| 58062 | .patterns = &.{ |
| 58063 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58064 | }, |
| 58065 | .extra_temps = .{ |
| 58066 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58067 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 58068 | .unused, |
| 58069 | .unused, |
| 58070 | .unused, |
| 58071 | .unused, |
| 58072 | .unused, |
| 58073 | .unused, |
| 58074 | .unused, |
| 58075 | }, |
| 58076 | .dst_temps = .{.mem}, |
| 58077 | .clobbers = .{ .eflags = true }, |
| 58078 | .each = .{ .once = &.{ |
| 58079 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58080 | .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memsia(.src0x, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58081 | .{ ._, .v_, .cvtps2ph, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, .rm(.{}), ._ }, |
| 58082 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 58083 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58084 | } }, |
| 58085 | }, .{ |
| 58086 | .required_features = .{ .avx, null, null, null }, |
| 58087 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58088 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58089 | .patterns = &.{ |
| 58090 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58091 | }, |
| 58092 | .call_frame = .{ .alignment = .@"16" }, |
| 58093 | .extra_temps = .{ |
| 58094 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58095 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 58096 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 58097 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58098 | .unused, |
| 58099 | .unused, |
| 58100 | .unused, |
| 58101 | .unused, |
| 58102 | .unused, |
| 58103 | }, |
| 58104 | .dst_temps = .{.mem}, |
| 58105 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58106 | .each = .{ .once = &.{ |
| 58107 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58108 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58109 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58110 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58111 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58112 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58113 | } }, |
| 58114 | }, .{ |
| 58115 | .required_features = .{ .sse4_1, null, null, null }, |
| 58116 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58117 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58118 | .patterns = &.{ |
| 58119 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58120 | }, |
| 58121 | .call_frame = .{ .alignment = .@"16" }, |
| 58122 | .extra_temps = .{ |
| 58123 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58124 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 58125 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 58126 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58127 | .unused, |
| 58128 | .unused, |
| 58129 | .unused, |
| 58130 | .unused, |
| 58131 | .unused, |
| 58132 | }, |
| 58133 | .dst_temps = .{.mem}, |
| 58134 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58135 | .each = .{ .once = &.{ |
| 58136 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58137 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58138 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58139 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58140 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58141 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58142 | } }, |
| 58143 | }, .{ |
| 58144 | .required_features = .{ .sse2, null, null, null }, |
| 58145 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58146 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58147 | .patterns = &.{ |
| 58148 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58149 | }, |
| 58150 | .call_frame = .{ .alignment = .@"16" }, |
| 58151 | .extra_temps = .{ |
| 58152 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58153 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 58154 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 58155 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58156 | .unused, |
| 58157 | .unused, |
| 58158 | .unused, |
| 58159 | .unused, |
| 58160 | .unused, |
| 58161 | }, |
| 58162 | .dst_temps = .{.mem}, |
| 58163 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58164 | .each = .{ .once = &.{ |
| 58165 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58166 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58167 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58168 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 58169 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58170 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58171 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58172 | } }, |
| 58173 | }, .{ |
| 58174 | .required_features = .{ .sse, null, null, null }, |
| 58175 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58176 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58177 | .patterns = &.{ |
| 58178 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58179 | }, |
| 58180 | .call_frame = .{ .alignment = .@"16" }, |
| 58181 | .extra_temps = .{ |
| 58182 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58183 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 58184 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, |
| 58185 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58186 | .{ .type = .f32, .kind = .mem }, |
| 58187 | .unused, |
| 58188 | .unused, |
| 58189 | .unused, |
| 58190 | .unused, |
| 58191 | }, |
| 58192 | .dst_temps = .{.mem}, |
| 58193 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58194 | .each = .{ .once = &.{ |
| 58195 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58196 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58197 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58198 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 58199 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 58200 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58201 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58202 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58203 | } }, |
| 58204 | }, .{ |
| 58205 | .required_features = .{ .avx, null, null, null }, |
| 58206 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58207 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58208 | .patterns = &.{ |
| 58209 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58210 | }, |
| 58211 | .call_frame = .{ .alignment = .@"16" }, |
| 58212 | .extra_temps = .{ |
| 58213 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58214 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 58215 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 58216 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58217 | .unused, |
| 58218 | .unused, |
| 58219 | .unused, |
| 58220 | .unused, |
| 58221 | .unused, |
| 58222 | }, |
| 58223 | .dst_temps = .{.mem}, |
| 58224 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58225 | .each = .{ .once = &.{ |
| 58226 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58227 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58228 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58229 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58230 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58231 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58232 | } }, |
| 58233 | }, .{ |
| 58234 | .required_features = .{ .sse4_1, null, null, null }, |
| 58235 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58236 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58237 | .patterns = &.{ |
| 58238 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58239 | }, |
| 58240 | .call_frame = .{ .alignment = .@"16" }, |
| 58241 | .extra_temps = .{ |
| 58242 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58243 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 58244 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 58245 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58246 | .unused, |
| 58247 | .unused, |
| 58248 | .unused, |
| 58249 | .unused, |
| 58250 | .unused, |
| 58251 | }, |
| 58252 | .dst_temps = .{.mem}, |
| 58253 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58254 | .each = .{ .once = &.{ |
| 58255 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58256 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58257 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58258 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58259 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58260 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58261 | } }, |
| 58262 | }, .{ |
| 58263 | .required_features = .{ .sse2, null, null, null }, |
| 58264 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58265 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58266 | .patterns = &.{ |
| 58267 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58268 | }, |
| 58269 | .call_frame = .{ .alignment = .@"16" }, |
| 58270 | .extra_temps = .{ |
| 58271 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58272 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 58273 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 58274 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58275 | .unused, |
| 58276 | .unused, |
| 58277 | .unused, |
| 58278 | .unused, |
| 58279 | .unused, |
| 58280 | }, |
| 58281 | .dst_temps = .{.mem}, |
| 58282 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58283 | .each = .{ .once = &.{ |
| 58284 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58285 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58286 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58287 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 58288 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58289 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58290 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58291 | } }, |
| 58292 | }, .{ |
| 58293 | .required_features = .{ .sse, null, null, null }, |
| 58294 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58295 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58296 | .patterns = &.{ |
| 58297 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58298 | }, |
| 58299 | .call_frame = .{ .alignment = .@"16" }, |
| 58300 | .extra_temps = .{ |
| 58301 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58302 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 58303 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, |
| 58304 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58305 | .{ .type = .f32, .kind = .mem }, |
| 58306 | .unused, |
| 58307 | .unused, |
| 58308 | .unused, |
| 58309 | .unused, |
| 58310 | }, |
| 58311 | .dst_temps = .{.mem}, |
| 58312 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58313 | .each = .{ .once = &.{ |
| 58314 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58315 | .{ .@"0:", ._, .mov, .tmp1d, .memsia(.src0d, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58316 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58317 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 58318 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 58319 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58320 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58321 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58322 | } }, |
| 58323 | }, .{ |
| 58324 | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 58325 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58326 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58327 | .patterns = &.{ |
| 58328 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58329 | }, |
| 58330 | .extra_temps = .{ |
| 58331 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58332 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| 58333 | .unused, |
| 58334 | .unused, |
| 58335 | .unused, |
| 58336 | .unused, |
| 58337 | .unused, |
| 58338 | .unused, |
| 58339 | .unused, |
| 58340 | }, |
| 58341 | .dst_temps = .{.mem}, |
| 58342 | .clobbers = .{ .eflags = true }, |
| 58343 | .each = .{ .once = &.{ |
| 58344 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58345 | .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 58346 | .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._ }, |
| 58347 | .{ ._, .v_, .cvtps2ph, .tmp1q, .tmp1x, .rm(.{}), ._ }, |
| 58348 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ }, |
| 58349 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58350 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58351 | } }, |
| 58352 | }, .{ |
| 58353 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 58354 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58355 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58356 | .patterns = &.{ |
| 58357 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58358 | }, |
| 58359 | .call_frame = .{ .alignment = .@"16" }, |
| 58360 | .extra_temps = .{ |
| 58361 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58362 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 58363 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, |
| 58364 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58365 | .unused, |
| 58366 | .unused, |
| 58367 | .unused, |
| 58368 | .unused, |
| 58369 | .unused, |
| 58370 | }, |
| 58371 | .dst_temps = .{.mem}, |
| 58372 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58373 | .each = .{ .once = &.{ |
| 58374 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58375 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58376 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58377 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58378 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58379 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58380 | } }, |
| 58381 | }, .{ |
| 58382 | .required_features = .{ .@"64bit", .sse4_1, null, null }, |
| 58383 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58384 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58385 | .patterns = &.{ |
| 58386 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58387 | }, |
| 58388 | .call_frame = .{ .alignment = .@"16" }, |
| 58389 | .extra_temps = .{ |
| 58390 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58391 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 58392 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, |
| 58393 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58394 | .unused, |
| 58395 | .unused, |
| 58396 | .unused, |
| 58397 | .unused, |
| 58398 | .unused, |
| 58399 | }, |
| 58400 | .dst_temps = .{.mem}, |
| 58401 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58402 | .each = .{ .once = &.{ |
| 58403 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58404 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58405 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58406 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58407 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58408 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58409 | } }, |
| 58410 | }, .{ |
| 58411 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 58412 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58413 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58414 | .patterns = &.{ |
| 58415 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58416 | }, |
| 58417 | .call_frame = .{ .alignment = .@"16" }, |
| 58418 | .extra_temps = .{ |
| 58419 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58420 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 58421 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, |
| 58422 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58423 | .unused, |
| 58424 | .unused, |
| 58425 | .unused, |
| 58426 | .unused, |
| 58427 | .unused, |
| 58428 | }, |
| 58429 | .dst_temps = .{.mem}, |
| 58430 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58431 | .each = .{ .once = &.{ |
| 58432 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58433 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58434 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58435 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 58436 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58437 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58438 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58439 | } }, |
| 58440 | }, .{ |
| 58441 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 58442 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58443 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58444 | .patterns = &.{ |
| 58445 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58446 | }, |
| 58447 | .call_frame = .{ .alignment = .@"16" }, |
| 58448 | .extra_temps = .{ |
| 58449 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58450 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 58451 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, |
| 58452 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58453 | .{ .type = .f32, .kind = .mem }, |
| 58454 | .unused, |
| 58455 | .unused, |
| 58456 | .unused, |
| 58457 | .unused, |
| 58458 | }, |
| 58459 | .dst_temps = .{.mem}, |
| 58460 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58461 | .each = .{ .once = &.{ |
| 58462 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58463 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58464 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58465 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 58466 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 58467 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58468 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58469 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58470 | } }, |
| 58471 | }, .{ |
| 58472 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 58473 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58474 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58475 | .patterns = &.{ |
| 58476 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58477 | }, |
| 58478 | .call_frame = .{ .alignment = .@"16" }, |
| 58479 | .extra_temps = .{ |
| 58480 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58481 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58482 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, |
| 58483 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58484 | .unused, |
| 58485 | .unused, |
| 58486 | .unused, |
| 58487 | .unused, |
| 58488 | .unused, |
| 58489 | }, |
| 58490 | .dst_temps = .{.mem}, |
| 58491 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58492 | .each = .{ .once = &.{ |
| 58493 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58494 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58495 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58496 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58497 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58498 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58499 | } }, |
| 58500 | }, .{ |
| 58501 | .required_features = .{ .@"64bit", .sse4_1, null, null }, |
| 58502 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58503 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58504 | .patterns = &.{ |
| 58505 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58506 | }, |
| 58507 | .call_frame = .{ .alignment = .@"16" }, |
| 58508 | .extra_temps = .{ |
| 58509 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58510 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58511 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, |
| 58512 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58513 | .unused, |
| 58514 | .unused, |
| 58515 | .unused, |
| 58516 | .unused, |
| 58517 | .unused, |
| 58518 | }, |
| 58519 | .dst_temps = .{.mem}, |
| 58520 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58521 | .each = .{ .once = &.{ |
| 58522 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58523 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58524 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58525 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp3x, .ui(0), ._ }, |
| 58526 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58527 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58528 | } }, |
| 58529 | }, .{ |
| 58530 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 58531 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58532 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58533 | .patterns = &.{ |
| 58534 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58535 | }, |
| 58536 | .call_frame = .{ .alignment = .@"16" }, |
| 58537 | .extra_temps = .{ |
| 58538 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58539 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58540 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, |
| 58541 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58542 | .unused, |
| 58543 | .unused, |
| 58544 | .unused, |
| 58545 | .unused, |
| 58546 | .unused, |
| 58547 | }, |
| 58548 | .dst_temps = .{.mem}, |
| 58549 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58550 | .each = .{ .once = &.{ |
| 58551 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58552 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58553 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58554 | .{ ._, .p_w, .extr, .tmp1d, .tmp3x, .ui(0), ._ }, |
| 58555 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58556 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58557 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58558 | } }, |
| 58559 | }, .{ |
| 58560 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 58561 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 58562 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58563 | .patterns = &.{ |
| 58564 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58565 | }, |
| 58566 | .call_frame = .{ .alignment = .@"16" }, |
| 58567 | .extra_temps = .{ |
| 58568 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58569 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58570 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, |
| 58571 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58572 | .{ .type = .f32, .kind = .mem }, |
| 58573 | .unused, |
| 58574 | .unused, |
| 58575 | .unused, |
| 58576 | .unused, |
| 58577 | }, |
| 58578 | .dst_temps = .{.mem}, |
| 58579 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58580 | .each = .{ .once = &.{ |
| 58581 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58582 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58583 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 58584 | .{ ._, ._ss, .mov, .tmp4d, .tmp3d, ._, ._ }, |
| 58585 | .{ ._, ._, .mov, .tmp1d, .tmp4d, ._, ._ }, |
| 58586 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58587 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58588 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58589 | } }, |
| 58590 | }, .{ |
| 58591 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 58592 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58593 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58594 | .patterns = &.{ |
| 58595 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58596 | }, |
| 58597 | .call_frame = .{ .alignment = .@"16" }, |
| 58598 | .extra_temps = .{ |
| 58599 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58600 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58601 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 58602 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, |
| 58603 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58604 | .unused, |
| 58605 | .unused, |
| 58606 | .unused, |
| 58607 | .unused, |
| 58608 | }, |
| 58609 | .dst_temps = .{.mem}, |
| 58610 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58611 | .each = .{ .once = &.{ |
| 58612 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58613 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58614 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58615 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58616 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, |
| 58617 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58618 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58619 | } }, |
| 58620 | }, .{ |
| 58621 | .required_features = .{ .@"64bit", .sse4_1, null, null }, |
| 58622 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58623 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58624 | .patterns = &.{ |
| 58625 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58626 | }, |
| 58627 | .call_frame = .{ .alignment = .@"16" }, |
| 58628 | .extra_temps = .{ |
| 58629 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58630 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58631 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 58632 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, |
| 58633 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58634 | .unused, |
| 58635 | .unused, |
| 58636 | .unused, |
| 58637 | .unused, |
| 58638 | }, |
| 58639 | .dst_temps = .{.mem}, |
| 58640 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58641 | .each = .{ .once = &.{ |
| 58642 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58643 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58644 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58645 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58646 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, |
| 58647 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58648 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58649 | } }, |
| 58650 | }, .{ |
| 58651 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 58652 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58653 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58654 | .patterns = &.{ |
| 58655 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58656 | }, |
| 58657 | .call_frame = .{ .alignment = .@"16" }, |
| 58658 | .extra_temps = .{ |
| 58659 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58660 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58661 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 58662 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, |
| 58663 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58664 | .unused, |
| 58665 | .unused, |
| 58666 | .unused, |
| 58667 | .unused, |
| 58668 | }, |
| 58669 | .dst_temps = .{.mem}, |
| 58670 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58671 | .each = .{ .once = &.{ |
| 58672 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58673 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58674 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58675 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58676 | .{ ._, .p_w, .extr, .tmp1d, .tmp4x, .ui(0), ._ }, |
| 58677 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58678 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58679 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58680 | } }, |
| 58681 | }, .{ |
| 58682 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 58683 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58684 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58685 | .patterns = &.{ |
| 58686 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58687 | }, |
| 58688 | .call_frame = .{ .alignment = .@"16" }, |
| 58689 | .extra_temps = .{ |
| 58690 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58691 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58692 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 58693 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, |
| 58694 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58695 | .{ .type = .f32, .kind = .mem }, |
| 58696 | .unused, |
| 58697 | .unused, |
| 58698 | .unused, |
| 58699 | }, |
| 58700 | .dst_temps = .{.mem}, |
| 58701 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58702 | .each = .{ .once = &.{ |
| 58703 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58704 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58705 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58706 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58707 | .{ ._, ._ss, .mov, .tmp5d, .tmp4d, ._, ._ }, |
| 58708 | .{ ._, ._, .mov, .tmp1d, .tmp5d, ._, ._ }, |
| 58709 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58710 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58711 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58712 | } }, |
| 58713 | }, .{ |
| 58714 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 58715 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58716 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58717 | .patterns = &.{ |
| 58718 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58719 | }, |
| 58720 | .call_frame = .{ .alignment = .@"16" }, |
| 58721 | .extra_temps = .{ |
| 58722 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58723 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58724 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 58725 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, |
| 58726 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58727 | .unused, |
| 58728 | .unused, |
| 58729 | .unused, |
| 58730 | .unused, |
| 58731 | }, |
| 58732 | .dst_temps = .{.mem}, |
| 58733 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58734 | .each = .{ .once = &.{ |
| 58735 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58736 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58737 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58738 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58739 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, |
| 58740 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58741 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58742 | } }, |
| 58743 | }, .{ |
| 58744 | .required_features = .{ .@"64bit", .sse4_1, null, null }, |
| 58745 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58746 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58747 | .patterns = &.{ |
| 58748 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58749 | }, |
| 58750 | .call_frame = .{ .alignment = .@"16" }, |
| 58751 | .extra_temps = .{ |
| 58752 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58753 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58754 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 58755 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, |
| 58756 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58757 | .unused, |
| 58758 | .unused, |
| 58759 | .unused, |
| 58760 | .unused, |
| 58761 | }, |
| 58762 | .dst_temps = .{.mem}, |
| 58763 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58764 | .each = .{ .once = &.{ |
| 58765 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58766 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58767 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58768 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58769 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4x, .ui(0), ._ }, |
| 58770 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58771 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58772 | } }, |
| 58773 | }, .{ |
| 58774 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 58775 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58776 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58777 | .patterns = &.{ |
| 58778 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58779 | }, |
| 58780 | .call_frame = .{ .alignment = .@"16" }, |
| 58781 | .extra_temps = .{ |
| 58782 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58783 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58784 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 58785 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, |
| 58786 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58787 | .unused, |
| 58788 | .unused, |
| 58789 | .unused, |
| 58790 | .unused, |
| 58791 | }, |
| 58792 | .dst_temps = .{.mem}, |
| 58793 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58794 | .each = .{ .once = &.{ |
| 58795 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58796 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58797 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58798 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58799 | .{ ._, .p_w, .extr, .tmp1d, .tmp4x, .ui(0), ._ }, |
| 58800 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58801 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58802 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58803 | } }, |
| 58804 | }, .{ |
| 58805 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 58806 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 58807 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58808 | .patterns = &.{ |
| 58809 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58810 | }, |
| 58811 | .call_frame = .{ .alignment = .@"16" }, |
| 58812 | .extra_temps = .{ |
| 58813 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58814 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 58815 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 58816 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, |
| 58817 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58818 | .{ .type = .f32, .kind = .mem }, |
| 58819 | .unused, |
| 58820 | .unused, |
| 58821 | .unused, |
| 58822 | }, |
| 58823 | .dst_temps = .{.mem}, |
| 58824 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58825 | .each = .{ .once = &.{ |
| 58826 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58827 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_unaligned_size), ._, ._ }, |
| 58828 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 58829 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 58830 | .{ ._, ._ss, .mov, .tmp5d, .tmp4d, ._, ._ }, |
| 58831 | .{ ._, ._, .mov, .tmp1d, .tmp5d, ._, ._ }, |
| 58832 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| 58833 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 58834 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58835 | } }, |
| 58836 | }, .{ |
| 58837 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 58838 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58839 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58840 | .patterns = &.{ |
| 58841 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58842 | }, |
| 58843 | .call_frame = .{ .alignment = .@"16" }, |
| 58844 | .extra_temps = .{ |
| 58845 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 58846 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58847 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 58848 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 58849 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, |
| 58850 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58851 | .unused, |
| 58852 | .unused, |
| 58853 | .unused, |
| 58854 | }, |
| 58855 | .dst_temps = .{.mem}, |
| 58856 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58857 | .each = .{ .once = &.{ |
| 58858 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 58859 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58860 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 58861 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 58862 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 58863 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, |
| 58864 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 58865 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 58866 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58867 | } }, |
| 58868 | }, .{ |
| 58869 | .required_features = .{ .@"64bit", .sse4_1, null, null }, |
| 58870 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58871 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58872 | .patterns = &.{ |
| 58873 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58874 | }, |
| 58875 | .call_frame = .{ .alignment = .@"16" }, |
| 58876 | .extra_temps = .{ |
| 58877 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 58878 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58879 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 58880 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 58881 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, |
| 58882 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58883 | .unused, |
| 58884 | .unused, |
| 58885 | .unused, |
| 58886 | }, |
| 58887 | .dst_temps = .{.mem}, |
| 58888 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58889 | .each = .{ .once = &.{ |
| 58890 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 58891 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58892 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 58893 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 58894 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 58895 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, |
| 58896 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 58897 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 58898 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58899 | } }, |
| 58900 | }, .{ |
| 58901 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 58902 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58903 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58904 | .patterns = &.{ |
| 58905 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58906 | }, |
| 58907 | .call_frame = .{ .alignment = .@"16" }, |
| 58908 | .extra_temps = .{ |
| 58909 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 58910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58911 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 58912 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 58913 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, |
| 58914 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58915 | .unused, |
| 58916 | .unused, |
| 58917 | .unused, |
| 58918 | }, |
| 58919 | .dst_temps = .{.mem}, |
| 58920 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58921 | .each = .{ .once = &.{ |
| 58922 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 58923 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58924 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 58925 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 58926 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 58927 | .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ }, |
| 58928 | .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 58929 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 58930 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 58931 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58932 | } }, |
| 58933 | }, .{ |
| 58934 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 58935 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58936 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58937 | .patterns = &.{ |
| 58938 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58939 | }, |
| 58940 | .call_frame = .{ .alignment = .@"16" }, |
| 58941 | .extra_temps = .{ |
| 58942 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 58943 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58944 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 58945 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 58946 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, |
| 58947 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58948 | .{ .type = .f32, .kind = .mem }, |
| 58949 | .unused, |
| 58950 | .unused, |
| 58951 | }, |
| 58952 | .dst_temps = .{.mem}, |
| 58953 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58954 | .each = .{ .once = &.{ |
| 58955 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 58956 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58957 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 58958 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 58959 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 58960 | .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ }, |
| 58961 | .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ }, |
| 58962 | .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 58963 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 58964 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 58965 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58966 | } }, |
| 58967 | }, .{ |
| 58968 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 58969 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 58970 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 58971 | .patterns = &.{ |
| 58972 | .{ .src = .{ .to_mem, .none, .none } }, |
| 58973 | }, |
| 58974 | .call_frame = .{ .alignment = .@"16" }, |
| 58975 | .extra_temps = .{ |
| 58976 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 58977 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 58978 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 58979 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 58980 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, |
| 58981 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 58982 | .unused, |
| 58983 | .unused, |
| 58984 | .unused, |
| 58985 | }, |
| 58986 | .dst_temps = .{.mem}, |
| 58987 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 58988 | .each = .{ .once = &.{ |
| 58989 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 58990 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 58991 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 58992 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 58993 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 58994 | .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, |
| 58995 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 58996 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 58997 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 58998 | } }, |
| 58999 | }, .{ |
| 59000 | .required_features = .{ .@"64bit", .sse4_1, null, null }, |
| 59001 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 59002 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 59003 | .patterns = &.{ |
| 59004 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59005 | }, |
| 59006 | .call_frame = .{ .alignment = .@"16" }, |
| 59007 | .extra_temps = .{ |
| 59008 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 59009 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59010 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 59011 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 59012 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, |
| 59013 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 59014 | .unused, |
| 59015 | .unused, |
| 59016 | .unused, |
| 59017 | }, |
| 59018 | .dst_temps = .{.mem}, |
| 59019 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59020 | .each = .{ .once = &.{ |
| 59021 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 59022 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 59023 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 59024 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 59025 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 59026 | .{ ._, .p_w, .extr, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp5x, .ui(0), ._ }, |
| 59027 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 59028 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 59029 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59030 | } }, |
| 59031 | }, .{ |
| 59032 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 59033 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 59034 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 59035 | .patterns = &.{ |
| 59036 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59037 | }, |
| 59038 | .call_frame = .{ .alignment = .@"16" }, |
| 59039 | .extra_temps = .{ |
| 59040 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 59041 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59042 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 59043 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 59044 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, |
| 59045 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 59046 | .unused, |
| 59047 | .unused, |
| 59048 | .unused, |
| 59049 | }, |
| 59050 | .dst_temps = .{.mem}, |
| 59051 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59052 | .each = .{ .once = &.{ |
| 59053 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 59054 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 59055 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 59056 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 59057 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 59058 | .{ ._, .p_w, .extr, .tmp2d, .tmp5x, .ui(0), ._ }, |
| 59059 | .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 59060 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 59061 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 59062 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59063 | } }, |
| 59064 | }, .{ |
| 59065 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59066 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 59067 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .word, .is = .word } }}, |
| 59068 | .patterns = &.{ |
| 59069 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59070 | }, |
| 59071 | .call_frame = .{ .alignment = .@"16" }, |
| 59072 | .extra_temps = .{ |
| 59073 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 59074 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59075 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 59076 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 59077 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, |
| 59078 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 59079 | .{ .type = .f32, .kind = .mem }, |
| 59080 | .unused, |
| 59081 | .unused, |
| 59082 | }, |
| 59083 | .dst_temps = .{.mem}, |
| 59084 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59085 | .each = .{ .once = &.{ |
| 59086 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 59087 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 59088 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 59089 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 59090 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 59091 | .{ ._, ._ss, .mov, .tmp6d, .tmp5d, ._, ._ }, |
| 59092 | .{ ._, ._, .mov, .tmp2d, .tmp6d, ._, ._ }, |
| 59093 | .{ ._, ._, .mov, .memia(.dst0w, .tmp1, .add_unaligned_size), .tmp2w, ._, ._ }, |
| 59094 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 59095 | .{ ._, ._, .add, .tmp1p, .si(2), ._, ._ }, |
| 59096 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59097 | } }, |
| 59098 | }, .{ |
| 59099 | .required_features = .{ .avx, null, null, null }, |
| 59100 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 59101 | .dst_constraints = .{.{ .float = .dword }}, |
| 59102 | .patterns = &.{ |
| 59103 | .{ .src = .{ .mem, .none, .none } }, |
| 59104 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59105 | }, |
| 59106 | .extra_temps = .{ |
| 59107 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59108 | .unused, |
| 59109 | .unused, |
| 59110 | .unused, |
| 59111 | .unused, |
| 59112 | .unused, |
| 59113 | .unused, |
| 59114 | .unused, |
| 59115 | .unused, |
| 59116 | }, |
| 59117 | .dst_temps = .{.{ .rc = .sse }}, |
| 59118 | .each = .{ .once = &.{ |
| 59119 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 59120 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59121 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 59122 | } }, |
| 59123 | }, .{ |
| 59124 | .required_features = .{ .sse, null, null, null }, |
| 59125 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 59126 | .dst_constraints = .{.{ .float = .dword }}, |
| 59127 | .patterns = &.{ |
| 59128 | .{ .src = .{ .mem, .none, .none } }, |
| 59129 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59130 | }, |
| 59131 | .extra_temps = .{ |
| 59132 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59133 | .unused, |
| 59134 | .unused, |
| 59135 | .unused, |
| 59136 | .unused, |
| 59137 | .unused, |
| 59138 | .unused, |
| 59139 | .unused, |
| 59140 | .unused, |
| 59141 | }, |
| 59142 | .dst_temps = .{.{ .rc = .sse }}, |
| 59143 | .each = .{ .once = &.{ |
| 59144 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 59145 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59146 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 59147 | } }, |
| 59148 | }, .{ |
| 59149 | .required_features = .{ .avx, null, null, null }, |
| 59150 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 59151 | .dst_constraints = .{.{ .float = .dword }}, |
| 59152 | .patterns = &.{ |
| 59153 | .{ .src = .{ .mem, .none, .none } }, |
| 59154 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59155 | }, |
| 59156 | .extra_temps = .{ |
| 59157 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59158 | .unused, |
| 59159 | .unused, |
| 59160 | .unused, |
| 59161 | .unused, |
| 59162 | .unused, |
| 59163 | .unused, |
| 59164 | .unused, |
| 59165 | .unused, |
| 59166 | }, |
| 59167 | .dst_temps = .{.{ .rc = .sse }}, |
| 59168 | .each = .{ .once = &.{ |
| 59169 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 59170 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59171 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 59172 | } }, |
| 59173 | }, .{ |
| 59174 | .required_features = .{ .sse, null, null, null }, |
| 59175 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 59176 | .dst_constraints = .{.{ .float = .dword }}, |
| 59177 | .patterns = &.{ |
| 59178 | .{ .src = .{ .mem, .none, .none } }, |
| 59179 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59180 | }, |
| 59181 | .extra_temps = .{ |
| 59182 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59183 | .unused, |
| 59184 | .unused, |
| 59185 | .unused, |
| 59186 | .unused, |
| 59187 | .unused, |
| 59188 | .unused, |
| 59189 | .unused, |
| 59190 | .unused, |
| 59191 | }, |
| 59192 | .dst_temps = .{.{ .rc = .sse }}, |
| 59193 | .each = .{ .once = &.{ |
| 59194 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 59195 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59196 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 59197 | } }, |
| 59198 | }, .{ |
| 59199 | .required_features = .{ .avx, null, null, null }, |
| 59200 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 59201 | .dst_constraints = .{.{ .float = .dword }}, |
| 59202 | .patterns = &.{ |
| 59203 | .{ .src = .{ .mem, .none, .none } }, |
| 59204 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59205 | }, |
| 59206 | .extra_temps = .{ |
| 59207 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59208 | .unused, |
| 59209 | .unused, |
| 59210 | .unused, |
| 59211 | .unused, |
| 59212 | .unused, |
| 59213 | .unused, |
| 59214 | .unused, |
| 59215 | .unused, |
| 59216 | }, |
| 59217 | .dst_temps = .{.{ .rc = .sse }}, |
| 59218 | .each = .{ .once = &.{ |
| 59219 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 59220 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59221 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 59222 | } }, |
| 59223 | }, .{ |
| 59224 | .required_features = .{ .sse, null, null, null }, |
| 59225 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 59226 | .dst_constraints = .{.{ .float = .dword }}, |
| 59227 | .patterns = &.{ |
| 59228 | .{ .src = .{ .mem, .none, .none } }, |
| 59229 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59230 | }, |
| 59231 | .extra_temps = .{ |
| 59232 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59233 | .unused, |
| 59234 | .unused, |
| 59235 | .unused, |
| 59236 | .unused, |
| 59237 | .unused, |
| 59238 | .unused, |
| 59239 | .unused, |
| 59240 | .unused, |
| 59241 | }, |
| 59242 | .dst_temps = .{.{ .rc = .sse }}, |
| 59243 | .each = .{ .once = &.{ |
| 59244 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 59245 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59246 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 59247 | } }, |
| 59248 | }, .{ |
| 59249 | .required_features = .{ .avx, null, null, null }, |
| 59250 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 59251 | .dst_constraints = .{.{ .float = .dword }}, |
| 59252 | .patterns = &.{ |
| 59253 | .{ .src = .{ .mem, .none, .none } }, |
| 59254 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59255 | }, |
| 59256 | .extra_temps = .{ |
| 59257 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59258 | .unused, |
| 59259 | .unused, |
| 59260 | .unused, |
| 59261 | .unused, |
| 59262 | .unused, |
| 59263 | .unused, |
| 59264 | .unused, |
| 59265 | .unused, |
| 59266 | }, |
| 59267 | .dst_temps = .{.{ .rc = .sse }}, |
| 59268 | .each = .{ .once = &.{ |
| 59269 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 59270 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59271 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 59272 | } }, |
| 59273 | }, .{ |
| 59274 | .required_features = .{ .sse, null, null, null }, |
| 59275 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 59276 | .dst_constraints = .{.{ .float = .dword }}, |
| 59277 | .patterns = &.{ |
| 59278 | .{ .src = .{ .mem, .none, .none } }, |
| 59279 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59280 | }, |
| 59281 | .extra_temps = .{ |
| 59282 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59283 | .unused, |
| 59284 | .unused, |
| 59285 | .unused, |
| 59286 | .unused, |
| 59287 | .unused, |
| 59288 | .unused, |
| 59289 | .unused, |
| 59290 | .unused, |
| 59291 | }, |
| 59292 | .dst_temps = .{.{ .rc = .sse }}, |
| 59293 | .each = .{ .once = &.{ |
| 59294 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 59295 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59296 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 59297 | } }, |
| 59298 | }, .{ |
| 59299 | .required_features = .{ .avx, null, null, null }, |
| 59300 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 59301 | .dst_constraints = .{.{ .float = .dword }}, |
| 59302 | .patterns = &.{ |
| 59303 | .{ .src = .{ .mem, .none, .none } }, |
| 59304 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59305 | }, |
| 59306 | .dst_temps = .{.{ .rc = .sse }}, |
| 59307 | .each = .{ .once = &.{ |
| 59308 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59309 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, |
| 59310 | } }, |
| 59311 | }, .{ |
| 59312 | .required_features = .{ .sse, null, null, null }, |
| 59313 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 59314 | .dst_constraints = .{.{ .float = .dword }}, |
| 59315 | .patterns = &.{ |
| 59316 | .{ .src = .{ .mem, .none, .none } }, |
| 59317 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59318 | }, |
| 59319 | .dst_temps = .{.{ .rc = .sse }}, |
| 59320 | .each = .{ .once = &.{ |
| 59321 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59322 | .{ ._, ._ss, .cvtsi2, .dst0x, .src0d, ._, ._ }, |
| 59323 | } }, |
| 59324 | }, .{ |
| 59325 | .required_features = .{ .avx, null, null, null }, |
| 59326 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 59327 | .dst_constraints = .{.{ .float = .dword }}, |
| 59328 | .patterns = &.{ |
| 59329 | .{ .src = .{ .mem, .none, .none } }, |
| 59330 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59331 | }, |
| 59332 | .extra_temps = .{ |
| 59333 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59334 | .unused, |
| 59335 | .unused, |
| 59336 | .unused, |
| 59337 | .unused, |
| 59338 | .unused, |
| 59339 | .unused, |
| 59340 | .unused, |
| 59341 | .unused, |
| 59342 | }, |
| 59343 | .dst_temps = .{.{ .rc = .sse }}, |
| 59344 | .each = .{ .once = &.{ |
| 59345 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 59346 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59347 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, |
| 59348 | } }, |
| 59349 | }, .{ |
| 59350 | .required_features = .{ .sse, null, null, null }, |
| 59351 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 59352 | .dst_constraints = .{.{ .float = .dword }}, |
| 59353 | .patterns = &.{ |
| 59354 | .{ .src = .{ .mem, .none, .none } }, |
| 59355 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59356 | }, |
| 59357 | .extra_temps = .{ |
| 59358 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 59359 | .unused, |
| 59360 | .unused, |
| 59361 | .unused, |
| 59362 | .unused, |
| 59363 | .unused, |
| 59364 | .unused, |
| 59365 | .unused, |
| 59366 | .unused, |
| 59367 | }, |
| 59368 | .dst_temps = .{.{ .rc = .sse }}, |
| 59369 | .each = .{ .once = &.{ |
| 59370 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 59371 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59372 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0q, ._, ._ }, |
| 59373 | } }, |
| 59374 | }, .{ |
| 59375 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 59376 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 59377 | .dst_constraints = .{.{ .float = .dword }}, |
| 59378 | .patterns = &.{ |
| 59379 | .{ .src = .{ .mem, .none, .none } }, |
| 59380 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59381 | }, |
| 59382 | .dst_temps = .{.{ .rc = .sse }}, |
| 59383 | .each = .{ .once = &.{ |
| 59384 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59385 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 59386 | } }, |
| 59387 | }, .{ |
| 59388 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59389 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 59390 | .dst_constraints = .{.{ .float = .dword }}, |
| 59391 | .patterns = &.{ |
| 59392 | .{ .src = .{ .mem, .none, .none } }, |
| 59393 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 59394 | }, |
| 59395 | .dst_temps = .{.{ .rc = .sse }}, |
| 59396 | .each = .{ .once = &.{ |
| 59397 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59398 | .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 59399 | } }, |
| 59400 | }, .{ |
| 59401 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 59402 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 59403 | .dst_constraints = .{.{ .float = .dword }}, |
| 59404 | .patterns = &.{ |
| 59405 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 59406 | }, |
| 59407 | .extra_temps = .{ |
| 59408 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 59409 | .unused, |
| 59410 | .unused, |
| 59411 | .unused, |
| 59412 | .unused, |
| 59413 | .unused, |
| 59414 | .unused, |
| 59415 | .unused, |
| 59416 | .unused, |
| 59417 | }, |
| 59418 | .dst_temps = .{.{ .rc = .sse }}, |
| 59419 | .clobbers = .{ .eflags = true }, |
| 59420 | .each = .{ .once = &.{ |
| 59421 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 59422 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 59423 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 59424 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 59425 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 59426 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 59427 | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 59428 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 59429 | .{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ }, |
| 59430 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 59431 | .{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 59432 | } }, |
| 59433 | }, .{ |
| 59434 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59435 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 59436 | .dst_constraints = .{.{ .float = .dword }}, |
| 59437 | .patterns = &.{ |
| 59438 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 59439 | }, |
| 59440 | .extra_temps = .{ |
| 59441 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 59442 | .unused, |
| 59443 | .unused, |
| 59444 | .unused, |
| 59445 | .unused, |
| 59446 | .unused, |
| 59447 | .unused, |
| 59448 | .unused, |
| 59449 | .unused, |
| 59450 | }, |
| 59451 | .dst_temps = .{.{ .rc = .sse }}, |
| 59452 | .clobbers = .{ .eflags = true }, |
| 59453 | .each = .{ .once = &.{ |
| 59454 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 59455 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 59456 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 59457 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 59458 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 59459 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 59460 | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 59461 | .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 59462 | .{ ._, ._ss, .add, .dst0x, .dst0d, ._, ._ }, |
| 59463 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 59464 | .{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 59465 | } }, |
| 59466 | }, .{ |
| 59467 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59468 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 59469 | .dst_constraints = .{.{ .float = .dword }}, |
| 59470 | .patterns = &.{ |
| 59471 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 59472 | }, |
| 59473 | .call_frame = .{ .alignment = .@"16" }, |
| 59474 | .extra_temps = .{ |
| 59475 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattisf" } } }, |
| 59476 | .unused, |
| 59477 | .unused, |
| 59478 | .unused, |
| 59479 | .unused, |
| 59480 | .unused, |
| 59481 | .unused, |
| 59482 | .unused, |
| 59483 | .unused, |
| 59484 | }, |
| 59485 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 59486 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59487 | .each = .{ .once = &.{ |
| 59488 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 59489 | } }, |
| 59490 | }, .{ |
| 59491 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59492 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 59493 | .dst_constraints = .{.{ .float = .dword }}, |
| 59494 | .patterns = &.{ |
| 59495 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 59496 | }, |
| 59497 | .call_frame = .{ .alignment = .@"16" }, |
| 59498 | .extra_temps = .{ |
| 59499 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntisf" } } }, |
| 59500 | .unused, |
| 59501 | .unused, |
| 59502 | .unused, |
| 59503 | .unused, |
| 59504 | .unused, |
| 59505 | .unused, |
| 59506 | .unused, |
| 59507 | .unused, |
| 59508 | }, |
| 59509 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 59510 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59511 | .each = .{ .once = &.{ |
| 59512 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 59513 | } }, |
| 59514 | }, .{ |
| 59515 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59516 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 59517 | .dst_constraints = .{.{ .float = .dword }}, |
| 59518 | .patterns = &.{ |
| 59519 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59520 | }, |
| 59521 | .call_frame = .{ .alignment = .@"16" }, |
| 59522 | .extra_temps = .{ |
| 59523 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 59524 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 59525 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateisf" } } }, |
| 59526 | .unused, |
| 59527 | .unused, |
| 59528 | .unused, |
| 59529 | .unused, |
| 59530 | .unused, |
| 59531 | .unused, |
| 59532 | }, |
| 59533 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 59534 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59535 | .each = .{ .once = &.{ |
| 59536 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 59537 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 59538 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59539 | } }, |
| 59540 | }, .{ |
| 59541 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 59542 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 59543 | .dst_constraints = .{.{ .float = .dword }}, |
| 59544 | .patterns = &.{ |
| 59545 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59546 | }, |
| 59547 | .call_frame = .{ .alignment = .@"16" }, |
| 59548 | .extra_temps = .{ |
| 59549 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 59550 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 59551 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneisf" } } }, |
| 59552 | .unused, |
| 59553 | .unused, |
| 59554 | .unused, |
| 59555 | .unused, |
| 59556 | .unused, |
| 59557 | .unused, |
| 59558 | }, |
| 59559 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 59560 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59561 | .each = .{ .once = &.{ |
| 59562 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 59563 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 59564 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59565 | } }, |
| 59566 | }, .{ |
| 59567 | .required_features = .{ .avx, null, null, null }, |
| 59568 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59569 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59570 | .patterns = &.{ |
| 59571 | .{ .src = .{ .mem, .none, .none } }, |
| 59572 | .{ .src = .{ .to_sse, .none, .none } }, |
| 59573 | }, |
| 59574 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 59575 | .each = .{ .once = &.{ |
| 59576 | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 59577 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 59578 | } }, |
| 59579 | }, .{ |
| 59580 | .required_features = .{ .sse4_1, null, null, null }, |
| 59581 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59582 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59583 | .patterns = &.{ |
| 59584 | .{ .src = .{ .mem, .none, .none } }, |
| 59585 | .{ .src = .{ .to_sse, .none, .none } }, |
| 59586 | }, |
| 59587 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 59588 | .each = .{ .once = &.{ |
| 59589 | .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 59590 | .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 59591 | } }, |
| 59592 | }, .{ |
| 59593 | .required_features = .{ .avx2, null, null, null }, |
| 59594 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 59595 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 59596 | .patterns = &.{ |
| 59597 | .{ .src = .{ .mem, .none, .none } }, |
| 59598 | .{ .src = .{ .to_sse, .none, .none } }, |
| 59599 | }, |
| 59600 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 59601 | .each = .{ .once = &.{ |
| 59602 | .{ ._, .vp_d, .movsxb, .dst0y, .src0q, ._, ._ }, |
| 59603 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 59604 | } }, |
| 59605 | }, .{ |
| 59606 | .required_features = .{ .avx, null, null, null }, |
| 59607 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59608 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59609 | .patterns = &.{ |
| 59610 | .{ .src = .{ .mem, .none, .none } }, |
| 59611 | .{ .src = .{ .to_sse, .none, .none } }, |
| 59612 | }, |
| 59613 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 59614 | .each = .{ .once = &.{ |
| 59615 | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 59616 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 59617 | } }, |
| 59618 | }, .{ |
| 59619 | .required_features = .{ .sse4_1, null, null, null }, |
| 59620 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59621 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59622 | .patterns = &.{ |
| 59623 | .{ .src = .{ .mem, .none, .none } }, |
| 59624 | .{ .src = .{ .to_sse, .none, .none } }, |
| 59625 | }, |
| 59626 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 59627 | .each = .{ .once = &.{ |
| 59628 | .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 59629 | .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 59630 | } }, |
| 59631 | }, .{ |
| 59632 | .required_features = .{ .avx2, null, null, null }, |
| 59633 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 59634 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 59635 | .patterns = &.{ |
| 59636 | .{ .src = .{ .mem, .none, .none } }, |
| 59637 | .{ .src = .{ .to_sse, .none, .none } }, |
| 59638 | }, |
| 59639 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 59640 | .each = .{ .once = &.{ |
| 59641 | .{ ._, .vp_d, .movzxb, .dst0y, .src0q, ._, ._ }, |
| 59642 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 59643 | } }, |
| 59644 | }, .{ |
| 59645 | .required_features = .{ .avx2, null, null, null }, |
| 59646 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 59647 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 59648 | .patterns = &.{ |
| 59649 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59650 | }, |
| 59651 | .extra_temps = .{ |
| 59652 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59653 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 59654 | .unused, |
| 59655 | .unused, |
| 59656 | .unused, |
| 59657 | .unused, |
| 59658 | .unused, |
| 59659 | .unused, |
| 59660 | .unused, |
| 59661 | }, |
| 59662 | .dst_temps = .{.mem}, |
| 59663 | .clobbers = .{ .eflags = true }, |
| 59664 | .each = .{ .once = &.{ |
| 59665 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59666 | .{ .@"0:", .vp_d, .movsxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59667 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 59668 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 59669 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 59670 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59671 | } }, |
| 59672 | }, .{ |
| 59673 | .required_features = .{ .avx, null, null, null }, |
| 59674 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59675 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59676 | .patterns = &.{ |
| 59677 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59678 | }, |
| 59679 | .extra_temps = .{ |
| 59680 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59681 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 59682 | .unused, |
| 59683 | .unused, |
| 59684 | .unused, |
| 59685 | .unused, |
| 59686 | .unused, |
| 59687 | .unused, |
| 59688 | .unused, |
| 59689 | }, |
| 59690 | .dst_temps = .{.mem}, |
| 59691 | .clobbers = .{ .eflags = true }, |
| 59692 | .each = .{ .once = &.{ |
| 59693 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59694 | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59695 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 59696 | .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 59697 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 59698 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59699 | } }, |
| 59700 | }, .{ |
| 59701 | .required_features = .{ .sse4_1, null, null, null }, |
| 59702 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59703 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59704 | .patterns = &.{ |
| 59705 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59706 | }, |
| 59707 | .extra_temps = .{ |
| 59708 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59709 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 59710 | .unused, |
| 59711 | .unused, |
| 59712 | .unused, |
| 59713 | .unused, |
| 59714 | .unused, |
| 59715 | .unused, |
| 59716 | .unused, |
| 59717 | }, |
| 59718 | .dst_temps = .{.mem}, |
| 59719 | .clobbers = .{ .eflags = true }, |
| 59720 | .each = .{ .once = &.{ |
| 59721 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59722 | .{ .@"0:", .p_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59723 | .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 59724 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 59725 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 59726 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59727 | } }, |
| 59728 | }, .{ |
| 59729 | .required_features = .{ .avx2, null, null, null }, |
| 59730 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, .any, .any }, |
| 59731 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 59732 | .patterns = &.{ |
| 59733 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59734 | }, |
| 59735 | .extra_temps = .{ |
| 59736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59737 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 59738 | .unused, |
| 59739 | .unused, |
| 59740 | .unused, |
| 59741 | .unused, |
| 59742 | .unused, |
| 59743 | .unused, |
| 59744 | .unused, |
| 59745 | }, |
| 59746 | .dst_temps = .{.mem}, |
| 59747 | .clobbers = .{ .eflags = true }, |
| 59748 | .each = .{ .once = &.{ |
| 59749 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59750 | .{ .@"0:", .vp_d, .movzxb, .tmp1y, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59751 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 59752 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 59753 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 59754 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59755 | } }, |
| 59756 | }, .{ |
| 59757 | .required_features = .{ .avx, null, null, null }, |
| 59758 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59759 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59760 | .patterns = &.{ |
| 59761 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59762 | }, |
| 59763 | .extra_temps = .{ |
| 59764 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59765 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 59766 | .unused, |
| 59767 | .unused, |
| 59768 | .unused, |
| 59769 | .unused, |
| 59770 | .unused, |
| 59771 | .unused, |
| 59772 | .unused, |
| 59773 | }, |
| 59774 | .dst_temps = .{.mem}, |
| 59775 | .clobbers = .{ .eflags = true }, |
| 59776 | .each = .{ .once = &.{ |
| 59777 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59778 | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59779 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 59780 | .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 59781 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 59782 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59783 | } }, |
| 59784 | }, .{ |
| 59785 | .required_features = .{ .sse4_1, null, null, null }, |
| 59786 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 59787 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 59788 | .patterns = &.{ |
| 59789 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59790 | }, |
| 59791 | .extra_temps = .{ |
| 59792 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59793 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 59794 | .unused, |
| 59795 | .unused, |
| 59796 | .unused, |
| 59797 | .unused, |
| 59798 | .unused, |
| 59799 | .unused, |
| 59800 | .unused, |
| 59801 | }, |
| 59802 | .dst_temps = .{.mem}, |
| 59803 | .clobbers = .{ .eflags = true }, |
| 59804 | .each = .{ .once = &.{ |
| 59805 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59806 | .{ .@"0:", .p_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59807 | .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 59808 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 59809 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 59810 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59811 | } }, |
| 59812 | }, .{ |
| 59813 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 59814 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59815 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59816 | .patterns = &.{ |
| 59817 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59818 | }, |
| 59819 | .call_frame = .{ .alignment = .@"16" }, |
| 59820 | .extra_temps = .{ |
| 59821 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59822 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 59823 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 59824 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59825 | .unused, |
| 59826 | .unused, |
| 59827 | .unused, |
| 59828 | .unused, |
| 59829 | .unused, |
| 59830 | }, |
| 59831 | .dst_temps = .{.mem}, |
| 59832 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59833 | .each = .{ .once = &.{ |
| 59834 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59835 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59836 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59837 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 59838 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 59839 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59840 | } }, |
| 59841 | }, .{ |
| 59842 | .required_features = .{ .avx, null, null, null }, |
| 59843 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59844 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59845 | .patterns = &.{ |
| 59846 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59847 | }, |
| 59848 | .call_frame = .{ .alignment = .@"16" }, |
| 59849 | .extra_temps = .{ |
| 59850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59851 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 59852 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 59853 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59854 | .unused, |
| 59855 | .unused, |
| 59856 | .unused, |
| 59857 | .unused, |
| 59858 | .unused, |
| 59859 | }, |
| 59860 | .dst_temps = .{.mem}, |
| 59861 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59862 | .each = .{ .once = &.{ |
| 59863 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59864 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59865 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59866 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 59867 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 59868 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 59869 | } }, |
| 59870 | }, .{ |
| 59871 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 59872 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59873 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59874 | .patterns = &.{ |
| 59875 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59876 | }, |
| 59877 | .call_frame = .{ .alignment = .@"16" }, |
| 59878 | .extra_temps = .{ |
| 59879 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59880 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 59881 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 59882 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59883 | .unused, |
| 59884 | .unused, |
| 59885 | .unused, |
| 59886 | .unused, |
| 59887 | .unused, |
| 59888 | }, |
| 59889 | .dst_temps = .{.mem}, |
| 59890 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59891 | .each = .{ .once = &.{ |
| 59892 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59893 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59894 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59895 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 59896 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 59897 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59898 | } }, |
| 59899 | }, .{ |
| 59900 | .required_features = .{ .sse, null, null, null }, |
| 59901 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59902 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59903 | .patterns = &.{ |
| 59904 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59905 | }, |
| 59906 | .call_frame = .{ .alignment = .@"16" }, |
| 59907 | .extra_temps = .{ |
| 59908 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59909 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 59910 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 59911 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59912 | .unused, |
| 59913 | .unused, |
| 59914 | .unused, |
| 59915 | .unused, |
| 59916 | .unused, |
| 59917 | }, |
| 59918 | .dst_temps = .{.mem}, |
| 59919 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59920 | .each = .{ .once = &.{ |
| 59921 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59922 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59923 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59924 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 59925 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 59926 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 59927 | } }, |
| 59928 | }, .{ |
| 59929 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 59930 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59931 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59932 | .patterns = &.{ |
| 59933 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59934 | }, |
| 59935 | .call_frame = .{ .alignment = .@"16" }, |
| 59936 | .extra_temps = .{ |
| 59937 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59938 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 59939 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 59940 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59941 | .unused, |
| 59942 | .unused, |
| 59943 | .unused, |
| 59944 | .unused, |
| 59945 | .unused, |
| 59946 | }, |
| 59947 | .dst_temps = .{.mem}, |
| 59948 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59949 | .each = .{ .once = &.{ |
| 59950 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59951 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59952 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59953 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 59954 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 59955 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 59956 | } }, |
| 59957 | }, .{ |
| 59958 | .required_features = .{ .avx, null, null, null }, |
| 59959 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59960 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59961 | .patterns = &.{ |
| 59962 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59963 | }, |
| 59964 | .call_frame = .{ .alignment = .@"16" }, |
| 59965 | .extra_temps = .{ |
| 59966 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59967 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 59968 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 59969 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59970 | .unused, |
| 59971 | .unused, |
| 59972 | .unused, |
| 59973 | .unused, |
| 59974 | .unused, |
| 59975 | }, |
| 59976 | .dst_temps = .{.mem}, |
| 59977 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 59978 | .each = .{ .once = &.{ |
| 59979 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 59980 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 59981 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 59982 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 59983 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 59984 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 59985 | } }, |
| 59986 | }, .{ |
| 59987 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 59988 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 59989 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 59990 | .patterns = &.{ |
| 59991 | .{ .src = .{ .to_mem, .none, .none } }, |
| 59992 | }, |
| 59993 | .call_frame = .{ .alignment = .@"16" }, |
| 59994 | .extra_temps = .{ |
| 59995 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 59996 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 59997 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 59998 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 59999 | .unused, |
| 60000 | .unused, |
| 60001 | .unused, |
| 60002 | .unused, |
| 60003 | .unused, |
| 60004 | }, |
| 60005 | .dst_temps = .{.mem}, |
| 60006 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60007 | .each = .{ .once = &.{ |
| 60008 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60009 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60010 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60011 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60012 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 60013 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60014 | } }, |
| 60015 | }, .{ |
| 60016 | .required_features = .{ .sse, null, null, null }, |
| 60017 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 60018 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60019 | .patterns = &.{ |
| 60020 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60021 | }, |
| 60022 | .call_frame = .{ .alignment = .@"16" }, |
| 60023 | .extra_temps = .{ |
| 60024 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60025 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 60026 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 60027 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60028 | .unused, |
| 60029 | .unused, |
| 60030 | .unused, |
| 60031 | .unused, |
| 60032 | .unused, |
| 60033 | }, |
| 60034 | .dst_temps = .{.mem}, |
| 60035 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60036 | .each = .{ .once = &.{ |
| 60037 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60038 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60039 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60040 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60041 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 60042 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 60043 | } }, |
| 60044 | }, .{ |
| 60045 | .required_features = .{ .avx, null, null, null }, |
| 60046 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60047 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60048 | .patterns = &.{ |
| 60049 | .{ .src = .{ .mem, .none, .none } }, |
| 60050 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60051 | }, |
| 60052 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60053 | .each = .{ .once = &.{ |
| 60054 | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 60055 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 60056 | } }, |
| 60057 | }, .{ |
| 60058 | .required_features = .{ .sse4_1, null, null, null }, |
| 60059 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60060 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60061 | .patterns = &.{ |
| 60062 | .{ .src = .{ .mem, .none, .none } }, |
| 60063 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60064 | }, |
| 60065 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60066 | .each = .{ .once = &.{ |
| 60067 | .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 60068 | .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 60069 | } }, |
| 60070 | }, .{ |
| 60071 | .required_features = .{ .avx2, null, null, null }, |
| 60072 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 60073 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 60074 | .patterns = &.{ |
| 60075 | .{ .src = .{ .mem, .none, .none } }, |
| 60076 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60077 | }, |
| 60078 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60079 | .each = .{ .once = &.{ |
| 60080 | .{ ._, .vp_d, .movsxw, .dst0y, .src0x, ._, ._ }, |
| 60081 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 60082 | } }, |
| 60083 | }, .{ |
| 60084 | .required_features = .{ .avx, null, null, null }, |
| 60085 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60086 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60087 | .patterns = &.{ |
| 60088 | .{ .src = .{ .mem, .none, .none } }, |
| 60089 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60090 | }, |
| 60091 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60092 | .each = .{ .once = &.{ |
| 60093 | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 60094 | .{ ._, .v_ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 60095 | } }, |
| 60096 | }, .{ |
| 60097 | .required_features = .{ .sse4_1, null, null, null }, |
| 60098 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60099 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60100 | .patterns = &.{ |
| 60101 | .{ .src = .{ .mem, .none, .none } }, |
| 60102 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60103 | }, |
| 60104 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60105 | .each = .{ .once = &.{ |
| 60106 | .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 60107 | .{ ._, ._ps, .cvtdq2, .dst0x, .dst0x, ._, ._ }, |
| 60108 | } }, |
| 60109 | }, .{ |
| 60110 | .required_features = .{ .avx2, null, null, null }, |
| 60111 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 60112 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 60113 | .patterns = &.{ |
| 60114 | .{ .src = .{ .mem, .none, .none } }, |
| 60115 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60116 | }, |
| 60117 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60118 | .each = .{ .once = &.{ |
| 60119 | .{ ._, .vp_d, .movzxw, .dst0y, .src0x, ._, ._ }, |
| 60120 | .{ ._, .v_ps, .cvtdq2, .dst0y, .dst0y, ._, ._ }, |
| 60121 | } }, |
| 60122 | }, .{ |
| 60123 | .required_features = .{ .avx2, null, null, null }, |
| 60124 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 60125 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 60126 | .patterns = &.{ |
| 60127 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60128 | }, |
| 60129 | .extra_temps = .{ |
| 60130 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60131 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 60132 | .unused, |
| 60133 | .unused, |
| 60134 | .unused, |
| 60135 | .unused, |
| 60136 | .unused, |
| 60137 | .unused, |
| 60138 | .unused, |
| 60139 | }, |
| 60140 | .dst_temps = .{.mem}, |
| 60141 | .clobbers = .{ .eflags = true }, |
| 60142 | .each = .{ .once = &.{ |
| 60143 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60144 | .{ .@"0:", .vp_d, .movsxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60145 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 60146 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 60147 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 60148 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60149 | } }, |
| 60150 | }, .{ |
| 60151 | .required_features = .{ .avx, null, null, null }, |
| 60152 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60153 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60154 | .patterns = &.{ |
| 60155 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60156 | }, |
| 60157 | .extra_temps = .{ |
| 60158 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60159 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 60160 | .unused, |
| 60161 | .unused, |
| 60162 | .unused, |
| 60163 | .unused, |
| 60164 | .unused, |
| 60165 | .unused, |
| 60166 | .unused, |
| 60167 | }, |
| 60168 | .dst_temps = .{.mem}, |
| 60169 | .clobbers = .{ .eflags = true }, |
| 60170 | .each = .{ .once = &.{ |
| 60171 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60172 | .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60173 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 60174 | .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60175 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 60176 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60177 | } }, |
| 60178 | }, .{ |
| 60179 | .required_features = .{ .sse4_1, null, null, null }, |
| 60180 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60181 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60182 | .patterns = &.{ |
| 60183 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60184 | }, |
| 60185 | .extra_temps = .{ |
| 60186 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60187 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 60188 | .unused, |
| 60189 | .unused, |
| 60190 | .unused, |
| 60191 | .unused, |
| 60192 | .unused, |
| 60193 | .unused, |
| 60194 | .unused, |
| 60195 | }, |
| 60196 | .dst_temps = .{.mem}, |
| 60197 | .clobbers = .{ .eflags = true }, |
| 60198 | .each = .{ .once = &.{ |
| 60199 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60200 | .{ .@"0:", .p_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60201 | .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 60202 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60203 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 60204 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60205 | } }, |
| 60206 | }, .{ |
| 60207 | .required_features = .{ .avx2, null, null, null }, |
| 60208 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, .any, .any }, |
| 60209 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 60210 | .patterns = &.{ |
| 60211 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60212 | }, |
| 60213 | .extra_temps = .{ |
| 60214 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60215 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 60216 | .unused, |
| 60217 | .unused, |
| 60218 | .unused, |
| 60219 | .unused, |
| 60220 | .unused, |
| 60221 | .unused, |
| 60222 | .unused, |
| 60223 | }, |
| 60224 | .dst_temps = .{.mem}, |
| 60225 | .clobbers = .{ .eflags = true }, |
| 60226 | .each = .{ .once = &.{ |
| 60227 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60228 | .{ .@"0:", .vp_d, .movzxw, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60229 | .{ ._, .v_ps, .cvtdq2, .tmp1y, .tmp1y, ._, ._ }, |
| 60230 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 60231 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 60232 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60233 | } }, |
| 60234 | }, .{ |
| 60235 | .required_features = .{ .avx, null, null, null }, |
| 60236 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60237 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60238 | .patterns = &.{ |
| 60239 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60240 | }, |
| 60241 | .extra_temps = .{ |
| 60242 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60243 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 60244 | .unused, |
| 60245 | .unused, |
| 60246 | .unused, |
| 60247 | .unused, |
| 60248 | .unused, |
| 60249 | .unused, |
| 60250 | .unused, |
| 60251 | }, |
| 60252 | .dst_temps = .{.mem}, |
| 60253 | .clobbers = .{ .eflags = true }, |
| 60254 | .each = .{ .once = &.{ |
| 60255 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60256 | .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60257 | .{ ._, .v_ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 60258 | .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60259 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 60260 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60261 | } }, |
| 60262 | }, .{ |
| 60263 | .required_features = .{ .sse4_1, null, null, null }, |
| 60264 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 60265 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60266 | .patterns = &.{ |
| 60267 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60268 | }, |
| 60269 | .extra_temps = .{ |
| 60270 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60271 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 60272 | .unused, |
| 60273 | .unused, |
| 60274 | .unused, |
| 60275 | .unused, |
| 60276 | .unused, |
| 60277 | .unused, |
| 60278 | .unused, |
| 60279 | }, |
| 60280 | .dst_temps = .{.mem}, |
| 60281 | .clobbers = .{ .eflags = true }, |
| 60282 | .each = .{ .once = &.{ |
| 60283 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60284 | .{ .@"0:", .p_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60285 | .{ ._, ._ps, .cvtdq2, .tmp1x, .tmp1x, ._, ._ }, |
| 60286 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60287 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 60288 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60289 | } }, |
| 60290 | }, .{ |
| 60291 | .required_features = .{ .avx, null, null, null }, |
| 60292 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 60293 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60294 | .patterns = &.{ |
| 60295 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60296 | }, |
| 60297 | .call_frame = .{ .alignment = .@"16" }, |
| 60298 | .extra_temps = .{ |
| 60299 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60300 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 60301 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 60302 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60303 | .unused, |
| 60304 | .unused, |
| 60305 | .unused, |
| 60306 | .unused, |
| 60307 | .unused, |
| 60308 | }, |
| 60309 | .dst_temps = .{.mem}, |
| 60310 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60311 | .each = .{ .once = &.{ |
| 60312 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60313 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60314 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60315 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60316 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 60317 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60318 | } }, |
| 60319 | }, .{ |
| 60320 | .required_features = .{ .sse, null, null, null }, |
| 60321 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 60322 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60323 | .patterns = &.{ |
| 60324 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60325 | }, |
| 60326 | .call_frame = .{ .alignment = .@"16" }, |
| 60327 | .extra_temps = .{ |
| 60328 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60329 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 60330 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 60331 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60332 | .unused, |
| 60333 | .unused, |
| 60334 | .unused, |
| 60335 | .unused, |
| 60336 | .unused, |
| 60337 | }, |
| 60338 | .dst_temps = .{.mem}, |
| 60339 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60340 | .each = .{ .once = &.{ |
| 60341 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60342 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60343 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60344 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60345 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 60346 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60347 | } }, |
| 60348 | }, .{ |
| 60349 | .required_features = .{ .avx, null, null, null }, |
| 60350 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 60351 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60352 | .patterns = &.{ |
| 60353 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60354 | }, |
| 60355 | .call_frame = .{ .alignment = .@"16" }, |
| 60356 | .extra_temps = .{ |
| 60357 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60358 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 60359 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 60360 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60361 | .unused, |
| 60362 | .unused, |
| 60363 | .unused, |
| 60364 | .unused, |
| 60365 | .unused, |
| 60366 | }, |
| 60367 | .dst_temps = .{.mem}, |
| 60368 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60369 | .each = .{ .once = &.{ |
| 60370 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60371 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60372 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60373 | .{ ._, .v_ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60374 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 60375 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60376 | } }, |
| 60377 | }, .{ |
| 60378 | .required_features = .{ .sse, null, null, null }, |
| 60379 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 60380 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60381 | .patterns = &.{ |
| 60382 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60383 | }, |
| 60384 | .call_frame = .{ .alignment = .@"16" }, |
| 60385 | .extra_temps = .{ |
| 60386 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60387 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 60388 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 60389 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60390 | .unused, |
| 60391 | .unused, |
| 60392 | .unused, |
| 60393 | .unused, |
| 60394 | .unused, |
| 60395 | }, |
| 60396 | .dst_temps = .{.mem}, |
| 60397 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60398 | .each = .{ .once = &.{ |
| 60399 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60400 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60401 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60402 | .{ ._, ._ss, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60403 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 60404 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60405 | } }, |
| 60406 | }, .{ |
| 60407 | .required_features = .{ .avx, null, null, null }, |
| 60408 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 60409 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60410 | .patterns = &.{ |
| 60411 | .{ .src = .{ .mem, .none, .none } }, |
| 60412 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60413 | }, |
| 60414 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60415 | .each = .{ .once = &.{ |
| 60416 | .{ ._, .v_ps, .cvtdq2, .dst0x, .src0x, ._, ._ }, |
| 60417 | } }, |
| 60418 | }, .{ |
| 60419 | .required_features = .{ .sse2, null, null, null }, |
| 60420 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 60421 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60422 | .patterns = &.{ |
| 60423 | .{ .src = .{ .mem, .none, .none } }, |
| 60424 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60425 | }, |
| 60426 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60427 | .each = .{ .once = &.{ |
| 60428 | .{ ._, ._ps, .cvtdq2, .dst0x, .src0x, ._, ._ }, |
| 60429 | } }, |
| 60430 | }, .{ |
| 60431 | .required_features = .{ .avx2, null, null, null }, |
| 60432 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 60433 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 60434 | .patterns = &.{ |
| 60435 | .{ .src = .{ .mem, .none, .none } }, |
| 60436 | .{ .src = .{ .to_sse, .none, .none } }, |
| 60437 | }, |
| 60438 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 60439 | .each = .{ .once = &.{ |
| 60440 | .{ ._, .v_ps, .cvtdq2, .dst0y, .src0y, ._, ._ }, |
| 60441 | } }, |
| 60442 | }, .{ |
| 60443 | .required_features = .{ .avx2, null, null, null }, |
| 60444 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, .any, .any }, |
| 60445 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } }}, |
| 60446 | .patterns = &.{ |
| 60447 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60448 | }, |
| 60449 | .extra_temps = .{ |
| 60450 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60451 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 60452 | .unused, |
| 60453 | .unused, |
| 60454 | .unused, |
| 60455 | .unused, |
| 60456 | .unused, |
| 60457 | .unused, |
| 60458 | .unused, |
| 60459 | }, |
| 60460 | .dst_temps = .{.mem}, |
| 60461 | .clobbers = .{ .eflags = true }, |
| 60462 | .each = .{ .once = &.{ |
| 60463 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 60464 | .{ .@"0:", .v_ps, .cvtdq2, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60465 | .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 60466 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| 60467 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60468 | } }, |
| 60469 | }, .{ |
| 60470 | .required_features = .{ .avx, null, null, null }, |
| 60471 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 60472 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60473 | .patterns = &.{ |
| 60474 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60475 | }, |
| 60476 | .extra_temps = .{ |
| 60477 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60478 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 60479 | .unused, |
| 60480 | .unused, |
| 60481 | .unused, |
| 60482 | .unused, |
| 60483 | .unused, |
| 60484 | .unused, |
| 60485 | .unused, |
| 60486 | }, |
| 60487 | .dst_temps = .{.mem}, |
| 60488 | .clobbers = .{ .eflags = true }, |
| 60489 | .each = .{ .once = &.{ |
| 60490 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60491 | .{ .@"0:", .v_ps, .cvtdq2, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60492 | .{ ._, .v_ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60493 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 60494 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60495 | } }, |
| 60496 | }, .{ |
| 60497 | .required_features = .{ .sse2, null, null, null }, |
| 60498 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 60499 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }}, |
| 60500 | .patterns = &.{ |
| 60501 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60502 | }, |
| 60503 | .extra_temps = .{ |
| 60504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60505 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 60506 | .unused, |
| 60507 | .unused, |
| 60508 | .unused, |
| 60509 | .unused, |
| 60510 | .unused, |
| 60511 | .unused, |
| 60512 | .unused, |
| 60513 | }, |
| 60514 | .dst_temps = .{.mem}, |
| 60515 | .clobbers = .{ .eflags = true }, |
| 60516 | .each = .{ .once = &.{ |
| 60517 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60518 | .{ .@"0:", ._ps, .cvtdq2, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60519 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60520 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 60521 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60522 | } }, |
| 60523 | }, .{ |
| 60524 | .required_features = .{ .sse, null, null, null }, |
| 60525 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60526 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60527 | .patterns = &.{ |
| 60528 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60529 | }, |
| 60530 | .extra_temps = .{ |
| 60531 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60532 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 60533 | .unused, |
| 60534 | .unused, |
| 60535 | .unused, |
| 60536 | .unused, |
| 60537 | .unused, |
| 60538 | .unused, |
| 60539 | .unused, |
| 60540 | }, |
| 60541 | .dst_temps = .{.mem}, |
| 60542 | .clobbers = .{ .eflags = true }, |
| 60543 | .each = .{ .once = &.{ |
| 60544 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60545 | .{ .@"0:", ._ss, .cvtsi2, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60546 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60547 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60549 | } }, |
| 60550 | }, .{ |
| 60551 | .required_features = .{ .avx, null, null, null }, |
| 60552 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60553 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60554 | .patterns = &.{ |
| 60555 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60556 | }, |
| 60557 | .call_frame = .{ .alignment = .@"16" }, |
| 60558 | .extra_temps = .{ |
| 60559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60560 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 60561 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 60562 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60563 | .unused, |
| 60564 | .unused, |
| 60565 | .unused, |
| 60566 | .unused, |
| 60567 | .unused, |
| 60568 | }, |
| 60569 | .dst_temps = .{.mem}, |
| 60570 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60571 | .each = .{ .once = &.{ |
| 60572 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60573 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60574 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60575 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60576 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60577 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60578 | } }, |
| 60579 | }, .{ |
| 60580 | .required_features = .{ .sse, null, null, null }, |
| 60581 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60582 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60583 | .patterns = &.{ |
| 60584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60585 | }, |
| 60586 | .call_frame = .{ .alignment = .@"16" }, |
| 60587 | .extra_temps = .{ |
| 60588 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60589 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 60590 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsisf" } } }, |
| 60591 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60592 | .unused, |
| 60593 | .unused, |
| 60594 | .unused, |
| 60595 | .unused, |
| 60596 | .unused, |
| 60597 | }, |
| 60598 | .dst_temps = .{.mem}, |
| 60599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60600 | .each = .{ .once = &.{ |
| 60601 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60602 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60603 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60604 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60605 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60606 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60607 | } }, |
| 60608 | }, .{ |
| 60609 | .required_features = .{ .avx, null, null, null }, |
| 60610 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60611 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60612 | .patterns = &.{ |
| 60613 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60614 | }, |
| 60615 | .call_frame = .{ .alignment = .@"16" }, |
| 60616 | .extra_temps = .{ |
| 60617 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60618 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 60619 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 60620 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60621 | .unused, |
| 60622 | .unused, |
| 60623 | .unused, |
| 60624 | .unused, |
| 60625 | .unused, |
| 60626 | }, |
| 60627 | .dst_temps = .{.mem}, |
| 60628 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60629 | .each = .{ .once = &.{ |
| 60630 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60631 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60632 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60633 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60634 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60635 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60636 | } }, |
| 60637 | }, .{ |
| 60638 | .required_features = .{ .sse, null, null, null }, |
| 60639 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60640 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60641 | .patterns = &.{ |
| 60642 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60643 | }, |
| 60644 | .call_frame = .{ .alignment = .@"16" }, |
| 60645 | .extra_temps = .{ |
| 60646 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60647 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 60648 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsisf" } } }, |
| 60649 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60650 | .unused, |
| 60651 | .unused, |
| 60652 | .unused, |
| 60653 | .unused, |
| 60654 | .unused, |
| 60655 | }, |
| 60656 | .dst_temps = .{.mem}, |
| 60657 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60658 | .each = .{ .once = &.{ |
| 60659 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60660 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 60661 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60662 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60663 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60664 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60665 | } }, |
| 60666 | }, .{ |
| 60667 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 60668 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 60669 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60670 | .patterns = &.{ |
| 60671 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60672 | }, |
| 60673 | .extra_temps = .{ |
| 60674 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60675 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 60676 | .unused, |
| 60677 | .unused, |
| 60678 | .unused, |
| 60679 | .unused, |
| 60680 | .unused, |
| 60681 | .unused, |
| 60682 | .unused, |
| 60683 | }, |
| 60684 | .dst_temps = .{.mem}, |
| 60685 | .clobbers = .{ .eflags = true }, |
| 60686 | .each = .{ .once = &.{ |
| 60687 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60688 | .{ .@"0:", .v_ps, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 60689 | .{ ._, .v_ss, .cvtsi2, .tmp1x, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._ }, |
| 60690 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60691 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60692 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60693 | } }, |
| 60694 | }, .{ |
| 60695 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 60696 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 60697 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60698 | .patterns = &.{ |
| 60699 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60700 | }, |
| 60701 | .extra_temps = .{ |
| 60702 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60703 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 60704 | .unused, |
| 60705 | .unused, |
| 60706 | .unused, |
| 60707 | .unused, |
| 60708 | .unused, |
| 60709 | .unused, |
| 60710 | .unused, |
| 60711 | }, |
| 60712 | .dst_temps = .{.mem}, |
| 60713 | .clobbers = .{ .eflags = true }, |
| 60714 | .each = .{ .once = &.{ |
| 60715 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60716 | .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 60717 | .{ ._, ._ss, .cvtsi2, .tmp1x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60718 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 60719 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60720 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60721 | } }, |
| 60722 | }, .{ |
| 60723 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 60724 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 60725 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60726 | .patterns = &.{ |
| 60727 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60728 | }, |
| 60729 | .call_frame = .{ .alignment = .@"16" }, |
| 60730 | .extra_temps = .{ |
| 60731 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60732 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 60733 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdisf" } } }, |
| 60734 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60735 | .unused, |
| 60736 | .unused, |
| 60737 | .unused, |
| 60738 | .unused, |
| 60739 | .unused, |
| 60740 | }, |
| 60741 | .dst_temps = .{.mem}, |
| 60742 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60743 | .each = .{ .once = &.{ |
| 60744 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60745 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60746 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60747 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60748 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60749 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60750 | } }, |
| 60751 | }, .{ |
| 60752 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 60753 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 60754 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60755 | .patterns = &.{ |
| 60756 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60757 | }, |
| 60758 | .call_frame = .{ .alignment = .@"16" }, |
| 60759 | .extra_temps = .{ |
| 60760 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60761 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 60762 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdisf" } } }, |
| 60763 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60764 | .unused, |
| 60765 | .unused, |
| 60766 | .unused, |
| 60767 | .unused, |
| 60768 | .unused, |
| 60769 | }, |
| 60770 | .dst_temps = .{.mem}, |
| 60771 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60772 | .each = .{ .once = &.{ |
| 60773 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60774 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60775 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60776 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60777 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60778 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60779 | } }, |
| 60780 | }, .{ |
| 60781 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 60782 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 60783 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60784 | .patterns = &.{ |
| 60785 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60786 | }, |
| 60787 | .call_frame = .{ .alignment = .@"16" }, |
| 60788 | .extra_temps = .{ |
| 60789 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60790 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 60791 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundisf" } } }, |
| 60792 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60793 | .unused, |
| 60794 | .unused, |
| 60795 | .unused, |
| 60796 | .unused, |
| 60797 | .unused, |
| 60798 | }, |
| 60799 | .dst_temps = .{.mem}, |
| 60800 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60801 | .each = .{ .once = &.{ |
| 60802 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60803 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60804 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60805 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60806 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60807 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60808 | } }, |
| 60809 | }, .{ |
| 60810 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 60811 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 60812 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60813 | .patterns = &.{ |
| 60814 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60815 | }, |
| 60816 | .call_frame = .{ .alignment = .@"16" }, |
| 60817 | .extra_temps = .{ |
| 60818 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60819 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 60820 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundisf" } } }, |
| 60821 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60822 | .unused, |
| 60823 | .unused, |
| 60824 | .unused, |
| 60825 | .unused, |
| 60826 | .unused, |
| 60827 | }, |
| 60828 | .dst_temps = .{.mem}, |
| 60829 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60830 | .each = .{ .once = &.{ |
| 60831 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60832 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60833 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 60834 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 60835 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60836 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60837 | } }, |
| 60838 | }, .{ |
| 60839 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 60840 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 60841 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60842 | .patterns = &.{ |
| 60843 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60844 | }, |
| 60845 | .call_frame = .{ .alignment = .@"16" }, |
| 60846 | .extra_temps = .{ |
| 60847 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60848 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 60849 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 60850 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattisf" } } }, |
| 60851 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60852 | .unused, |
| 60853 | .unused, |
| 60854 | .unused, |
| 60855 | .unused, |
| 60856 | }, |
| 60857 | .dst_temps = .{.mem}, |
| 60858 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60859 | .each = .{ .once = &.{ |
| 60860 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60861 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60862 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 60863 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 60864 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 60865 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60866 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60867 | } }, |
| 60868 | }, .{ |
| 60869 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 60870 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 60871 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60872 | .patterns = &.{ |
| 60873 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60874 | }, |
| 60875 | .call_frame = .{ .alignment = .@"16" }, |
| 60876 | .extra_temps = .{ |
| 60877 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60878 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 60879 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 60880 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattisf" } } }, |
| 60881 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60882 | .unused, |
| 60883 | .unused, |
| 60884 | .unused, |
| 60885 | .unused, |
| 60886 | }, |
| 60887 | .dst_temps = .{.mem}, |
| 60888 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60889 | .each = .{ .once = &.{ |
| 60890 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60891 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60892 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 60893 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 60894 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 60895 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60896 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60897 | } }, |
| 60898 | }, .{ |
| 60899 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 60900 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 60901 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60902 | .patterns = &.{ |
| 60903 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60904 | }, |
| 60905 | .call_frame = .{ .alignment = .@"16" }, |
| 60906 | .extra_temps = .{ |
| 60907 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60908 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 60909 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 60910 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntisf" } } }, |
| 60911 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60912 | .unused, |
| 60913 | .unused, |
| 60914 | .unused, |
| 60915 | .unused, |
| 60916 | }, |
| 60917 | .dst_temps = .{.mem}, |
| 60918 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60919 | .each = .{ .once = &.{ |
| 60920 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60921 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60922 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 60923 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 60924 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 60925 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60926 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60927 | } }, |
| 60928 | }, .{ |
| 60929 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 60930 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 60931 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60932 | .patterns = &.{ |
| 60933 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60934 | }, |
| 60935 | .call_frame = .{ .alignment = .@"16" }, |
| 60936 | .extra_temps = .{ |
| 60937 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60938 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 60939 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 60940 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntisf" } } }, |
| 60941 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60942 | .unused, |
| 60943 | .unused, |
| 60944 | .unused, |
| 60945 | .unused, |
| 60946 | }, |
| 60947 | .dst_temps = .{.mem}, |
| 60948 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60949 | .each = .{ .once = &.{ |
| 60950 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60951 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 60952 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"4", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 60953 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 60954 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 60955 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 60956 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60957 | } }, |
| 60958 | }, .{ |
| 60959 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 60960 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60961 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60962 | .patterns = &.{ |
| 60963 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60964 | }, |
| 60965 | .call_frame = .{ .alignment = .@"16" }, |
| 60966 | .extra_temps = .{ |
| 60967 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 60968 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 60969 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 60970 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 60971 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateisf" } } }, |
| 60972 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 60973 | .unused, |
| 60974 | .unused, |
| 60975 | .unused, |
| 60976 | }, |
| 60977 | .dst_temps = .{.mem}, |
| 60978 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 60979 | .each = .{ .once = &.{ |
| 60980 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 60981 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 60982 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 60983 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 60984 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 60985 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 60986 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 60987 | .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, |
| 60988 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 60989 | } }, |
| 60990 | }, .{ |
| 60991 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 60992 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 60993 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 60994 | .patterns = &.{ |
| 60995 | .{ .src = .{ .to_mem, .none, .none } }, |
| 60996 | }, |
| 60997 | .call_frame = .{ .alignment = .@"16" }, |
| 60998 | .extra_temps = .{ |
| 60999 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 61000 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61001 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 61002 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 61003 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateisf" } } }, |
| 61004 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 61005 | .unused, |
| 61006 | .unused, |
| 61007 | .unused, |
| 61008 | }, |
| 61009 | .dst_temps = .{.mem}, |
| 61010 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61011 | .each = .{ .once = &.{ |
| 61012 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 61013 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 61014 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 61015 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 61016 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 61017 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 61018 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 61019 | .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, |
| 61020 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61021 | } }, |
| 61022 | }, .{ |
| 61023 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 61024 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 61025 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 61026 | .patterns = &.{ |
| 61027 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61028 | }, |
| 61029 | .call_frame = .{ .alignment = .@"16" }, |
| 61030 | .extra_temps = .{ |
| 61031 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 61032 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61033 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 61034 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 61035 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneisf" } } }, |
| 61036 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 61037 | .unused, |
| 61038 | .unused, |
| 61039 | .unused, |
| 61040 | }, |
| 61041 | .dst_temps = .{.mem}, |
| 61042 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61043 | .each = .{ .once = &.{ |
| 61044 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 61045 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 61046 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 61047 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 61048 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 61049 | .{ ._, .v_ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 61050 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 61051 | .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, |
| 61052 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61053 | } }, |
| 61054 | }, .{ |
| 61055 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 61056 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 61057 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }}, |
| 61058 | .patterns = &.{ |
| 61059 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61060 | }, |
| 61061 | .call_frame = .{ .alignment = .@"16" }, |
| 61062 | .extra_temps = .{ |
| 61063 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 61064 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61065 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 61066 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 61067 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneisf" } } }, |
| 61068 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 61069 | .unused, |
| 61070 | .unused, |
| 61071 | .unused, |
| 61072 | }, |
| 61073 | .dst_temps = .{.mem}, |
| 61074 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61075 | .each = .{ .once = &.{ |
| 61076 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 61077 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 61078 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 61079 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 61080 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 61081 | .{ ._, ._ss, .mov, .memia(.dst0d, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 61082 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 61083 | .{ ._, ._, .add, .tmp1p, .si(4), ._, ._ }, |
| 61084 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61085 | } }, |
| 61086 | }, .{ |
| 61087 | .required_features = .{ .avx, null, null, null }, |
| 61088 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 61089 | .dst_constraints = .{.{ .float = .qword }}, |
| 61090 | .patterns = &.{ |
| 61091 | .{ .src = .{ .mem, .none, .none } }, |
| 61092 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61093 | }, |
| 61094 | .extra_temps = .{ |
| 61095 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61096 | .unused, |
| 61097 | .unused, |
| 61098 | .unused, |
| 61099 | .unused, |
| 61100 | .unused, |
| 61101 | .unused, |
| 61102 | .unused, |
| 61103 | .unused, |
| 61104 | }, |
| 61105 | .dst_temps = .{.{ .rc = .sse }}, |
| 61106 | .each = .{ .once = &.{ |
| 61107 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 61108 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61109 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 61110 | } }, |
| 61111 | }, .{ |
| 61112 | .required_features = .{ .sse2, null, null, null }, |
| 61113 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 61114 | .dst_constraints = .{.{ .float = .qword }}, |
| 61115 | .patterns = &.{ |
| 61116 | .{ .src = .{ .mem, .none, .none } }, |
| 61117 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61118 | }, |
| 61119 | .extra_temps = .{ |
| 61120 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61121 | .unused, |
| 61122 | .unused, |
| 61123 | .unused, |
| 61124 | .unused, |
| 61125 | .unused, |
| 61126 | .unused, |
| 61127 | .unused, |
| 61128 | .unused, |
| 61129 | }, |
| 61130 | .dst_temps = .{.{ .rc = .sse }}, |
| 61131 | .each = .{ .once = &.{ |
| 61132 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 61133 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61134 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 61135 | } }, |
| 61136 | }, .{ |
| 61137 | .required_features = .{ .avx, null, null, null }, |
| 61138 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 61139 | .dst_constraints = .{.{ .float = .qword }}, |
| 61140 | .patterns = &.{ |
| 61141 | .{ .src = .{ .mem, .none, .none } }, |
| 61142 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61143 | }, |
| 61144 | .extra_temps = .{ |
| 61145 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61146 | .unused, |
| 61147 | .unused, |
| 61148 | .unused, |
| 61149 | .unused, |
| 61150 | .unused, |
| 61151 | .unused, |
| 61152 | .unused, |
| 61153 | .unused, |
| 61154 | }, |
| 61155 | .dst_temps = .{.{ .rc = .sse }}, |
| 61156 | .each = .{ .once = &.{ |
| 61157 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 61158 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61159 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 61160 | } }, |
| 61161 | }, .{ |
| 61162 | .required_features = .{ .sse2, null, null, null }, |
| 61163 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 61164 | .dst_constraints = .{.{ .float = .qword }}, |
| 61165 | .patterns = &.{ |
| 61166 | .{ .src = .{ .mem, .none, .none } }, |
| 61167 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61168 | }, |
| 61169 | .extra_temps = .{ |
| 61170 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61171 | .unused, |
| 61172 | .unused, |
| 61173 | .unused, |
| 61174 | .unused, |
| 61175 | .unused, |
| 61176 | .unused, |
| 61177 | .unused, |
| 61178 | .unused, |
| 61179 | }, |
| 61180 | .dst_temps = .{.{ .rc = .sse }}, |
| 61181 | .each = .{ .once = &.{ |
| 61182 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 61183 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61184 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 61185 | } }, |
| 61186 | }, .{ |
| 61187 | .required_features = .{ .avx, null, null, null }, |
| 61188 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 61189 | .dst_constraints = .{.{ .float = .qword }}, |
| 61190 | .patterns = &.{ |
| 61191 | .{ .src = .{ .mem, .none, .none } }, |
| 61192 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61193 | }, |
| 61194 | .extra_temps = .{ |
| 61195 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61196 | .unused, |
| 61197 | .unused, |
| 61198 | .unused, |
| 61199 | .unused, |
| 61200 | .unused, |
| 61201 | .unused, |
| 61202 | .unused, |
| 61203 | .unused, |
| 61204 | }, |
| 61205 | .dst_temps = .{.{ .rc = .sse }}, |
| 61206 | .each = .{ .once = &.{ |
| 61207 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 61208 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61209 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 61210 | } }, |
| 61211 | }, .{ |
| 61212 | .required_features = .{ .sse2, null, null, null }, |
| 61213 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 61214 | .dst_constraints = .{.{ .float = .qword }}, |
| 61215 | .patterns = &.{ |
| 61216 | .{ .src = .{ .mem, .none, .none } }, |
| 61217 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61218 | }, |
| 61219 | .extra_temps = .{ |
| 61220 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61221 | .unused, |
| 61222 | .unused, |
| 61223 | .unused, |
| 61224 | .unused, |
| 61225 | .unused, |
| 61226 | .unused, |
| 61227 | .unused, |
| 61228 | .unused, |
| 61229 | }, |
| 61230 | .dst_temps = .{.{ .rc = .sse }}, |
| 61231 | .each = .{ .once = &.{ |
| 61232 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 61233 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61234 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 61235 | } }, |
| 61236 | }, .{ |
| 61237 | .required_features = .{ .avx, null, null, null }, |
| 61238 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 61239 | .dst_constraints = .{.{ .float = .qword }}, |
| 61240 | .patterns = &.{ |
| 61241 | .{ .src = .{ .mem, .none, .none } }, |
| 61242 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61243 | }, |
| 61244 | .extra_temps = .{ |
| 61245 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61246 | .unused, |
| 61247 | .unused, |
| 61248 | .unused, |
| 61249 | .unused, |
| 61250 | .unused, |
| 61251 | .unused, |
| 61252 | .unused, |
| 61253 | .unused, |
| 61254 | }, |
| 61255 | .dst_temps = .{.{ .rc = .sse }}, |
| 61256 | .each = .{ .once = &.{ |
| 61257 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 61258 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61259 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 61260 | } }, |
| 61261 | }, .{ |
| 61262 | .required_features = .{ .sse2, null, null, null }, |
| 61263 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 61264 | .dst_constraints = .{.{ .float = .qword }}, |
| 61265 | .patterns = &.{ |
| 61266 | .{ .src = .{ .mem, .none, .none } }, |
| 61267 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61268 | }, |
| 61269 | .extra_temps = .{ |
| 61270 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61271 | .unused, |
| 61272 | .unused, |
| 61273 | .unused, |
| 61274 | .unused, |
| 61275 | .unused, |
| 61276 | .unused, |
| 61277 | .unused, |
| 61278 | .unused, |
| 61279 | }, |
| 61280 | .dst_temps = .{.{ .rc = .sse }}, |
| 61281 | .each = .{ .once = &.{ |
| 61282 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 61283 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61284 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 61285 | } }, |
| 61286 | }, .{ |
| 61287 | .required_features = .{ .avx, null, null, null }, |
| 61288 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 61289 | .dst_constraints = .{.{ .float = .qword }}, |
| 61290 | .patterns = &.{ |
| 61291 | .{ .src = .{ .mem, .none, .none } }, |
| 61292 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61293 | }, |
| 61294 | .dst_temps = .{.{ .rc = .sse }}, |
| 61295 | .each = .{ .once = &.{ |
| 61296 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61297 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, |
| 61298 | } }, |
| 61299 | }, .{ |
| 61300 | .required_features = .{ .sse2, null, null, null }, |
| 61301 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 61302 | .dst_constraints = .{.{ .float = .qword }}, |
| 61303 | .patterns = &.{ |
| 61304 | .{ .src = .{ .mem, .none, .none } }, |
| 61305 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61306 | }, |
| 61307 | .dst_temps = .{.{ .rc = .sse }}, |
| 61308 | .each = .{ .once = &.{ |
| 61309 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61310 | .{ ._, ._sd, .cvtsi2, .dst0x, .src0d, ._, ._ }, |
| 61311 | } }, |
| 61312 | }, .{ |
| 61313 | .required_features = .{ .avx, null, null, null }, |
| 61314 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 61315 | .dst_constraints = .{.{ .float = .qword }}, |
| 61316 | .patterns = &.{ |
| 61317 | .{ .src = .{ .mem, .none, .none } }, |
| 61318 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61319 | }, |
| 61320 | .extra_temps = .{ |
| 61321 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61322 | .unused, |
| 61323 | .unused, |
| 61324 | .unused, |
| 61325 | .unused, |
| 61326 | .unused, |
| 61327 | .unused, |
| 61328 | .unused, |
| 61329 | .unused, |
| 61330 | }, |
| 61331 | .dst_temps = .{.{ .rc = .sse }}, |
| 61332 | .each = .{ .once = &.{ |
| 61333 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 61334 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61335 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, |
| 61336 | } }, |
| 61337 | }, .{ |
| 61338 | .required_features = .{ .sse2, null, null, null }, |
| 61339 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 61340 | .dst_constraints = .{.{ .float = .qword }}, |
| 61341 | .patterns = &.{ |
| 61342 | .{ .src = .{ .mem, .none, .none } }, |
| 61343 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61344 | }, |
| 61345 | .extra_temps = .{ |
| 61346 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61347 | .unused, |
| 61348 | .unused, |
| 61349 | .unused, |
| 61350 | .unused, |
| 61351 | .unused, |
| 61352 | .unused, |
| 61353 | .unused, |
| 61354 | .unused, |
| 61355 | }, |
| 61356 | .dst_temps = .{.{ .rc = .sse }}, |
| 61357 | .each = .{ .once = &.{ |
| 61358 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 61359 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61360 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0q, ._, ._ }, |
| 61361 | } }, |
| 61362 | }, .{ |
| 61363 | .required_features = .{ .x87, null, null, null }, |
| 61364 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 61365 | .dst_constraints = .{.{ .float = .qword }}, |
| 61366 | .patterns = &.{ |
| 61367 | .{ .src = .{ .mem, .none, .none } }, |
| 61368 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61369 | }, |
| 61370 | .extra_temps = .{ |
| 61371 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61372 | .{ .type = .i16, .kind = .mem }, |
| 61373 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61374 | .unused, |
| 61375 | .unused, |
| 61376 | .unused, |
| 61377 | .unused, |
| 61378 | .unused, |
| 61379 | .unused, |
| 61380 | }, |
| 61381 | .dst_temps = .{.mem}, |
| 61382 | .each = .{ .once = &.{ |
| 61383 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 61384 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 61385 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 61386 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61387 | } }, |
| 61388 | }, .{ |
| 61389 | .required_features = .{ .x87, null, null, null }, |
| 61390 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 61391 | .dst_constraints = .{.{ .float = .qword }}, |
| 61392 | .patterns = &.{ |
| 61393 | .{ .src = .{ .mem, .none, .none } }, |
| 61394 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61395 | }, |
| 61396 | .extra_temps = .{ |
| 61397 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61398 | .{ .type = .i16, .kind = .mem }, |
| 61399 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61400 | .unused, |
| 61401 | .unused, |
| 61402 | .unused, |
| 61403 | .unused, |
| 61404 | .unused, |
| 61405 | .unused, |
| 61406 | }, |
| 61407 | .dst_temps = .{.mem}, |
| 61408 | .each = .{ .once = &.{ |
| 61409 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 61410 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 61411 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 61412 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61413 | } }, |
| 61414 | }, .{ |
| 61415 | .required_features = .{ .x87, null, null, null }, |
| 61416 | .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any }, |
| 61417 | .dst_constraints = .{.{ .float = .qword }}, |
| 61418 | .patterns = &.{ |
| 61419 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61420 | }, |
| 61421 | .extra_temps = .{ |
| 61422 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61423 | .unused, |
| 61424 | .unused, |
| 61425 | .unused, |
| 61426 | .unused, |
| 61427 | .unused, |
| 61428 | .unused, |
| 61429 | .unused, |
| 61430 | .unused, |
| 61431 | }, |
| 61432 | .dst_temps = .{.mem}, |
| 61433 | .each = .{ .once = &.{ |
| 61434 | .{ ._, .fi_, .ld, .src0w, ._, ._, ._ }, |
| 61435 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61436 | } }, |
| 61437 | }, .{ |
| 61438 | .required_features = .{ .x87, null, null, null }, |
| 61439 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any }, |
| 61440 | .dst_constraints = .{.{ .float = .qword }}, |
| 61441 | .patterns = &.{ |
| 61442 | .{ .src = .{ .mem, .none, .none } }, |
| 61443 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61444 | }, |
| 61445 | .extra_temps = .{ |
| 61446 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61447 | .{ .type = .i32, .kind = .mem }, |
| 61448 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61449 | .unused, |
| 61450 | .unused, |
| 61451 | .unused, |
| 61452 | .unused, |
| 61453 | .unused, |
| 61454 | .unused, |
| 61455 | }, |
| 61456 | .dst_temps = .{.mem}, |
| 61457 | .each = .{ .once = &.{ |
| 61458 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 61459 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 61460 | .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ }, |
| 61461 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61462 | } }, |
| 61463 | }, .{ |
| 61464 | .required_features = .{ .x87, null, null, null }, |
| 61465 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 61466 | .dst_constraints = .{.{ .float = .qword }}, |
| 61467 | .patterns = &.{ |
| 61468 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61469 | }, |
| 61470 | .extra_temps = .{ |
| 61471 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61472 | .unused, |
| 61473 | .unused, |
| 61474 | .unused, |
| 61475 | .unused, |
| 61476 | .unused, |
| 61477 | .unused, |
| 61478 | .unused, |
| 61479 | .unused, |
| 61480 | }, |
| 61481 | .dst_temps = .{.mem}, |
| 61482 | .each = .{ .once = &.{ |
| 61483 | .{ ._, .fi_, .ld, .src0d, ._, ._, ._ }, |
| 61484 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61485 | } }, |
| 61486 | }, .{ |
| 61487 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 61488 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 61489 | .dst_constraints = .{.{ .float = .qword }}, |
| 61490 | .patterns = &.{ |
| 61491 | .{ .src = .{ .mem, .none, .none } }, |
| 61492 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61493 | }, |
| 61494 | .extra_temps = .{ |
| 61495 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 61496 | .{ .type = .i64, .kind = .mem }, |
| 61497 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61498 | .unused, |
| 61499 | .unused, |
| 61500 | .unused, |
| 61501 | .unused, |
| 61502 | .unused, |
| 61503 | .unused, |
| 61504 | }, |
| 61505 | .dst_temps = .{.mem}, |
| 61506 | .each = .{ .once = &.{ |
| 61507 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 61508 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| 61509 | .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ }, |
| 61510 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61511 | } }, |
| 61512 | }, .{ |
| 61513 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 61514 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 61515 | .dst_constraints = .{.{ .float = .qword }}, |
| 61516 | .patterns = &.{ |
| 61517 | .{ .src = .{ .mem, .none, .none } }, |
| 61518 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61519 | }, |
| 61520 | .dst_temps = .{.{ .rc = .sse }}, |
| 61521 | .each = .{ .once = &.{ |
| 61522 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 61523 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 61524 | } }, |
| 61525 | }, .{ |
| 61526 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 61527 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 61528 | .dst_constraints = .{.{ .float = .qword }}, |
| 61529 | .patterns = &.{ |
| 61530 | .{ .src = .{ .mem, .none, .none } }, |
| 61531 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61532 | }, |
| 61533 | .dst_temps = .{.{ .rc = .sse }}, |
| 61534 | .each = .{ .once = &.{ |
| 61535 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 61536 | .{ ._, ._sd, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 61537 | } }, |
| 61538 | }, .{ |
| 61539 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 61540 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 61541 | .dst_constraints = .{.{ .float = .qword }}, |
| 61542 | .patterns = &.{ |
| 61543 | .{ .src = .{ .mem, .none, .none } }, |
| 61544 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61545 | }, |
| 61546 | .extra_temps = .{ |
| 61547 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 61548 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 61549 | .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem }, |
| 61550 | .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem }, |
| 61551 | .unused, |
| 61552 | .unused, |
| 61553 | .unused, |
| 61554 | .unused, |
| 61555 | .unused, |
| 61556 | }, |
| 61557 | .dst_temps = .{.{ .rc = .sse }}, |
| 61558 | .each = .{ .once = &.{ |
| 61559 | .{ ._, .v_q, .mov, .tmp0x, .src0q, ._, ._ }, |
| 61560 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 61561 | .{ ._, .vp_, .unpckldq, .tmp0x, .tmp0x, .lea(.tmp1x), ._ }, |
| 61562 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 61563 | .{ ._, .v_pd, .sub, .tmp0x, .tmp0x, .lea(.tmp1x), ._ }, |
| 61564 | .{ ._, .v_pd, .unpckh, .dst0x, .tmp0x, .tmp0x, ._ }, |
| 61565 | .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ }, |
| 61566 | } }, |
| 61567 | }, .{ |
| 61568 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 61569 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 61570 | .dst_constraints = .{.{ .float = .qword }}, |
| 61571 | .patterns = &.{ |
| 61572 | .{ .src = .{ .mem, .none, .none } }, |
| 61573 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 61574 | }, |
| 61575 | .extra_temps = .{ |
| 61576 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 61577 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 61578 | .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem }, |
| 61579 | .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem }, |
| 61580 | .unused, |
| 61581 | .unused, |
| 61582 | .unused, |
| 61583 | .unused, |
| 61584 | .unused, |
| 61585 | }, |
| 61586 | .dst_temps = .{.{ .rc = .sse }}, |
| 61587 | .each = .{ .once = &.{ |
| 61588 | .{ ._, ._q, .mov, .tmp0x, .src0q, ._, ._ }, |
| 61589 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 61590 | .{ ._, .p_, .unpckldq, .tmp0x, .lea(.tmp1x), ._, ._ }, |
| 61591 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 61592 | .{ ._, ._pd, .sub, .tmp0x, .lea(.tmp1x), ._, ._ }, |
| 61593 | .{ ._, ._pd, .mova, .dst0x, .tmp0x, ._, ._ }, |
| 61594 | .{ ._, ._pd, .unpckh, .dst0x, .dst0x, ._, ._ }, |
| 61595 | .{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ }, |
| 61596 | } }, |
| 61597 | }, .{ |
| 61598 | .required_features = .{ .x87, null, null, null }, |
| 61599 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 61600 | .dst_constraints = .{.{ .float = .qword }}, |
| 61601 | .patterns = &.{ |
| 61602 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61603 | }, |
| 61604 | .extra_temps = .{ |
| 61605 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61606 | .unused, |
| 61607 | .unused, |
| 61608 | .unused, |
| 61609 | .unused, |
| 61610 | .unused, |
| 61611 | .unused, |
| 61612 | .unused, |
| 61613 | .unused, |
| 61614 | }, |
| 61615 | .dst_temps = .{.mem}, |
| 61616 | .each = .{ .once = &.{ |
| 61617 | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, |
| 61618 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61619 | } }, |
| 61620 | }, .{ |
| 61621 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 61622 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 61623 | .dst_constraints = .{.{ .float = .qword }}, |
| 61624 | .patterns = &.{ |
| 61625 | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 61626 | }, |
| 61627 | .extra_temps = .{ |
| 61628 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 61629 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 61630 | .unused, |
| 61631 | .unused, |
| 61632 | .unused, |
| 61633 | .unused, |
| 61634 | .unused, |
| 61635 | .unused, |
| 61636 | .unused, |
| 61637 | }, |
| 61638 | .dst_temps = .{.mem}, |
| 61639 | .clobbers = .{ .eflags = true }, |
| 61640 | .each = .{ .once = &.{ |
| 61641 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 61642 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 61643 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 61644 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 61645 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 61646 | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 61647 | .{ ._, ._, .mov, .dst0q, .src0q, ._, ._ }, |
| 61648 | .{ ._, .fi_, .ld, .dst0q, ._, ._, ._ }, |
| 61649 | .{ ._, .f_, .add, .tmp1t, .tmp1t, ._, ._ }, |
| 61650 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 61651 | .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ }, |
| 61652 | .{ .@"1:", ._, .mov, .dst0q, .src0q, ._, ._ }, |
| 61653 | .{ ._, .fi_, .ld, .dst0q, ._, ._, ._ }, |
| 61654 | .{ .@"0:", .f_p, .st, .dst0q, ._, ._, ._ }, |
| 61655 | } }, |
| 61656 | }, .{ |
| 61657 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 61658 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 61659 | .dst_constraints = .{.{ .float = .qword }}, |
| 61660 | .patterns = &.{ |
| 61661 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 61662 | }, |
| 61663 | .call_frame = .{ .alignment = .@"16" }, |
| 61664 | .extra_temps = .{ |
| 61665 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } }, |
| 61666 | .unused, |
| 61667 | .unused, |
| 61668 | .unused, |
| 61669 | .unused, |
| 61670 | .unused, |
| 61671 | .unused, |
| 61672 | .unused, |
| 61673 | .unused, |
| 61674 | }, |
| 61675 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 61676 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61677 | .each = .{ .once = &.{ |
| 61678 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 61679 | } }, |
| 61680 | }, .{ |
| 61681 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 61682 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 61683 | .dst_constraints = .{.{ .float = .qword }}, |
| 61684 | .patterns = &.{ |
| 61685 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 61686 | }, |
| 61687 | .call_frame = .{ .alignment = .@"16" }, |
| 61688 | .extra_temps = .{ |
| 61689 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } }, |
| 61690 | .unused, |
| 61691 | .unused, |
| 61692 | .unused, |
| 61693 | .unused, |
| 61694 | .unused, |
| 61695 | .unused, |
| 61696 | .unused, |
| 61697 | .unused, |
| 61698 | }, |
| 61699 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 61700 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61701 | .each = .{ .once = &.{ |
| 61702 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 61703 | } }, |
| 61704 | }, .{ |
| 61705 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 61706 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 61707 | .dst_constraints = .{.{ .float = .qword }}, |
| 61708 | .patterns = &.{ |
| 61709 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61710 | }, |
| 61711 | .call_frame = .{ .alignment = .@"16" }, |
| 61712 | .extra_temps = .{ |
| 61713 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 61714 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 61715 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } }, |
| 61716 | .unused, |
| 61717 | .unused, |
| 61718 | .unused, |
| 61719 | .unused, |
| 61720 | .unused, |
| 61721 | .unused, |
| 61722 | }, |
| 61723 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 61724 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61725 | .each = .{ .once = &.{ |
| 61726 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 61727 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 61728 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 61729 | } }, |
| 61730 | }, .{ |
| 61731 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 61732 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 61733 | .dst_constraints = .{.{ .float = .qword }}, |
| 61734 | .patterns = &.{ |
| 61735 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61736 | }, |
| 61737 | .call_frame = .{ .alignment = .@"16" }, |
| 61738 | .extra_temps = .{ |
| 61739 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 61740 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 61741 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } }, |
| 61742 | .unused, |
| 61743 | .unused, |
| 61744 | .unused, |
| 61745 | .unused, |
| 61746 | .unused, |
| 61747 | .unused, |
| 61748 | }, |
| 61749 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 61750 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 61751 | .each = .{ .once = &.{ |
| 61752 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 61753 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 61754 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 61755 | } }, |
| 61756 | }, .{ |
| 61757 | .required_features = .{ .avx, null, null, null }, |
| 61758 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61759 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61760 | .patterns = &.{ |
| 61761 | .{ .src = .{ .mem, .none, .none } }, |
| 61762 | .{ .src = .{ .to_sse, .none, .none } }, |
| 61763 | }, |
| 61764 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 61765 | .each = .{ .once = &.{ |
| 61766 | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 61767 | .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 61768 | } }, |
| 61769 | }, .{ |
| 61770 | .required_features = .{ .sse4_1, null, null, null }, |
| 61771 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61772 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61773 | .patterns = &.{ |
| 61774 | .{ .src = .{ .mem, .none, .none } }, |
| 61775 | .{ .src = .{ .to_sse, .none, .none } }, |
| 61776 | }, |
| 61777 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 61778 | .each = .{ .once = &.{ |
| 61779 | .{ ._, .p_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 61780 | .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 61781 | } }, |
| 61782 | }, .{ |
| 61783 | .required_features = .{ .avx2, null, null, null }, |
| 61784 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 61785 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 61786 | .patterns = &.{ |
| 61787 | .{ .src = .{ .mem, .none, .none } }, |
| 61788 | .{ .src = .{ .to_sse, .none, .none } }, |
| 61789 | }, |
| 61790 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 61791 | .each = .{ .once = &.{ |
| 61792 | .{ ._, .vp_d, .movsxb, .dst0x, .src0d, ._, ._ }, |
| 61793 | .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ }, |
| 61794 | } }, |
| 61795 | }, .{ |
| 61796 | .required_features = .{ .avx, null, null, null }, |
| 61797 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61798 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61799 | .patterns = &.{ |
| 61800 | .{ .src = .{ .mem, .none, .none } }, |
| 61801 | .{ .src = .{ .to_sse, .none, .none } }, |
| 61802 | }, |
| 61803 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 61804 | .each = .{ .once = &.{ |
| 61805 | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 61806 | .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 61807 | } }, |
| 61808 | }, .{ |
| 61809 | .required_features = .{ .sse4_1, null, null, null }, |
| 61810 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61811 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61812 | .patterns = &.{ |
| 61813 | .{ .src = .{ .mem, .none, .none } }, |
| 61814 | .{ .src = .{ .to_sse, .none, .none } }, |
| 61815 | }, |
| 61816 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 61817 | .each = .{ .once = &.{ |
| 61818 | .{ ._, .p_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 61819 | .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 61820 | } }, |
| 61821 | }, .{ |
| 61822 | .required_features = .{ .avx2, null, null, null }, |
| 61823 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 61824 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 61825 | .patterns = &.{ |
| 61826 | .{ .src = .{ .mem, .none, .none } }, |
| 61827 | .{ .src = .{ .to_sse, .none, .none } }, |
| 61828 | }, |
| 61829 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 61830 | .each = .{ .once = &.{ |
| 61831 | .{ ._, .vp_d, .movzxb, .dst0x, .src0d, ._, ._ }, |
| 61832 | .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ }, |
| 61833 | } }, |
| 61834 | }, .{ |
| 61835 | .required_features = .{ .avx2, null, null, null }, |
| 61836 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 61837 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 61838 | .patterns = &.{ |
| 61839 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61840 | }, |
| 61841 | .extra_temps = .{ |
| 61842 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61843 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 61844 | .unused, |
| 61845 | .unused, |
| 61846 | .unused, |
| 61847 | .unused, |
| 61848 | .unused, |
| 61849 | .unused, |
| 61850 | .unused, |
| 61851 | }, |
| 61852 | .dst_temps = .{.mem}, |
| 61853 | .clobbers = .{ .eflags = true }, |
| 61854 | .each = .{ .once = &.{ |
| 61855 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 61856 | .{ .@"0:", .vp_d, .movsxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 61857 | .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, |
| 61858 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 61859 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 61860 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61861 | } }, |
| 61862 | }, .{ |
| 61863 | .required_features = .{ .avx, null, null, null }, |
| 61864 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61865 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61866 | .patterns = &.{ |
| 61867 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61868 | }, |
| 61869 | .extra_temps = .{ |
| 61870 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61871 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 61872 | .unused, |
| 61873 | .unused, |
| 61874 | .unused, |
| 61875 | .unused, |
| 61876 | .unused, |
| 61877 | .unused, |
| 61878 | .unused, |
| 61879 | }, |
| 61880 | .dst_temps = .{.mem}, |
| 61881 | .clobbers = .{ .eflags = true }, |
| 61882 | .each = .{ .once = &.{ |
| 61883 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 61884 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 61885 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 61886 | .{ ._, .vp_d, .movsxb, .tmp1x, .tmp1d, ._, ._ }, |
| 61887 | .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 61888 | .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 61889 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 61890 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61891 | } }, |
| 61892 | }, .{ |
| 61893 | .required_features = .{ .sse4_1, null, null, null }, |
| 61894 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61895 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61896 | .patterns = &.{ |
| 61897 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61898 | }, |
| 61899 | .extra_temps = .{ |
| 61900 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61901 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 61902 | .unused, |
| 61903 | .unused, |
| 61904 | .unused, |
| 61905 | .unused, |
| 61906 | .unused, |
| 61907 | .unused, |
| 61908 | .unused, |
| 61909 | }, |
| 61910 | .dst_temps = .{.mem}, |
| 61911 | .clobbers = .{ .eflags = true }, |
| 61912 | .each = .{ .once = &.{ |
| 61913 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 61914 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 61915 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 61916 | .{ ._, .p_d, .movsxb, .tmp1x, .tmp1d, ._, ._ }, |
| 61917 | .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 61918 | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 61919 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 61920 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61921 | } }, |
| 61922 | }, .{ |
| 61923 | .required_features = .{ .avx2, null, null, null }, |
| 61924 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .byte } }, .any, .any }, |
| 61925 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 61926 | .patterns = &.{ |
| 61927 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61928 | }, |
| 61929 | .extra_temps = .{ |
| 61930 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61931 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 61932 | .unused, |
| 61933 | .unused, |
| 61934 | .unused, |
| 61935 | .unused, |
| 61936 | .unused, |
| 61937 | .unused, |
| 61938 | .unused, |
| 61939 | }, |
| 61940 | .dst_temps = .{.mem}, |
| 61941 | .clobbers = .{ .eflags = true }, |
| 61942 | .each = .{ .once = &.{ |
| 61943 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 61944 | .{ .@"0:", .vp_d, .movzxb, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 61945 | .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, |
| 61946 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"8", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 61947 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 61948 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61949 | } }, |
| 61950 | }, .{ |
| 61951 | .required_features = .{ .avx, null, null, null }, |
| 61952 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61953 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61954 | .patterns = &.{ |
| 61955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61956 | }, |
| 61957 | .extra_temps = .{ |
| 61958 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61959 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 61960 | .unused, |
| 61961 | .unused, |
| 61962 | .unused, |
| 61963 | .unused, |
| 61964 | .unused, |
| 61965 | .unused, |
| 61966 | .unused, |
| 61967 | }, |
| 61968 | .dst_temps = .{.mem}, |
| 61969 | .clobbers = .{ .eflags = true }, |
| 61970 | .each = .{ .once = &.{ |
| 61971 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 61972 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 61973 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 61974 | .{ ._, .vp_d, .movzxb, .tmp1x, .tmp1d, ._, ._ }, |
| 61975 | .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 61976 | .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 61977 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 61978 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 61979 | } }, |
| 61980 | }, .{ |
| 61981 | .required_features = .{ .sse4_1, null, null, null }, |
| 61982 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .byte } }, .any, .any }, |
| 61983 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 61984 | .patterns = &.{ |
| 61985 | .{ .src = .{ .to_mem, .none, .none } }, |
| 61986 | }, |
| 61987 | .extra_temps = .{ |
| 61988 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 61989 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 61990 | .unused, |
| 61991 | .unused, |
| 61992 | .unused, |
| 61993 | .unused, |
| 61994 | .unused, |
| 61995 | .unused, |
| 61996 | .unused, |
| 61997 | }, |
| 61998 | .dst_temps = .{.mem}, |
| 61999 | .clobbers = .{ .eflags = true }, |
| 62000 | .each = .{ .once = &.{ |
| 62001 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62002 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 62003 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 62004 | .{ ._, .p_d, .movzxb, .tmp1x, .tmp1d, ._, ._ }, |
| 62005 | .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 62006 | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62007 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62008 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62009 | } }, |
| 62010 | }, .{ |
| 62011 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 62012 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62013 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62014 | .patterns = &.{ |
| 62015 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62016 | }, |
| 62017 | .call_frame = .{ .alignment = .@"16" }, |
| 62018 | .extra_temps = .{ |
| 62019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62020 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62021 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62022 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62023 | .unused, |
| 62024 | .unused, |
| 62025 | .unused, |
| 62026 | .unused, |
| 62027 | .unused, |
| 62028 | }, |
| 62029 | .dst_temps = .{.mem}, |
| 62030 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62031 | .each = .{ .once = &.{ |
| 62032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62033 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62034 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62035 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62036 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 62037 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62038 | } }, |
| 62039 | }, .{ |
| 62040 | .required_features = .{ .avx, null, null, null }, |
| 62041 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62042 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62043 | .patterns = &.{ |
| 62044 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62045 | }, |
| 62046 | .call_frame = .{ .alignment = .@"16" }, |
| 62047 | .extra_temps = .{ |
| 62048 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62049 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62050 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62051 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62052 | .unused, |
| 62053 | .unused, |
| 62054 | .unused, |
| 62055 | .unused, |
| 62056 | .unused, |
| 62057 | }, |
| 62058 | .dst_temps = .{.mem}, |
| 62059 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62060 | .each = .{ .once = &.{ |
| 62061 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62062 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62063 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62064 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62065 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 62066 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 62067 | } }, |
| 62068 | }, .{ |
| 62069 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 62070 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62071 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62072 | .patterns = &.{ |
| 62073 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62074 | }, |
| 62075 | .call_frame = .{ .alignment = .@"16" }, |
| 62076 | .extra_temps = .{ |
| 62077 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62078 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62079 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62080 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62081 | .unused, |
| 62082 | .unused, |
| 62083 | .unused, |
| 62084 | .unused, |
| 62085 | .unused, |
| 62086 | }, |
| 62087 | .dst_temps = .{.mem}, |
| 62088 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62089 | .each = .{ .once = &.{ |
| 62090 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62091 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62092 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62093 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62094 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 62095 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62096 | } }, |
| 62097 | }, .{ |
| 62098 | .required_features = .{ .sse2, null, null, null }, |
| 62099 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62100 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62101 | .patterns = &.{ |
| 62102 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62103 | }, |
| 62104 | .call_frame = .{ .alignment = .@"16" }, |
| 62105 | .extra_temps = .{ |
| 62106 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62107 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62108 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62109 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62110 | .unused, |
| 62111 | .unused, |
| 62112 | .unused, |
| 62113 | .unused, |
| 62114 | .unused, |
| 62115 | }, |
| 62116 | .dst_temps = .{.mem}, |
| 62117 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62118 | .each = .{ .once = &.{ |
| 62119 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62120 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62121 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62122 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62123 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 62124 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 62125 | } }, |
| 62126 | }, .{ |
| 62127 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 62128 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62129 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62130 | .patterns = &.{ |
| 62131 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62132 | }, |
| 62133 | .call_frame = .{ .alignment = .@"16" }, |
| 62134 | .extra_temps = .{ |
| 62135 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62136 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62137 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62138 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62139 | .unused, |
| 62140 | .unused, |
| 62141 | .unused, |
| 62142 | .unused, |
| 62143 | .unused, |
| 62144 | }, |
| 62145 | .dst_temps = .{.mem}, |
| 62146 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62147 | .each = .{ .once = &.{ |
| 62148 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62149 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62150 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62151 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62152 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 62153 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62154 | } }, |
| 62155 | }, .{ |
| 62156 | .required_features = .{ .sse, null, null, null }, |
| 62157 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62158 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62159 | .patterns = &.{ |
| 62160 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62161 | }, |
| 62162 | .call_frame = .{ .alignment = .@"16" }, |
| 62163 | .extra_temps = .{ |
| 62164 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62165 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62166 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62167 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62168 | .unused, |
| 62169 | .unused, |
| 62170 | .unused, |
| 62171 | .unused, |
| 62172 | .unused, |
| 62173 | }, |
| 62174 | .dst_temps = .{.mem}, |
| 62175 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62176 | .each = .{ .once = &.{ |
| 62177 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62178 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62179 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62180 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62181 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 62182 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 62183 | } }, |
| 62184 | }, .{ |
| 62185 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 62186 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62187 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62188 | .patterns = &.{ |
| 62189 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62190 | }, |
| 62191 | .call_frame = .{ .alignment = .@"16" }, |
| 62192 | .extra_temps = .{ |
| 62193 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62194 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62195 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62196 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62197 | .unused, |
| 62198 | .unused, |
| 62199 | .unused, |
| 62200 | .unused, |
| 62201 | .unused, |
| 62202 | }, |
| 62203 | .dst_temps = .{.mem}, |
| 62204 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62205 | .each = .{ .once = &.{ |
| 62206 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62207 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62208 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62209 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62210 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 62211 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62212 | } }, |
| 62213 | }, .{ |
| 62214 | .required_features = .{ .avx, null, null, null }, |
| 62215 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62216 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62217 | .patterns = &.{ |
| 62218 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62219 | }, |
| 62220 | .call_frame = .{ .alignment = .@"16" }, |
| 62221 | .extra_temps = .{ |
| 62222 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62223 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62224 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62225 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62226 | .unused, |
| 62227 | .unused, |
| 62228 | .unused, |
| 62229 | .unused, |
| 62230 | .unused, |
| 62231 | }, |
| 62232 | .dst_temps = .{.mem}, |
| 62233 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62234 | .each = .{ .once = &.{ |
| 62235 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62236 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62237 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62238 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62239 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 62240 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 62241 | } }, |
| 62242 | }, .{ |
| 62243 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 62244 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62245 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62246 | .patterns = &.{ |
| 62247 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62248 | }, |
| 62249 | .call_frame = .{ .alignment = .@"16" }, |
| 62250 | .extra_temps = .{ |
| 62251 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62252 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62253 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62254 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62255 | .unused, |
| 62256 | .unused, |
| 62257 | .unused, |
| 62258 | .unused, |
| 62259 | .unused, |
| 62260 | }, |
| 62261 | .dst_temps = .{.mem}, |
| 62262 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62263 | .each = .{ .once = &.{ |
| 62264 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62265 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62266 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62267 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62268 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 62269 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62270 | } }, |
| 62271 | }, .{ |
| 62272 | .required_features = .{ .sse2, null, null, null }, |
| 62273 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62274 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62275 | .patterns = &.{ |
| 62276 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62277 | }, |
| 62278 | .call_frame = .{ .alignment = .@"16" }, |
| 62279 | .extra_temps = .{ |
| 62280 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62281 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62282 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62283 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62284 | .unused, |
| 62285 | .unused, |
| 62286 | .unused, |
| 62287 | .unused, |
| 62288 | .unused, |
| 62289 | }, |
| 62290 | .dst_temps = .{.mem}, |
| 62291 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62292 | .each = .{ .once = &.{ |
| 62293 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62294 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62295 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62296 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62297 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 62298 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 62299 | } }, |
| 62300 | }, .{ |
| 62301 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 62302 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62303 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62304 | .patterns = &.{ |
| 62305 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62306 | }, |
| 62307 | .call_frame = .{ .alignment = .@"16" }, |
| 62308 | .extra_temps = .{ |
| 62309 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62310 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62311 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62312 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62313 | .unused, |
| 62314 | .unused, |
| 62315 | .unused, |
| 62316 | .unused, |
| 62317 | .unused, |
| 62318 | }, |
| 62319 | .dst_temps = .{.mem}, |
| 62320 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62321 | .each = .{ .once = &.{ |
| 62322 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62323 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62324 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62325 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62326 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 62327 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62328 | } }, |
| 62329 | }, .{ |
| 62330 | .required_features = .{ .sse, null, null, null }, |
| 62331 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 62332 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62333 | .patterns = &.{ |
| 62334 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62335 | }, |
| 62336 | .call_frame = .{ .alignment = .@"16" }, |
| 62337 | .extra_temps = .{ |
| 62338 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62339 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62340 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62341 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62342 | .unused, |
| 62343 | .unused, |
| 62344 | .unused, |
| 62345 | .unused, |
| 62346 | .unused, |
| 62347 | }, |
| 62348 | .dst_temps = .{.mem}, |
| 62349 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62350 | .each = .{ .once = &.{ |
| 62351 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62352 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62353 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62354 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62355 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 62356 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 62357 | } }, |
| 62358 | }, .{ |
| 62359 | .required_features = .{ .avx, null, null, null }, |
| 62360 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62361 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62362 | .patterns = &.{ |
| 62363 | .{ .src = .{ .mem, .none, .none } }, |
| 62364 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62365 | }, |
| 62366 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62367 | .each = .{ .once = &.{ |
| 62368 | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 62369 | .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 62370 | } }, |
| 62371 | }, .{ |
| 62372 | .required_features = .{ .sse4_1, null, null, null }, |
| 62373 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62374 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62375 | .patterns = &.{ |
| 62376 | .{ .src = .{ .mem, .none, .none } }, |
| 62377 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62378 | }, |
| 62379 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62380 | .each = .{ .once = &.{ |
| 62381 | .{ ._, .p_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 62382 | .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 62383 | } }, |
| 62384 | }, .{ |
| 62385 | .required_features = .{ .avx2, null, null, null }, |
| 62386 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 62387 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 62388 | .patterns = &.{ |
| 62389 | .{ .src = .{ .mem, .none, .none } }, |
| 62390 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62391 | }, |
| 62392 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62393 | .each = .{ .once = &.{ |
| 62394 | .{ ._, .vp_d, .movsxw, .dst0x, .src0q, ._, ._ }, |
| 62395 | .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ }, |
| 62396 | } }, |
| 62397 | }, .{ |
| 62398 | .required_features = .{ .avx, null, null, null }, |
| 62399 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62400 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62401 | .patterns = &.{ |
| 62402 | .{ .src = .{ .mem, .none, .none } }, |
| 62403 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62404 | }, |
| 62405 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62406 | .each = .{ .once = &.{ |
| 62407 | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 62408 | .{ ._, .v_pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 62409 | } }, |
| 62410 | }, .{ |
| 62411 | .required_features = .{ .sse4_1, null, null, null }, |
| 62412 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62413 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62414 | .patterns = &.{ |
| 62415 | .{ .src = .{ .mem, .none, .none } }, |
| 62416 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62417 | }, |
| 62418 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62419 | .each = .{ .once = &.{ |
| 62420 | .{ ._, .p_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 62421 | .{ ._, ._pd, .cvtdq2, .dst0x, .dst0q, ._, ._ }, |
| 62422 | } }, |
| 62423 | }, .{ |
| 62424 | .required_features = .{ .avx2, null, null, null }, |
| 62425 | .src_constraints = .{ .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 62426 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 62427 | .patterns = &.{ |
| 62428 | .{ .src = .{ .mem, .none, .none } }, |
| 62429 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62430 | }, |
| 62431 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62432 | .each = .{ .once = &.{ |
| 62433 | .{ ._, .vp_d, .movzxw, .dst0x, .src0q, ._, ._ }, |
| 62434 | .{ ._, .v_pd, .cvtdq2, .dst0y, .dst0x, ._, ._ }, |
| 62435 | } }, |
| 62436 | }, .{ |
| 62437 | .required_features = .{ .avx2, null, null, null }, |
| 62438 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 62439 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 62440 | .patterns = &.{ |
| 62441 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62442 | }, |
| 62443 | .extra_temps = .{ |
| 62444 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62445 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 62446 | .unused, |
| 62447 | .unused, |
| 62448 | .unused, |
| 62449 | .unused, |
| 62450 | .unused, |
| 62451 | .unused, |
| 62452 | .unused, |
| 62453 | }, |
| 62454 | .dst_temps = .{.mem}, |
| 62455 | .clobbers = .{ .eflags = true }, |
| 62456 | .each = .{ .once = &.{ |
| 62457 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62458 | .{ .@"0:", .vp_d, .movsxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62459 | .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, |
| 62460 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 62461 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 62462 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62463 | } }, |
| 62464 | }, .{ |
| 62465 | .required_features = .{ .avx, null, null, null }, |
| 62466 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62467 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62468 | .patterns = &.{ |
| 62469 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62470 | }, |
| 62471 | .extra_temps = .{ |
| 62472 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62473 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 62474 | .unused, |
| 62475 | .unused, |
| 62476 | .unused, |
| 62477 | .unused, |
| 62478 | .unused, |
| 62479 | .unused, |
| 62480 | .unused, |
| 62481 | }, |
| 62482 | .dst_temps = .{.mem}, |
| 62483 | .clobbers = .{ .eflags = true }, |
| 62484 | .each = .{ .once = &.{ |
| 62485 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62486 | .{ .@"0:", .v_d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62487 | .{ ._, .vp_d, .movsxw, .tmp1x, .tmp1q, ._, ._ }, |
| 62488 | .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 62489 | .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62490 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62491 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62492 | } }, |
| 62493 | }, .{ |
| 62494 | .required_features = .{ .sse4_1, null, null, null }, |
| 62495 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62496 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62497 | .patterns = &.{ |
| 62498 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62499 | }, |
| 62500 | .extra_temps = .{ |
| 62501 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62502 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 62503 | .unused, |
| 62504 | .unused, |
| 62505 | .unused, |
| 62506 | .unused, |
| 62507 | .unused, |
| 62508 | .unused, |
| 62509 | .unused, |
| 62510 | }, |
| 62511 | .dst_temps = .{.mem}, |
| 62512 | .clobbers = .{ .eflags = true }, |
| 62513 | .each = .{ .once = &.{ |
| 62514 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62515 | .{ .@"0:", ._d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62516 | .{ ._, .p_d, .movsxw, .tmp1x, .tmp1q, ._, ._ }, |
| 62517 | .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 62518 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62519 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62520 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62521 | } }, |
| 62522 | }, .{ |
| 62523 | .required_features = .{ .avx2, null, null, null }, |
| 62524 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 62525 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 62526 | .patterns = &.{ |
| 62527 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62528 | }, |
| 62529 | .extra_temps = .{ |
| 62530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62531 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 62532 | .unused, |
| 62533 | .unused, |
| 62534 | .unused, |
| 62535 | .unused, |
| 62536 | .unused, |
| 62537 | .unused, |
| 62538 | .unused, |
| 62539 | }, |
| 62540 | .dst_temps = .{.mem}, |
| 62541 | .clobbers = .{ .eflags = true }, |
| 62542 | .each = .{ .once = &.{ |
| 62543 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62544 | .{ .@"0:", .vp_d, .movzxw, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62545 | .{ ._, .v_pd, .cvtdq2, .tmp1y, .tmp1x, ._, ._ }, |
| 62546 | .{ ._, .v_ps, .mova, .memsia(.dst0y, .@"4", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 62547 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 62548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62549 | } }, |
| 62550 | }, .{ |
| 62551 | .required_features = .{ .avx, null, null, null }, |
| 62552 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62553 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62554 | .patterns = &.{ |
| 62555 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62556 | }, |
| 62557 | .extra_temps = .{ |
| 62558 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62559 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 62560 | .unused, |
| 62561 | .unused, |
| 62562 | .unused, |
| 62563 | .unused, |
| 62564 | .unused, |
| 62565 | .unused, |
| 62566 | .unused, |
| 62567 | }, |
| 62568 | .dst_temps = .{.mem}, |
| 62569 | .clobbers = .{ .eflags = true }, |
| 62570 | .each = .{ .once = &.{ |
| 62571 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62572 | .{ .@"0:", .v_d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62573 | .{ ._, .vp_d, .movzxw, .tmp1x, .tmp1q, ._, ._ }, |
| 62574 | .{ ._, .v_pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 62575 | .{ ._, .v_ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62576 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62577 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62578 | } }, |
| 62579 | }, .{ |
| 62580 | .required_features = .{ .sse4_1, null, null, null }, |
| 62581 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .word } }, .any, .any }, |
| 62582 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62583 | .patterns = &.{ |
| 62584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62585 | }, |
| 62586 | .extra_temps = .{ |
| 62587 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62588 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 62589 | .unused, |
| 62590 | .unused, |
| 62591 | .unused, |
| 62592 | .unused, |
| 62593 | .unused, |
| 62594 | .unused, |
| 62595 | .unused, |
| 62596 | }, |
| 62597 | .dst_temps = .{.mem}, |
| 62598 | .clobbers = .{ .eflags = true }, |
| 62599 | .each = .{ .once = &.{ |
| 62600 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62601 | .{ .@"0:", ._d, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62602 | .{ ._, .p_d, .movzxw, .tmp1x, .tmp1q, ._, ._ }, |
| 62603 | .{ ._, ._pd, .cvtdq2, .tmp1x, .tmp1q, ._, ._ }, |
| 62604 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62605 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62606 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62607 | } }, |
| 62608 | }, .{ |
| 62609 | .required_features = .{ .avx, null, null, null }, |
| 62610 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 62611 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62612 | .patterns = &.{ |
| 62613 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62614 | }, |
| 62615 | .call_frame = .{ .alignment = .@"16" }, |
| 62616 | .extra_temps = .{ |
| 62617 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62618 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62619 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62620 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62621 | .unused, |
| 62622 | .unused, |
| 62623 | .unused, |
| 62624 | .unused, |
| 62625 | .unused, |
| 62626 | }, |
| 62627 | .dst_temps = .{.mem}, |
| 62628 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62629 | .each = .{ .once = &.{ |
| 62630 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62631 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62632 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62633 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62634 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62635 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62636 | } }, |
| 62637 | }, .{ |
| 62638 | .required_features = .{ .sse2, null, null, null }, |
| 62639 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 62640 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62641 | .patterns = &.{ |
| 62642 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62643 | }, |
| 62644 | .call_frame = .{ .alignment = .@"16" }, |
| 62645 | .extra_temps = .{ |
| 62646 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62647 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62648 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62649 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62650 | .unused, |
| 62651 | .unused, |
| 62652 | .unused, |
| 62653 | .unused, |
| 62654 | .unused, |
| 62655 | }, |
| 62656 | .dst_temps = .{.mem}, |
| 62657 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62658 | .each = .{ .once = &.{ |
| 62659 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62660 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62661 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62662 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62663 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62664 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62665 | } }, |
| 62666 | }, .{ |
| 62667 | .required_features = .{ .sse, null, null, null }, |
| 62668 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 62669 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62670 | .patterns = &.{ |
| 62671 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62672 | }, |
| 62673 | .call_frame = .{ .alignment = .@"16" }, |
| 62674 | .extra_temps = .{ |
| 62675 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62676 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62677 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62678 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62679 | .unused, |
| 62680 | .unused, |
| 62681 | .unused, |
| 62682 | .unused, |
| 62683 | .unused, |
| 62684 | }, |
| 62685 | .dst_temps = .{.mem}, |
| 62686 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62687 | .each = .{ .once = &.{ |
| 62688 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62689 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62690 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62691 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62692 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62694 | } }, |
| 62695 | }, .{ |
| 62696 | .required_features = .{ .avx, null, null, null }, |
| 62697 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 62698 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62699 | .patterns = &.{ |
| 62700 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62701 | }, |
| 62702 | .call_frame = .{ .alignment = .@"16" }, |
| 62703 | .extra_temps = .{ |
| 62704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62705 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62706 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62707 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62708 | .unused, |
| 62709 | .unused, |
| 62710 | .unused, |
| 62711 | .unused, |
| 62712 | .unused, |
| 62713 | }, |
| 62714 | .dst_temps = .{.mem}, |
| 62715 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62716 | .each = .{ .once = &.{ |
| 62717 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62718 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62719 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62720 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62721 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62722 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62723 | } }, |
| 62724 | }, .{ |
| 62725 | .required_features = .{ .sse2, null, null, null }, |
| 62726 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 62727 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62728 | .patterns = &.{ |
| 62729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62730 | }, |
| 62731 | .call_frame = .{ .alignment = .@"16" }, |
| 62732 | .extra_temps = .{ |
| 62733 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62734 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62735 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62736 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62737 | .unused, |
| 62738 | .unused, |
| 62739 | .unused, |
| 62740 | .unused, |
| 62741 | .unused, |
| 62742 | }, |
| 62743 | .dst_temps = .{.mem}, |
| 62744 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62745 | .each = .{ .once = &.{ |
| 62746 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62747 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62748 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62749 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62750 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62751 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62752 | } }, |
| 62753 | }, .{ |
| 62754 | .required_features = .{ .sse, null, null, null }, |
| 62755 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 62756 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62757 | .patterns = &.{ |
| 62758 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62759 | }, |
| 62760 | .call_frame = .{ .alignment = .@"16" }, |
| 62761 | .extra_temps = .{ |
| 62762 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62763 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62764 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62765 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62766 | .unused, |
| 62767 | .unused, |
| 62768 | .unused, |
| 62769 | .unused, |
| 62770 | .unused, |
| 62771 | }, |
| 62772 | .dst_temps = .{.mem}, |
| 62773 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62774 | .each = .{ .once = &.{ |
| 62775 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62776 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62777 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62778 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62779 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 62780 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62781 | } }, |
| 62782 | }, .{ |
| 62783 | .required_features = .{ .avx, null, null, null }, |
| 62784 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 62785 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62786 | .patterns = &.{ |
| 62787 | .{ .src = .{ .mem, .none, .none } }, |
| 62788 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62789 | }, |
| 62790 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62791 | .each = .{ .once = &.{ |
| 62792 | .{ ._, .v_pd, .cvtdq2, .dst0x, .src0q, ._, ._ }, |
| 62793 | } }, |
| 62794 | }, .{ |
| 62795 | .required_features = .{ .sse2, null, null, null }, |
| 62796 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 62797 | .dst_constraints = .{.{ .scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62798 | .patterns = &.{ |
| 62799 | .{ .src = .{ .mem, .none, .none } }, |
| 62800 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62801 | }, |
| 62802 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62803 | .each = .{ .once = &.{ |
| 62804 | .{ ._, ._pd, .cvtdq2, .dst0x, .src0q, ._, ._ }, |
| 62805 | } }, |
| 62806 | }, .{ |
| 62807 | .required_features = .{ .avx2, null, null, null }, |
| 62808 | .src_constraints = .{ .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 62809 | .dst_constraints = .{.{ .scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 62810 | .patterns = &.{ |
| 62811 | .{ .src = .{ .mem, .none, .none } }, |
| 62812 | .{ .src = .{ .to_sse, .none, .none } }, |
| 62813 | }, |
| 62814 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 62815 | .each = .{ .once = &.{ |
| 62816 | .{ ._, .v_pd, .cvtdq2, .dst0y, .src0x, ._, ._ }, |
| 62817 | } }, |
| 62818 | }, .{ |
| 62819 | .required_features = .{ .avx2, null, null, null }, |
| 62820 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 62821 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } }}, |
| 62822 | .patterns = &.{ |
| 62823 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62824 | }, |
| 62825 | .extra_temps = .{ |
| 62826 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62827 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| 62828 | .unused, |
| 62829 | .unused, |
| 62830 | .unused, |
| 62831 | .unused, |
| 62832 | .unused, |
| 62833 | .unused, |
| 62834 | .unused, |
| 62835 | }, |
| 62836 | .dst_temps = .{.mem}, |
| 62837 | .clobbers = .{ .eflags = true }, |
| 62838 | .each = .{ .once = &.{ |
| 62839 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62840 | .{ .@"0:", .v_pd, .cvtdq2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62841 | .{ ._, .v_pd, .mova, .memsia(.dst0y, .@"2", .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| 62842 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 62843 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62844 | } }, |
| 62845 | }, .{ |
| 62846 | .required_features = .{ .avx, null, null, null }, |
| 62847 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 62848 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62849 | .patterns = &.{ |
| 62850 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62851 | }, |
| 62852 | .extra_temps = .{ |
| 62853 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62854 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 62855 | .unused, |
| 62856 | .unused, |
| 62857 | .unused, |
| 62858 | .unused, |
| 62859 | .unused, |
| 62860 | .unused, |
| 62861 | .unused, |
| 62862 | }, |
| 62863 | .dst_temps = .{.mem}, |
| 62864 | .clobbers = .{ .eflags = true }, |
| 62865 | .each = .{ .once = &.{ |
| 62866 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62867 | .{ .@"0:", .v_pd, .cvtdq2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62868 | .{ ._, .v_pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62869 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 62870 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62871 | } }, |
| 62872 | }, .{ |
| 62873 | .required_features = .{ .sse2, null, null, null }, |
| 62874 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .dword } }, .any, .any }, |
| 62875 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } }}, |
| 62876 | .patterns = &.{ |
| 62877 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62878 | }, |
| 62879 | .extra_temps = .{ |
| 62880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62881 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 62882 | .unused, |
| 62883 | .unused, |
| 62884 | .unused, |
| 62885 | .unused, |
| 62886 | .unused, |
| 62887 | .unused, |
| 62888 | .unused, |
| 62889 | }, |
| 62890 | .dst_temps = .{.mem}, |
| 62891 | .clobbers = .{ .eflags = true }, |
| 62892 | .each = .{ .once = &.{ |
| 62893 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62894 | .{ .@"0:", ._pd, .cvtdq2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62895 | .{ ._, ._pd, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 62896 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 62897 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62898 | } }, |
| 62899 | }, .{ |
| 62900 | .required_features = .{ .avx, null, null, null }, |
| 62901 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 62902 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62903 | .patterns = &.{ |
| 62904 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62905 | }, |
| 62906 | .call_frame = .{ .alignment = .@"16" }, |
| 62907 | .extra_temps = .{ |
| 62908 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62909 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62910 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62911 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62912 | .unused, |
| 62913 | .unused, |
| 62914 | .unused, |
| 62915 | .unused, |
| 62916 | .unused, |
| 62917 | }, |
| 62918 | .dst_temps = .{.mem}, |
| 62919 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62920 | .each = .{ .once = &.{ |
| 62921 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62922 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62923 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62924 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62925 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62926 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62927 | } }, |
| 62928 | }, .{ |
| 62929 | .required_features = .{ .sse2, null, null, null }, |
| 62930 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 62931 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62932 | .patterns = &.{ |
| 62933 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62934 | }, |
| 62935 | .call_frame = .{ .alignment = .@"16" }, |
| 62936 | .extra_temps = .{ |
| 62937 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62938 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62939 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62940 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62941 | .unused, |
| 62942 | .unused, |
| 62943 | .unused, |
| 62944 | .unused, |
| 62945 | .unused, |
| 62946 | }, |
| 62947 | .dst_temps = .{.mem}, |
| 62948 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62949 | .each = .{ .once = &.{ |
| 62950 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62951 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62952 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62953 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62954 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62955 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62956 | } }, |
| 62957 | }, .{ |
| 62958 | .required_features = .{ .sse, null, null, null }, |
| 62959 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 62960 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62961 | .patterns = &.{ |
| 62962 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62963 | }, |
| 62964 | .call_frame = .{ .alignment = .@"16" }, |
| 62965 | .extra_temps = .{ |
| 62966 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62967 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 62968 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsidf" } } }, |
| 62969 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62970 | .unused, |
| 62971 | .unused, |
| 62972 | .unused, |
| 62973 | .unused, |
| 62974 | .unused, |
| 62975 | }, |
| 62976 | .dst_temps = .{.mem}, |
| 62977 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 62978 | .each = .{ .once = &.{ |
| 62979 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 62980 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 62981 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 62982 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 62983 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 62984 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 62985 | } }, |
| 62986 | }, .{ |
| 62987 | .required_features = .{ .avx, null, null, null }, |
| 62988 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 62989 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 62990 | .patterns = &.{ |
| 62991 | .{ .src = .{ .to_mem, .none, .none } }, |
| 62992 | }, |
| 62993 | .call_frame = .{ .alignment = .@"16" }, |
| 62994 | .extra_temps = .{ |
| 62995 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 62996 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 62997 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 62998 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 62999 | .unused, |
| 63000 | .unused, |
| 63001 | .unused, |
| 63002 | .unused, |
| 63003 | .unused, |
| 63004 | }, |
| 63005 | .dst_temps = .{.mem}, |
| 63006 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63007 | .each = .{ .once = &.{ |
| 63008 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63009 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63010 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63011 | .{ ._, .v_sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63012 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 63013 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63014 | } }, |
| 63015 | }, .{ |
| 63016 | .required_features = .{ .sse2, null, null, null }, |
| 63017 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63018 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63019 | .patterns = &.{ |
| 63020 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63021 | }, |
| 63022 | .call_frame = .{ .alignment = .@"16" }, |
| 63023 | .extra_temps = .{ |
| 63024 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63025 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 63026 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 63027 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63028 | .unused, |
| 63029 | .unused, |
| 63030 | .unused, |
| 63031 | .unused, |
| 63032 | .unused, |
| 63033 | }, |
| 63034 | .dst_temps = .{.mem}, |
| 63035 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63036 | .each = .{ .once = &.{ |
| 63037 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63038 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63039 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63040 | .{ ._, ._sd, .mov, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63041 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 63042 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63043 | } }, |
| 63044 | }, .{ |
| 63045 | .required_features = .{ .sse, null, null, null }, |
| 63046 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63047 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63048 | .patterns = &.{ |
| 63049 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63050 | }, |
| 63051 | .call_frame = .{ .alignment = .@"16" }, |
| 63052 | .extra_temps = .{ |
| 63053 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63054 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 63055 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsidf" } } }, |
| 63056 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63057 | .unused, |
| 63058 | .unused, |
| 63059 | .unused, |
| 63060 | .unused, |
| 63061 | .unused, |
| 63062 | }, |
| 63063 | .dst_temps = .{.mem}, |
| 63064 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63065 | .each = .{ .once = &.{ |
| 63066 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63067 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63068 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63069 | .{ ._, ._ps, .movl, .memsia(.dst0q, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63070 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 63071 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63072 | } }, |
| 63073 | }, .{ |
| 63074 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63075 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63076 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63077 | .patterns = &.{ |
| 63078 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63079 | }, |
| 63080 | .extra_temps = .{ |
| 63081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63082 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 63083 | .unused, |
| 63084 | .unused, |
| 63085 | .unused, |
| 63086 | .unused, |
| 63087 | .unused, |
| 63088 | .unused, |
| 63089 | .unused, |
| 63090 | }, |
| 63091 | .dst_temps = .{.mem}, |
| 63092 | .clobbers = .{ .eflags = true }, |
| 63093 | .each = .{ .once = &.{ |
| 63094 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63095 | .{ .@"0:", .v_pd, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 63096 | .{ ._, .v_sd, .cvtsi2, .tmp1x, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._ }, |
| 63097 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 63098 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63099 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63100 | } }, |
| 63101 | }, .{ |
| 63102 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63103 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63104 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63105 | .patterns = &.{ |
| 63106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63107 | }, |
| 63108 | .extra_temps = .{ |
| 63109 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63110 | .{ .type = .f64, .kind = .{ .rc = .sse } }, |
| 63111 | .unused, |
| 63112 | .unused, |
| 63113 | .unused, |
| 63114 | .unused, |
| 63115 | .unused, |
| 63116 | .unused, |
| 63117 | .unused, |
| 63118 | }, |
| 63119 | .dst_temps = .{.mem}, |
| 63120 | .clobbers = .{ .eflags = true }, |
| 63121 | .each = .{ .once = &.{ |
| 63122 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63123 | .{ .@"0:", ._pd, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 63124 | .{ ._, ._sd, .cvtsi2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63125 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| 63126 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63127 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63128 | } }, |
| 63129 | }, .{ |
| 63130 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63131 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63132 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63133 | .patterns = &.{ |
| 63134 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63135 | }, |
| 63136 | .call_frame = .{ .alignment = .@"16" }, |
| 63137 | .extra_temps = .{ |
| 63138 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63139 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 63140 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdidf" } } }, |
| 63141 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63142 | .unused, |
| 63143 | .unused, |
| 63144 | .unused, |
| 63145 | .unused, |
| 63146 | .unused, |
| 63147 | }, |
| 63148 | .dst_temps = .{.mem}, |
| 63149 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63150 | .each = .{ .once = &.{ |
| 63151 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63152 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63153 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63154 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63155 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63156 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63157 | } }, |
| 63158 | }, .{ |
| 63159 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63160 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63161 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63162 | .patterns = &.{ |
| 63163 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63164 | }, |
| 63165 | .call_frame = .{ .alignment = .@"16" }, |
| 63166 | .extra_temps = .{ |
| 63167 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63168 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 63169 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdidf" } } }, |
| 63170 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63171 | .unused, |
| 63172 | .unused, |
| 63173 | .unused, |
| 63174 | .unused, |
| 63175 | .unused, |
| 63176 | }, |
| 63177 | .dst_temps = .{.mem}, |
| 63178 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63179 | .each = .{ .once = &.{ |
| 63180 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63181 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63182 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63183 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63184 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63185 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63186 | } }, |
| 63187 | }, .{ |
| 63188 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 63189 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63190 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63191 | .patterns = &.{ |
| 63192 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63193 | }, |
| 63194 | .call_frame = .{ .alignment = .@"16" }, |
| 63195 | .extra_temps = .{ |
| 63196 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63197 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 63198 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdidf" } } }, |
| 63199 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63200 | .unused, |
| 63201 | .unused, |
| 63202 | .unused, |
| 63203 | .unused, |
| 63204 | .unused, |
| 63205 | }, |
| 63206 | .dst_temps = .{.mem}, |
| 63207 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63208 | .each = .{ .once = &.{ |
| 63209 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63210 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63211 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63212 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63213 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63214 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63215 | } }, |
| 63216 | }, .{ |
| 63217 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63218 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63219 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63220 | .patterns = &.{ |
| 63221 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63222 | }, |
| 63223 | .call_frame = .{ .alignment = .@"16" }, |
| 63224 | .extra_temps = .{ |
| 63225 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63226 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63227 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundidf" } } }, |
| 63228 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63229 | .unused, |
| 63230 | .unused, |
| 63231 | .unused, |
| 63232 | .unused, |
| 63233 | .unused, |
| 63234 | }, |
| 63235 | .dst_temps = .{.mem}, |
| 63236 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63237 | .each = .{ .once = &.{ |
| 63238 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63239 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63240 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63241 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63242 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63243 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63244 | } }, |
| 63245 | }, .{ |
| 63246 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63247 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63248 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63249 | .patterns = &.{ |
| 63250 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63251 | }, |
| 63252 | .call_frame = .{ .alignment = .@"16" }, |
| 63253 | .extra_temps = .{ |
| 63254 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63255 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63256 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundidf" } } }, |
| 63257 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63258 | .unused, |
| 63259 | .unused, |
| 63260 | .unused, |
| 63261 | .unused, |
| 63262 | .unused, |
| 63263 | }, |
| 63264 | .dst_temps = .{.mem}, |
| 63265 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63266 | .each = .{ .once = &.{ |
| 63267 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63268 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63269 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63270 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63271 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63272 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63273 | } }, |
| 63274 | }, .{ |
| 63275 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 63276 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 63277 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63278 | .patterns = &.{ |
| 63279 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63280 | }, |
| 63281 | .call_frame = .{ .alignment = .@"16" }, |
| 63282 | .extra_temps = .{ |
| 63283 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63284 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63285 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundidf" } } }, |
| 63286 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63287 | .unused, |
| 63288 | .unused, |
| 63289 | .unused, |
| 63290 | .unused, |
| 63291 | .unused, |
| 63292 | }, |
| 63293 | .dst_temps = .{.mem}, |
| 63294 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63295 | .each = .{ .once = &.{ |
| 63296 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63297 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 63298 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 63299 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 63300 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63301 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63302 | } }, |
| 63303 | }, .{ |
| 63304 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63305 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 63306 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63307 | .patterns = &.{ |
| 63308 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63309 | }, |
| 63310 | .call_frame = .{ .alignment = .@"16" }, |
| 63311 | .extra_temps = .{ |
| 63312 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63313 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63314 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 63315 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } }, |
| 63316 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63317 | .unused, |
| 63318 | .unused, |
| 63319 | .unused, |
| 63320 | .unused, |
| 63321 | }, |
| 63322 | .dst_temps = .{.mem}, |
| 63323 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63324 | .each = .{ .once = &.{ |
| 63325 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63326 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 63327 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 63328 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 63329 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 63330 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63331 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63332 | } }, |
| 63333 | }, .{ |
| 63334 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63335 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 63336 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63337 | .patterns = &.{ |
| 63338 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63339 | }, |
| 63340 | .call_frame = .{ .alignment = .@"16" }, |
| 63341 | .extra_temps = .{ |
| 63342 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63343 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63344 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 63345 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } }, |
| 63346 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63347 | .unused, |
| 63348 | .unused, |
| 63349 | .unused, |
| 63350 | .unused, |
| 63351 | }, |
| 63352 | .dst_temps = .{.mem}, |
| 63353 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63354 | .each = .{ .once = &.{ |
| 63355 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63356 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 63357 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 63358 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 63359 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 63360 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63361 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63362 | } }, |
| 63363 | }, .{ |
| 63364 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 63365 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 63366 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63367 | .patterns = &.{ |
| 63368 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63369 | }, |
| 63370 | .call_frame = .{ .alignment = .@"16" }, |
| 63371 | .extra_temps = .{ |
| 63372 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63373 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63374 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 63375 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } }, |
| 63376 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63377 | .unused, |
| 63378 | .unused, |
| 63379 | .unused, |
| 63380 | .unused, |
| 63381 | }, |
| 63382 | .dst_temps = .{.mem}, |
| 63383 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63384 | .each = .{ .once = &.{ |
| 63385 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63386 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 63387 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 63388 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 63389 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 63390 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63391 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63392 | } }, |
| 63393 | }, .{ |
| 63394 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63395 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 63396 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63397 | .patterns = &.{ |
| 63398 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63399 | }, |
| 63400 | .call_frame = .{ .alignment = .@"16" }, |
| 63401 | .extra_temps = .{ |
| 63402 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63403 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63404 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 63405 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } }, |
| 63406 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63407 | .unused, |
| 63408 | .unused, |
| 63409 | .unused, |
| 63410 | .unused, |
| 63411 | }, |
| 63412 | .dst_temps = .{.mem}, |
| 63413 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63414 | .each = .{ .once = &.{ |
| 63415 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63416 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 63417 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 63418 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 63419 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 63420 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63421 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63422 | } }, |
| 63423 | }, .{ |
| 63424 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63425 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 63426 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63427 | .patterns = &.{ |
| 63428 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63429 | }, |
| 63430 | .call_frame = .{ .alignment = .@"16" }, |
| 63431 | .extra_temps = .{ |
| 63432 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63433 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63434 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 63435 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } }, |
| 63436 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63437 | .unused, |
| 63438 | .unused, |
| 63439 | .unused, |
| 63440 | .unused, |
| 63441 | }, |
| 63442 | .dst_temps = .{.mem}, |
| 63443 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63444 | .each = .{ .once = &.{ |
| 63445 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63446 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 63447 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 63448 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 63449 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 63450 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63451 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63452 | } }, |
| 63453 | }, .{ |
| 63454 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 63455 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 63456 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63457 | .patterns = &.{ |
| 63458 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63459 | }, |
| 63460 | .call_frame = .{ .alignment = .@"16" }, |
| 63461 | .extra_temps = .{ |
| 63462 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63463 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 63464 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 63465 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } }, |
| 63466 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63467 | .unused, |
| 63468 | .unused, |
| 63469 | .unused, |
| 63470 | .unused, |
| 63471 | }, |
| 63472 | .dst_temps = .{.mem}, |
| 63473 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63474 | .each = .{ .once = &.{ |
| 63475 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63476 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 63477 | .{ ._, ._, .mov, .tmp2q, .memsiad(.src0q, .@"2", .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 63478 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 63479 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 63480 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 63481 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63482 | } }, |
| 63483 | }, .{ |
| 63484 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63485 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63486 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63487 | .patterns = &.{ |
| 63488 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63489 | }, |
| 63490 | .call_frame = .{ .alignment = .@"16" }, |
| 63491 | .extra_temps = .{ |
| 63492 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63493 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63494 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 63495 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 63496 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } }, |
| 63497 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63498 | .unused, |
| 63499 | .unused, |
| 63500 | .unused, |
| 63501 | }, |
| 63502 | .dst_temps = .{.mem}, |
| 63503 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63504 | .each = .{ .once = &.{ |
| 63505 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 63506 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63507 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 63508 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 63509 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 63510 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 63511 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 63512 | .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, |
| 63513 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63514 | } }, |
| 63515 | }, .{ |
| 63516 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63517 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63518 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63519 | .patterns = &.{ |
| 63520 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63521 | }, |
| 63522 | .call_frame = .{ .alignment = .@"16" }, |
| 63523 | .extra_temps = .{ |
| 63524 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63525 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63526 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 63527 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 63528 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } }, |
| 63529 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63530 | .unused, |
| 63531 | .unused, |
| 63532 | .unused, |
| 63533 | }, |
| 63534 | .dst_temps = .{.mem}, |
| 63535 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63536 | .each = .{ .once = &.{ |
| 63537 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 63538 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63539 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 63540 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 63541 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 63542 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 63543 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 63544 | .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, |
| 63545 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63546 | } }, |
| 63547 | }, .{ |
| 63548 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 63549 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63550 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63551 | .patterns = &.{ |
| 63552 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63553 | }, |
| 63554 | .call_frame = .{ .alignment = .@"16" }, |
| 63555 | .extra_temps = .{ |
| 63556 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63557 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63558 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 63559 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 63560 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } }, |
| 63561 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63562 | .unused, |
| 63563 | .unused, |
| 63564 | .unused, |
| 63565 | }, |
| 63566 | .dst_temps = .{.mem}, |
| 63567 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63568 | .each = .{ .once = &.{ |
| 63569 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 63570 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63571 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 63572 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 63573 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 63574 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 63575 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 63576 | .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, |
| 63577 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63578 | } }, |
| 63579 | }, .{ |
| 63580 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 63581 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63582 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63583 | .patterns = &.{ |
| 63584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63585 | }, |
| 63586 | .call_frame = .{ .alignment = .@"16" }, |
| 63587 | .extra_temps = .{ |
| 63588 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63589 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63590 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 63591 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 63592 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } }, |
| 63593 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63594 | .unused, |
| 63595 | .unused, |
| 63596 | .unused, |
| 63597 | }, |
| 63598 | .dst_temps = .{.mem}, |
| 63599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63600 | .each = .{ .once = &.{ |
| 63601 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 63602 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63603 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 63604 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 63605 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 63606 | .{ ._, .v_sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 63607 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 63608 | .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, |
| 63609 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63610 | } }, |
| 63611 | }, .{ |
| 63612 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 63613 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63614 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63615 | .patterns = &.{ |
| 63616 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63617 | }, |
| 63618 | .call_frame = .{ .alignment = .@"16" }, |
| 63619 | .extra_temps = .{ |
| 63620 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63621 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63622 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 63623 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 63624 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } }, |
| 63625 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63626 | .unused, |
| 63627 | .unused, |
| 63628 | .unused, |
| 63629 | }, |
| 63630 | .dst_temps = .{.mem}, |
| 63631 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63632 | .each = .{ .once = &.{ |
| 63633 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 63634 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63635 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 63636 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 63637 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 63638 | .{ ._, ._sd, .mov, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 63639 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 63640 | .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, |
| 63641 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63642 | } }, |
| 63643 | }, .{ |
| 63644 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 63645 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 63646 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } }}, |
| 63647 | .patterns = &.{ |
| 63648 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63649 | }, |
| 63650 | .call_frame = .{ .alignment = .@"16" }, |
| 63651 | .extra_temps = .{ |
| 63652 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63653 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63654 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 63655 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 63656 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } }, |
| 63657 | .{ .type = .f64, .kind = .{ .reg = .xmm0 } }, |
| 63658 | .unused, |
| 63659 | .unused, |
| 63660 | .unused, |
| 63661 | }, |
| 63662 | .dst_temps = .{.mem}, |
| 63663 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63664 | .each = .{ .once = &.{ |
| 63665 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 63666 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 63667 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 63668 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 63669 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 63670 | .{ ._, ._ps, .movl, .memia(.dst0q, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 63671 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 63672 | .{ ._, ._, .add, .tmp1p, .si(8), ._, ._ }, |
| 63673 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 63674 | } }, |
| 63675 | }, .{ |
| 63676 | .required_features = .{ .x87, null, null, null }, |
| 63677 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 63678 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63679 | .patterns = &.{ |
| 63680 | .{ .src = .{ .mem, .none, .none } }, |
| 63681 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 63682 | }, |
| 63683 | .extra_temps = .{ |
| 63684 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 63685 | .{ .type = .i16, .kind = .mem }, |
| 63686 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 63687 | .unused, |
| 63688 | .unused, |
| 63689 | .unused, |
| 63690 | .unused, |
| 63691 | .unused, |
| 63692 | .unused, |
| 63693 | }, |
| 63694 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63695 | .each = .{ .once = &.{ |
| 63696 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 63697 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 63698 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 63699 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 63700 | } }, |
| 63701 | }, .{ |
| 63702 | .required_features = .{ .x87, null, null, null }, |
| 63703 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 63704 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63705 | .patterns = &.{ |
| 63706 | .{ .src = .{ .mem, .none, .none } }, |
| 63707 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 63708 | }, |
| 63709 | .extra_temps = .{ |
| 63710 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 63711 | .{ .type = .i16, .kind = .mem }, |
| 63712 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 63713 | .unused, |
| 63714 | .unused, |
| 63715 | .unused, |
| 63716 | .unused, |
| 63717 | .unused, |
| 63718 | .unused, |
| 63719 | }, |
| 63720 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63721 | .each = .{ .once = &.{ |
| 63722 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 63723 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 63724 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 63725 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 63726 | } }, |
| 63727 | }, .{ |
| 63728 | .required_features = .{ .x87, null, null, null }, |
| 63729 | .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any }, |
| 63730 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63731 | .patterns = &.{ |
| 63732 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63733 | }, |
| 63734 | .extra_temps = .{ |
| 63735 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 63736 | .unused, |
| 63737 | .unused, |
| 63738 | .unused, |
| 63739 | .unused, |
| 63740 | .unused, |
| 63741 | .unused, |
| 63742 | .unused, |
| 63743 | .unused, |
| 63744 | }, |
| 63745 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63746 | .each = .{ .once = &.{ |
| 63747 | .{ ._, .fi_, .ld, .src0w, ._, ._, ._ }, |
| 63748 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 63749 | } }, |
| 63750 | }, .{ |
| 63751 | .required_features = .{ .x87, null, null, null }, |
| 63752 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any }, |
| 63753 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63754 | .patterns = &.{ |
| 63755 | .{ .src = .{ .mem, .none, .none } }, |
| 63756 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 63757 | }, |
| 63758 | .extra_temps = .{ |
| 63759 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 63760 | .{ .type = .i32, .kind = .mem }, |
| 63761 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 63762 | .unused, |
| 63763 | .unused, |
| 63764 | .unused, |
| 63765 | .unused, |
| 63766 | .unused, |
| 63767 | .unused, |
| 63768 | }, |
| 63769 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63770 | .each = .{ .once = &.{ |
| 63771 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 63772 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 63773 | .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ }, |
| 63774 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 63775 | } }, |
| 63776 | }, .{ |
| 63777 | .required_features = .{ .x87, null, null, null }, |
| 63778 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 63779 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63780 | .patterns = &.{ |
| 63781 | .{ .src = .{ .to_mem, .none, .none } }, |
| 63782 | }, |
| 63783 | .extra_temps = .{ |
| 63784 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 63785 | .unused, |
| 63786 | .unused, |
| 63787 | .unused, |
| 63788 | .unused, |
| 63789 | .unused, |
| 63790 | .unused, |
| 63791 | .unused, |
| 63792 | .unused, |
| 63793 | }, |
| 63794 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63795 | .each = .{ .once = &.{ |
| 63796 | .{ ._, .fi_, .ld, .src0d, ._, ._, ._ }, |
| 63797 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 63798 | } }, |
| 63799 | }, .{ |
| 63800 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 63801 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 63802 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63803 | .patterns = &.{ |
| 63804 | .{ .src = .{ .mem, .none, .none } }, |
| 63805 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 63806 | }, |
| 63807 | .extra_temps = .{ |
| 63808 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 63809 | .{ .type = .i64, .kind = .mem }, |
| 63810 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 63811 | .unused, |
| 63812 | .unused, |
| 63813 | .unused, |
| 63814 | .unused, |
| 63815 | .unused, |
| 63816 | .unused, |
| 63817 | }, |
| 63818 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63819 | .each = .{ .once = &.{ |
| 63820 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 63821 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| 63822 | .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ }, |
| 63823 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 63824 | } }, |
| 63825 | }, .{ |
| 63826 | .required_features = .{ .x87, null, null, null }, |
| 63827 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 63828 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 63829 | .patterns = &.{ |
| 63830 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50692 | 63831 | }, |
| 50693 | | .call_frame = .{ .alignment = .@"16" }, |
| 50694 | 63832 | .extra_temps = .{ |
| 50695 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, |
| 63833 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50696 | 63834 | .unused, |
| 50697 | 63835 | .unused, |
| 50698 | 63836 | .unused, |
| ... | ... | @@ -50702,45 +63840,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50702 | 63840 | .unused, |
| 50703 | 63841 | .unused, |
| 50704 | 63842 | }, |
| 50705 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 50706 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63843 | .dst_temps = .{.{ .rc = .x87 }}, |
| 50707 | 63844 | .each = .{ .once = &.{ |
| 50708 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 63845 | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, |
| 63846 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 50709 | 63847 | } }, |
| 50710 | 63848 | }, .{ |
| 50711 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50712 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 50713 | | .dst_constraints = .{.{ .float = .word }}, |
| 63849 | .required_features = .{ .x87, null, null, null }, |
| 63850 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 63851 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50714 | 63852 | .patterns = &.{ |
| 50715 | | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 63853 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50716 | 63854 | }, |
| 50717 | | .call_frame = .{ .alignment = .@"16" }, |
| 50718 | 63855 | .extra_temps = .{ |
| 50719 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, |
| 50720 | | .unused, |
| 50721 | | .unused, |
| 50722 | | .unused, |
| 63856 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63857 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 63858 | .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem }, |
| 63859 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50723 | 63860 | .unused, |
| 50724 | 63861 | .unused, |
| 50725 | 63862 | .unused, |
| 50726 | 63863 | .unused, |
| 50727 | 63864 | .unused, |
| 50728 | 63865 | }, |
| 50729 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 50730 | | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 63866 | .dst_temps = .{.{ .rc = .x87 }}, |
| 63867 | .clobbers = .{ .eflags = true }, |
| 50731 | 63868 | .each = .{ .once = &.{ |
| 50732 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 63869 | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, |
| 63870 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 63871 | .{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ }, |
| 63872 | .{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ }, |
| 63873 | .{ ._, .f_, .add, .leasi(.tmp0d, .@"4", .tmp1), ._, ._, ._ }, |
| 63874 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 50733 | 63875 | } }, |
| 50734 | 63876 | }, .{ |
| 50735 | 63877 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50736 | 63878 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 50737 | | .dst_constraints = .{.{ .float = .word }}, |
| 63879 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50738 | 63880 | .patterns = &.{ |
| 50739 | 63881 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 50740 | 63882 | }, |
| 50741 | 63883 | .call_frame = .{ .alignment = .@"16" }, |
| 50742 | 63884 | .extra_temps = .{ |
| 50743 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, |
| 63885 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattixf" } } }, |
| 50744 | 63886 | .unused, |
| 50745 | 63887 | .unused, |
| 50746 | 63888 | .unused, |
| ... | ... | @@ -50750,7 +63892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50750 | 63892 | .unused, |
| 50751 | 63893 | .unused, |
| 50752 | 63894 | }, |
| 50753 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 63895 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50754 | 63896 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50755 | 63897 | .each = .{ .once = &.{ |
| 50756 | 63898 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| ... | ... | @@ -50758,13 +63900,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50758 | 63900 | }, .{ |
| 50759 | 63901 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50760 | 63902 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 50761 | | .dst_constraints = .{.{ .float = .word }}, |
| 63903 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50762 | 63904 | .patterns = &.{ |
| 50763 | 63905 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 50764 | 63906 | }, |
| 50765 | 63907 | .call_frame = .{ .alignment = .@"16" }, |
| 50766 | 63908 | .extra_temps = .{ |
| 50767 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, |
| 63909 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntixf" } } }, |
| 50768 | 63910 | .unused, |
| 50769 | 63911 | .unused, |
| 50770 | 63912 | .unused, |
| ... | ... | @@ -50774,7 +63916,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50774 | 63916 | .unused, |
| 50775 | 63917 | .unused, |
| 50776 | 63918 | }, |
| 50777 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 63919 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50778 | 63920 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50779 | 63921 | .each = .{ .once = &.{ |
| 50780 | 63922 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| ... | ... | @@ -50782,7 +63924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50782 | 63924 | }, .{ |
| 50783 | 63925 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50784 | 63926 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50785 | | .dst_constraints = .{.{ .float = .word }}, |
| 63927 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50786 | 63928 | .patterns = &.{ |
| 50787 | 63929 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50788 | 63930 | }, |
| ... | ... | @@ -50790,7 +63932,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50790 | 63932 | .extra_temps = .{ |
| 50791 | 63933 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50792 | 63934 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50793 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, |
| 63935 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } }, |
| 50794 | 63936 | .unused, |
| 50795 | 63937 | .unused, |
| 50796 | 63938 | .unused, |
| ... | ... | @@ -50798,7 +63940,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50798 | 63940 | .unused, |
| 50799 | 63941 | .unused, |
| 50800 | 63942 | }, |
| 50801 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 63943 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50802 | 63944 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50803 | 63945 | .each = .{ .once = &.{ |
| 50804 | 63946 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| ... | ... | @@ -50808,7 +63950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50808 | 63950 | }, .{ |
| 50809 | 63951 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50810 | 63952 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50811 | | .dst_constraints = .{.{ .float = .word }}, |
| 63953 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50812 | 63954 | .patterns = &.{ |
| 50813 | 63955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50814 | 63956 | }, |
| ... | ... | @@ -50816,7 +63958,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50816 | 63958 | .extra_temps = .{ |
| 50817 | 63959 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50818 | 63960 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50819 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, |
| 63961 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } }, |
| 50820 | 63962 | .unused, |
| 50821 | 63963 | .unused, |
| 50822 | 63964 | .unused, |
| ... | ... | @@ -50824,7 +63966,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50824 | 63966 | .unused, |
| 50825 | 63967 | .unused, |
| 50826 | 63968 | }, |
| 50827 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 63969 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50828 | 63970 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50829 | 63971 | .each = .{ .once = &.{ |
| 50830 | 63972 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| ... | ... | @@ -50832,166 +63974,267 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50832 | 63974 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50833 | 63975 | } }, |
| 50834 | 63976 | }, .{ |
| 50835 | | .required_features = .{ .avx, null, null, null }, |
| 50836 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 50837 | | .dst_constraints = .{.{ .float = .dword }}, |
| 63977 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 63978 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 63979 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50838 | 63980 | .patterns = &.{ |
| 50839 | | .{ .src = .{ .mem, .none, .none } }, |
| 50840 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 63981 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50841 | 63982 | }, |
| 50842 | 63983 | .extra_temps = .{ |
| 50843 | | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50844 | | .unused, |
| 50845 | | .unused, |
| 50846 | | .unused, |
| 50847 | | .unused, |
| 63984 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 63985 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 63986 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 63987 | .{ .type = .i16, .kind = .mem }, |
| 63988 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50848 | 63989 | .unused, |
| 50849 | 63990 | .unused, |
| 50850 | 63991 | .unused, |
| 50851 | 63992 | .unused, |
| 50852 | 63993 | }, |
| 50853 | | .dst_temps = .{.{ .rc = .sse }}, |
| 63994 | .dst_temps = .{.mem}, |
| 63995 | .clobbers = .{ .eflags = true }, |
| 50854 | 63996 | .each = .{ .once = &.{ |
| 50855 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 50856 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50857 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 63997 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 63998 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 63999 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64000 | .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, |
| 64001 | .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, |
| 64002 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64003 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64004 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 64005 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50858 | 64006 | } }, |
| 50859 | 64007 | }, .{ |
| 50860 | | .required_features = .{ .sse, null, null, null }, |
| 50861 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 50862 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64008 | .required_features = .{ .x87, null, null, null }, |
| 64009 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64010 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50863 | 64011 | .patterns = &.{ |
| 50864 | | .{ .src = .{ .mem, .none, .none } }, |
| 50865 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64012 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50866 | 64013 | }, |
| 50867 | 64014 | .extra_temps = .{ |
| 50868 | | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50869 | | .unused, |
| 50870 | | .unused, |
| 50871 | | .unused, |
| 50872 | | .unused, |
| 64015 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64016 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64017 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 64018 | .{ .type = .i16, .kind = .mem }, |
| 64019 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50873 | 64020 | .unused, |
| 50874 | 64021 | .unused, |
| 50875 | 64022 | .unused, |
| 50876 | 64023 | .unused, |
| 50877 | 64024 | }, |
| 50878 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64025 | .dst_temps = .{.mem}, |
| 64026 | .clobbers = .{ .eflags = true }, |
| 50879 | 64027 | .each = .{ .once = &.{ |
| 50880 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 50881 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 50882 | | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64028 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64029 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64030 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64031 | .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, |
| 64032 | .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, |
| 64033 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64034 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64035 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 64036 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50883 | 64037 | } }, |
| 50884 | 64038 | }, .{ |
| 50885 | | .required_features = .{ .avx, null, null, null }, |
| 50886 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 50887 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64039 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 64040 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64041 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50888 | 64042 | .patterns = &.{ |
| 50889 | | .{ .src = .{ .mem, .none, .none } }, |
| 50890 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64043 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50891 | 64044 | }, |
| 50892 | 64045 | .extra_temps = .{ |
| 50893 | | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50894 | | .unused, |
| 50895 | | .unused, |
| 50896 | | .unused, |
| 50897 | | .unused, |
| 64046 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64047 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64048 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 64049 | .{ .type = .i16, .kind = .mem }, |
| 64050 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50898 | 64051 | .unused, |
| 50899 | 64052 | .unused, |
| 50900 | 64053 | .unused, |
| 50901 | 64054 | .unused, |
| 50902 | 64055 | }, |
| 50903 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64056 | .dst_temps = .{.mem}, |
| 64057 | .clobbers = .{ .eflags = true }, |
| 50904 | 64058 | .each = .{ .once = &.{ |
| 50905 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 50906 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50907 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64059 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64060 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64061 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64062 | .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, |
| 64063 | .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, |
| 64064 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64065 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64066 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 64067 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 50908 | 64068 | } }, |
| 50909 | 64069 | }, .{ |
| 50910 | | .required_features = .{ .sse, null, null, null }, |
| 50911 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 50912 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64070 | .required_features = .{ .x87, null, null, null }, |
| 64071 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64072 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50913 | 64073 | .patterns = &.{ |
| 50914 | | .{ .src = .{ .mem, .none, .none } }, |
| 50915 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64074 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50916 | 64075 | }, |
| 50917 | 64076 | .extra_temps = .{ |
| 50918 | | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50919 | | .unused, |
| 50920 | | .unused, |
| 50921 | | .unused, |
| 50922 | | .unused, |
| 64077 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64078 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64079 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 64080 | .{ .type = .i16, .kind = .mem }, |
| 64081 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50923 | 64082 | .unused, |
| 50924 | 64083 | .unused, |
| 50925 | 64084 | .unused, |
| 50926 | 64085 | .unused, |
| 50927 | 64086 | }, |
| 50928 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64087 | .dst_temps = .{.mem}, |
| 64088 | .clobbers = .{ .eflags = true }, |
| 50929 | 64089 | .each = .{ .once = &.{ |
| 50930 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 50931 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 50932 | | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64090 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64091 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64092 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64093 | .{ ._, ._, .mov, .tmp3w, .tmp2w, ._, ._ }, |
| 64094 | .{ ._, .fi_, .ld, .tmp3w, ._, ._, ._ }, |
| 64095 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64096 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64097 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 64098 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50933 | 64099 | } }, |
| 50934 | 64100 | }, .{ |
| 50935 | | .required_features = .{ .avx, null, null, null }, |
| 50936 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 50937 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64101 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 64102 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64103 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50938 | 64104 | .patterns = &.{ |
| 50939 | | .{ .src = .{ .mem, .none, .none } }, |
| 50940 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64105 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50941 | 64106 | }, |
| 64107 | .call_frame = .{ .alignment = .@"16" }, |
| 50942 | 64108 | .extra_temps = .{ |
| 50943 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64109 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64110 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64111 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64112 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsixf" } } }, |
| 64113 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50944 | 64114 | .unused, |
| 50945 | 64115 | .unused, |
| 50946 | 64116 | .unused, |
| 50947 | 64117 | .unused, |
| 64118 | }, |
| 64119 | .dst_temps = .{.mem}, |
| 64120 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 64121 | .each = .{ .once = &.{ |
| 64122 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64123 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64124 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64125 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64126 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64127 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64128 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64129 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 64130 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 64131 | } }, |
| 64132 | }, .{ |
| 64133 | .required_features = .{ .x87, null, null, null }, |
| 64134 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64135 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 64136 | .patterns = &.{ |
| 64137 | .{ .src = .{ .to_mem, .none, .none } }, |
| 64138 | }, |
| 64139 | .call_frame = .{ .alignment = .@"16" }, |
| 64140 | .extra_temps = .{ |
| 64141 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64142 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64143 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64144 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsixf" } } }, |
| 64145 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50948 | 64146 | .unused, |
| 50949 | 64147 | .unused, |
| 50950 | 64148 | .unused, |
| 50951 | 64149 | .unused, |
| 50952 | 64150 | }, |
| 50953 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64151 | .dst_temps = .{.mem}, |
| 64152 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50954 | 64153 | .each = .{ .once = &.{ |
| 50955 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 50956 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 50957 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64154 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64155 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64156 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64157 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64158 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64159 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64160 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64161 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 64162 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50958 | 64163 | } }, |
| 50959 | 64164 | }, .{ |
| 50960 | | .required_features = .{ .sse, null, null, null }, |
| 50961 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 50962 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64165 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 64166 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64167 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50963 | 64168 | .patterns = &.{ |
| 50964 | | .{ .src = .{ .mem, .none, .none } }, |
| 50965 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64169 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50966 | 64170 | }, |
| 64171 | .call_frame = .{ .alignment = .@"16" }, |
| 50967 | 64172 | .extra_temps = .{ |
| 50968 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64173 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64174 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64175 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 64176 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsixf" } } }, |
| 64177 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50969 | 64178 | .unused, |
| 50970 | 64179 | .unused, |
| 50971 | 64180 | .unused, |
| 50972 | 64181 | .unused, |
| 64182 | }, |
| 64183 | .dst_temps = .{.mem}, |
| 64184 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 64185 | .each = .{ .once = &.{ |
| 64186 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64187 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64188 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64189 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64190 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64191 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64192 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64193 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 64194 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 64195 | } }, |
| 64196 | }, .{ |
| 64197 | .required_features = .{ .x87, null, null, null }, |
| 64198 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64199 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 64200 | .patterns = &.{ |
| 64201 | .{ .src = .{ .to_mem, .none, .none } }, |
| 64202 | }, |
| 64203 | .call_frame = .{ .alignment = .@"16" }, |
| 64204 | .extra_temps = .{ |
| 64205 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64206 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64207 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 64208 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsixf" } } }, |
| 64209 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50973 | 64210 | .unused, |
| 50974 | 64211 | .unused, |
| 50975 | 64212 | .unused, |
| 50976 | 64213 | .unused, |
| 50977 | 64214 | }, |
| 50978 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64215 | .dst_temps = .{.mem}, |
| 64216 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50979 | 64217 | .each = .{ .once = &.{ |
| 50980 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 50981 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 50982 | | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64218 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64219 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64220 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64221 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64222 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64223 | .{ ._, .f_p, .st, .lea(.tmp1t), ._, ._, ._ }, |
| 64224 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64225 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 64226 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50983 | 64227 | } }, |
| 50984 | 64228 | }, .{ |
| 50985 | | .required_features = .{ .avx, null, null, null }, |
| 50986 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 50987 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64229 | .required_features = .{ .x87, null, null, null }, |
| 64230 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 64231 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50988 | 64232 | .patterns = &.{ |
| 50989 | | .{ .src = .{ .mem, .none, .none } }, |
| 50990 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64233 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50991 | 64234 | }, |
| 50992 | 64235 | .extra_temps = .{ |
| 50993 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 50994 | | .unused, |
| 64236 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64237 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50995 | 64238 | .unused, |
| 50996 | 64239 | .unused, |
| 50997 | 64240 | .unused, |
| ... | ... | @@ -51000,74 +64243,85 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51000 | 64243 | .unused, |
| 51001 | 64244 | .unused, |
| 51002 | 64245 | }, |
| 51003 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64246 | .dst_temps = .{.mem}, |
| 64247 | .clobbers = .{ .eflags = true }, |
| 51004 | 64248 | .each = .{ .once = &.{ |
| 51005 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 51006 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51007 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64250 | .{ .@"0:", .fi_, .ld, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64251 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64252 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 64253 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51008 | 64254 | } }, |
| 51009 | 64255 | }, .{ |
| 51010 | | .required_features = .{ .sse, null, null, null }, |
| 51011 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 51012 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64256 | .required_features = .{ .x87, null, null, null }, |
| 64257 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 64258 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51013 | 64259 | .patterns = &.{ |
| 51014 | | .{ .src = .{ .mem, .none, .none } }, |
| 51015 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64260 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51016 | 64261 | }, |
| 64262 | .call_frame = .{ .alignment = .@"16" }, |
| 51017 | 64263 | .extra_temps = .{ |
| 51018 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51019 | | .unused, |
| 51020 | | .unused, |
| 51021 | | .unused, |
| 64264 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64265 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64266 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsixf" } } }, |
| 64267 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51022 | 64268 | .unused, |
| 51023 | 64269 | .unused, |
| 51024 | 64270 | .unused, |
| 51025 | 64271 | .unused, |
| 51026 | 64272 | .unused, |
| 51027 | 64273 | }, |
| 51028 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64274 | .dst_temps = .{.mem}, |
| 64275 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51029 | 64276 | .each = .{ .once = &.{ |
| 51030 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 51031 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51032 | | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64277 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64278 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64279 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64280 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64281 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64282 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 64283 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51033 | 64284 | } }, |
| 51034 | 64285 | }, .{ |
| 51035 | | .required_features = .{ .avx, null, null, null }, |
| 51036 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 51037 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64286 | .required_features = .{ .x87, null, null, null }, |
| 64287 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 64288 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51038 | 64289 | .patterns = &.{ |
| 51039 | | .{ .src = .{ .mem, .none, .none } }, |
| 51040 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64290 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51041 | 64291 | }, |
| 51042 | | .dst_temps = .{.{ .rc = .sse }}, |
| 51043 | | .each = .{ .once = &.{ |
| 51044 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51045 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, |
| 51046 | | } }, |
| 51047 | | }, .{ |
| 51048 | | .required_features = .{ .sse, null, null, null }, |
| 51049 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 51050 | | .dst_constraints = .{.{ .float = .dword }}, |
| 51051 | | .patterns = &.{ |
| 51052 | | .{ .src = .{ .mem, .none, .none } }, |
| 51053 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64292 | .call_frame = .{ .alignment = .@"16" }, |
| 64293 | .extra_temps = .{ |
| 64294 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64295 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 64296 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsixf" } } }, |
| 64297 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 64298 | .unused, |
| 64299 | .unused, |
| 64300 | .unused, |
| 64301 | .unused, |
| 64302 | .unused, |
| 51054 | 64303 | }, |
| 51055 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64304 | .dst_temps = .{.mem}, |
| 64305 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51056 | 64306 | .each = .{ .once = &.{ |
| 51057 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51058 | | .{ ._, ._ss, .cvtsi2, .dst0x, .src0d, ._, ._ }, |
| 64307 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64308 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64309 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64310 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64311 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"8", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64312 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 64313 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51059 | 64314 | } }, |
| 51060 | 64315 | }, .{ |
| 51061 | | .required_features = .{ .avx, null, null, null }, |
| 51062 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 51063 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64316 | .required_features = .{ .x87, null, null, null }, |
| 64317 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64318 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51064 | 64319 | .patterns = &.{ |
| 51065 | | .{ .src = .{ .mem, .none, .none } }, |
| 51066 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64320 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51067 | 64321 | }, |
| 51068 | 64322 | .extra_temps = .{ |
| 51069 | | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51070 | | .unused, |
| 64323 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64324 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51071 | 64325 | .unused, |
| 51072 | 64326 | .unused, |
| 51073 | 64327 | .unused, |
| ... | ... | @@ -51076,73 +64330,85 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51076 | 64330 | .unused, |
| 51077 | 64331 | .unused, |
| 51078 | 64332 | }, |
| 51079 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64333 | .dst_temps = .{.mem}, |
| 64334 | .clobbers = .{ .eflags = true }, |
| 51080 | 64335 | .each = .{ .once = &.{ |
| 51081 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51082 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51083 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, |
| 64336 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64337 | .{ .@"0:", .fi_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64338 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64339 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 64340 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51084 | 64341 | } }, |
| 51085 | 64342 | }, .{ |
| 51086 | | .required_features = .{ .sse, null, null, null }, |
| 51087 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 51088 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64343 | .required_features = .{ .x87, null, null, null }, |
| 64344 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64345 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51089 | 64346 | .patterns = &.{ |
| 51090 | | .{ .src = .{ .mem, .none, .none } }, |
| 51091 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64347 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51092 | 64348 | }, |
| 64349 | .call_frame = .{ .alignment = .@"16" }, |
| 51093 | 64350 | .extra_temps = .{ |
| 51094 | | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51095 | | .unused, |
| 51096 | | .unused, |
| 51097 | | .unused, |
| 64351 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64352 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64353 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsixf" } } }, |
| 64354 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51098 | 64355 | .unused, |
| 51099 | 64356 | .unused, |
| 51100 | 64357 | .unused, |
| 51101 | 64358 | .unused, |
| 51102 | 64359 | .unused, |
| 51103 | 64360 | }, |
| 51104 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64361 | .dst_temps = .{.mem}, |
| 64362 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51105 | 64363 | .each = .{ .once = &.{ |
| 51106 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51107 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51108 | | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0q, ._, ._ }, |
| 64364 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64365 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64366 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64367 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64368 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64369 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 64370 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51109 | 64371 | } }, |
| 51110 | 64372 | }, .{ |
| 51111 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51112 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 51113 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64373 | .required_features = .{ .x87, null, null, null }, |
| 64374 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64375 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51114 | 64376 | .patterns = &.{ |
| 51115 | | .{ .src = .{ .mem, .none, .none } }, |
| 51116 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64377 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51117 | 64378 | }, |
| 51118 | | .dst_temps = .{.{ .rc = .sse }}, |
| 51119 | | .each = .{ .once = &.{ |
| 51120 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51121 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 51122 | | } }, |
| 51123 | | }, .{ |
| 51124 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51125 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 51126 | | .dst_constraints = .{.{ .float = .dword }}, |
| 51127 | | .patterns = &.{ |
| 51128 | | .{ .src = .{ .mem, .none, .none } }, |
| 51129 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64379 | .call_frame = .{ .alignment = .@"16" }, |
| 64380 | .extra_temps = .{ |
| 64381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64382 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 64383 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsixf" } } }, |
| 64384 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 64385 | .unused, |
| 64386 | .unused, |
| 64387 | .unused, |
| 64388 | .unused, |
| 64389 | .unused, |
| 51130 | 64390 | }, |
| 51131 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64391 | .dst_temps = .{.mem}, |
| 64392 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51132 | 64393 | .each = .{ .once = &.{ |
| 51133 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51134 | | .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 64394 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64395 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64396 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64397 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64398 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"4", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64399 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 64400 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51135 | 64401 | } }, |
| 51136 | 64402 | }, .{ |
| 51137 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51138 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 51139 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64403 | .required_features = .{ .x87, null, null, null }, |
| 64404 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 64405 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51140 | 64406 | .patterns = &.{ |
| 51141 | | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 64407 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51142 | 64408 | }, |
| 51143 | 64409 | .extra_temps = .{ |
| 51144 | | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 51145 | | .unused, |
| 64410 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64411 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51146 | 64412 | .unused, |
| 51147 | 64413 | .unused, |
| 51148 | 64414 | .unused, |
| ... | ... | @@ -51151,165 +64417,215 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51151 | 64417 | .unused, |
| 51152 | 64418 | .unused, |
| 51153 | 64419 | }, |
| 51154 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64420 | .dst_temps = .{.mem}, |
| 51155 | 64421 | .clobbers = .{ .eflags = true }, |
| 51156 | 64422 | .each = .{ .once = &.{ |
| 51157 | | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51158 | | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 51159 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 51160 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51161 | | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 51162 | | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 51163 | | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 51164 | | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 51165 | | .{ ._, .v_ss, .add, .dst0x, .dst0x, .dst0d, ._ }, |
| 51166 | | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 51167 | | .{ .@"1:", .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 64423 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64424 | .{ .@"0:", .fi_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64425 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64426 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 64427 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51168 | 64428 | } }, |
| 51169 | 64429 | }, .{ |
| 51170 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51171 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 51172 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64430 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 64431 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 64432 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51173 | 64433 | .patterns = &.{ |
| 51174 | | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 64434 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51175 | 64435 | }, |
| 64436 | .call_frame = .{ .alignment = .@"16" }, |
| 51176 | 64437 | .extra_temps = .{ |
| 51177 | | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 51178 | | .unused, |
| 51179 | | .unused, |
| 51180 | | .unused, |
| 64438 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64439 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 64440 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdixf" } } }, |
| 64441 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51181 | 64442 | .unused, |
| 51182 | 64443 | .unused, |
| 51183 | 64444 | .unused, |
| 51184 | 64445 | .unused, |
| 51185 | 64446 | .unused, |
| 51186 | 64447 | }, |
| 51187 | | .dst_temps = .{.{ .rc = .sse }}, |
| 51188 | | .clobbers = .{ .eflags = true }, |
| 64448 | .dst_temps = .{.mem}, |
| 64449 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51189 | 64450 | .each = .{ .once = &.{ |
| 51190 | | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51191 | | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 51192 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 51193 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51194 | | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 51195 | | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 51196 | | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 51197 | | .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 51198 | | .{ ._, ._ss, .add, .dst0x, .dst0d, ._, ._ }, |
| 51199 | | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 51200 | | .{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 64451 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64452 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64453 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64454 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64455 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64456 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 64457 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51201 | 64458 | } }, |
| 51202 | 64459 | }, .{ |
| 51203 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51204 | | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 51205 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64460 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 64461 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 64462 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51206 | 64463 | .patterns = &.{ |
| 51207 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 64464 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51208 | 64465 | }, |
| 51209 | 64466 | .call_frame = .{ .alignment = .@"16" }, |
| 51210 | 64467 | .extra_temps = .{ |
| 51211 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattisf" } } }, |
| 51212 | | .unused, |
| 51213 | | .unused, |
| 51214 | | .unused, |
| 64468 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64469 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 64470 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundixf" } } }, |
| 64471 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51215 | 64472 | .unused, |
| 51216 | 64473 | .unused, |
| 51217 | 64474 | .unused, |
| 51218 | 64475 | .unused, |
| 51219 | 64476 | .unused, |
| 51220 | 64477 | }, |
| 51221 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64478 | .dst_temps = .{.mem}, |
| 51222 | 64479 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51223 | 64480 | .each = .{ .once = &.{ |
| 51224 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 64481 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64482 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64483 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64484 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64485 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64486 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 64487 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51225 | 64488 | } }, |
| 51226 | 64489 | }, .{ |
| 51227 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51228 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 51229 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64490 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 64491 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 64492 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51230 | 64493 | .patterns = &.{ |
| 51231 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 64494 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51232 | 64495 | }, |
| 51233 | 64496 | .call_frame = .{ .alignment = .@"16" }, |
| 51234 | 64497 | .extra_temps = .{ |
| 51235 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntisf" } } }, |
| 64498 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64499 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 64500 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 64501 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattixf" } } }, |
| 64502 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51236 | 64503 | .unused, |
| 51237 | 64504 | .unused, |
| 51238 | 64505 | .unused, |
| 51239 | 64506 | .unused, |
| 64507 | }, |
| 64508 | .dst_temps = .{.mem}, |
| 64509 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 64510 | .each = .{ .once = &.{ |
| 64511 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64512 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64513 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 64514 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64515 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64516 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64517 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 64518 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 64519 | } }, |
| 64520 | }, .{ |
| 64521 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 64522 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 64523 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 64524 | .patterns = &.{ |
| 64525 | .{ .src = .{ .to_mem, .none, .none } }, |
| 64526 | }, |
| 64527 | .call_frame = .{ .alignment = .@"16" }, |
| 64528 | .extra_temps = .{ |
| 64529 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64530 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 64531 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 64532 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntixf" } } }, |
| 64533 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51240 | 64534 | .unused, |
| 51241 | 64535 | .unused, |
| 51242 | 64536 | .unused, |
| 51243 | 64537 | .unused, |
| 51244 | 64538 | }, |
| 51245 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64539 | .dst_temps = .{.mem}, |
| 51246 | 64540 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51247 | 64541 | .each = .{ .once = &.{ |
| 51248 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 64542 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64543 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64544 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 64545 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64546 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64547 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 64548 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 64549 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51249 | 64550 | } }, |
| 51250 | 64551 | }, .{ |
| 51251 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51252 | | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51253 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64552 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 64553 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64554 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51254 | 64555 | .patterns = &.{ |
| 51255 | 64556 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51256 | 64557 | }, |
| 51257 | 64558 | .call_frame = .{ .alignment = .@"16" }, |
| 51258 | 64559 | .extra_temps = .{ |
| 64560 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64561 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51259 | 64562 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51260 | 64563 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51261 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateisf" } } }, |
| 51262 | | .unused, |
| 51263 | | .unused, |
| 51264 | | .unused, |
| 64564 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } }, |
| 64565 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51265 | 64566 | .unused, |
| 51266 | 64567 | .unused, |
| 51267 | 64568 | .unused, |
| 51268 | 64569 | }, |
| 51269 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64570 | .dst_temps = .{.mem}, |
| 51270 | 64571 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51271 | 64572 | .each = .{ .once = &.{ |
| 51272 | 64573 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51273 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 51274 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64574 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 64575 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 64576 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 64577 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 64578 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64579 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, |
| 64580 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 64581 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 64582 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51275 | 64583 | } }, |
| 51276 | 64584 | }, .{ |
| 51277 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51278 | | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51279 | | .dst_constraints = .{.{ .float = .dword }}, |
| 64585 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 64586 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64587 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51280 | 64588 | .patterns = &.{ |
| 51281 | 64589 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51282 | 64590 | }, |
| 51283 | 64591 | .call_frame = .{ .alignment = .@"16" }, |
| 51284 | 64592 | .extra_temps = .{ |
| 64593 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64594 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51285 | 64595 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51286 | 64596 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51287 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneisf" } } }, |
| 51288 | | .unused, |
| 51289 | | .unused, |
| 51290 | | .unused, |
| 64597 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } }, |
| 64598 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51291 | 64599 | .unused, |
| 51292 | 64600 | .unused, |
| 51293 | 64601 | .unused, |
| 51294 | 64602 | }, |
| 51295 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64603 | .dst_temps = .{.mem}, |
| 51296 | 64604 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51297 | 64605 | .each = .{ .once = &.{ |
| 51298 | 64606 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51299 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 51300 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64607 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 64608 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 64609 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 64610 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 64611 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 64612 | .{ ._, .f_p, .st, .memia(.dst0t, .tmp1, .add_unaligned_size), ._, ._, ._ }, |
| 64613 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 64614 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 64615 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51301 | 64616 | } }, |
| 51302 | 64617 | }, .{ |
| 51303 | | .required_features = .{ .avx, null, null, null }, |
| 64618 | .required_features = .{ .sse, null, null, null }, |
| 51304 | 64619 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 51305 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64620 | .dst_constraints = .{.{ .float = .xword }}, |
| 51306 | 64621 | .patterns = &.{ |
| 51307 | 64622 | .{ .src = .{ .mem, .none, .none } }, |
| 51308 | 64623 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51309 | 64624 | }, |
| 64625 | .call_frame = .{ .alignment = .@"16" }, |
| 51310 | 64626 | .extra_temps = .{ |
| 51311 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51312 | | .unused, |
| 64627 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64628 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51313 | 64629 | .unused, |
| 51314 | 64630 | .unused, |
| 51315 | 64631 | .unused, |
| ... | ... | @@ -51318,23 +64634,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51318 | 64634 | .unused, |
| 51319 | 64635 | .unused, |
| 51320 | 64636 | }, |
| 51321 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64637 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64638 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51322 | 64639 | .each = .{ .once = &.{ |
| 51323 | 64640 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 51324 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51325 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64641 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51326 | 64642 | } }, |
| 51327 | 64643 | }, .{ |
| 51328 | | .required_features = .{ .sse2, null, null, null }, |
| 51329 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 51330 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64644 | .required_features = .{ .sse, null, null, null }, |
| 64645 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 64646 | .dst_constraints = .{.{ .float = .xword }}, |
| 51331 | 64647 | .patterns = &.{ |
| 51332 | 64648 | .{ .src = .{ .mem, .none, .none } }, |
| 51333 | 64649 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51334 | 64650 | }, |
| 64651 | .call_frame = .{ .alignment = .@"16" }, |
| 51335 | 64652 | .extra_temps = .{ |
| 51336 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51337 | | .unused, |
| 64653 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 64654 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51338 | 64655 | .unused, |
| 51339 | 64656 | .unused, |
| 51340 | 64657 | .unused, |
| ... | ... | @@ -51343,23 +64660,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51343 | 64660 | .unused, |
| 51344 | 64661 | .unused, |
| 51345 | 64662 | }, |
| 51346 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64663 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64664 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51347 | 64665 | .each = .{ .once = &.{ |
| 51348 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 51349 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51350 | | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64666 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 64667 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51351 | 64668 | } }, |
| 51352 | 64669 | }, .{ |
| 51353 | | .required_features = .{ .avx, null, null, null }, |
| 51354 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 51355 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64670 | .required_features = .{ .sse, null, null, null }, |
| 64671 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 64672 | .dst_constraints = .{.{ .float = .xword }}, |
| 51356 | 64673 | .patterns = &.{ |
| 51357 | 64674 | .{ .src = .{ .mem, .none, .none } }, |
| 51358 | 64675 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51359 | 64676 | }, |
| 64677 | .call_frame = .{ .alignment = .@"16" }, |
| 51360 | 64678 | .extra_temps = .{ |
| 51361 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51362 | | .unused, |
| 64679 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64680 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51363 | 64681 | .unused, |
| 51364 | 64682 | .unused, |
| 51365 | 64683 | .unused, |
| ... | ... | @@ -51368,23 +64686,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51368 | 64686 | .unused, |
| 51369 | 64687 | .unused, |
| 51370 | 64688 | }, |
| 51371 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64689 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64690 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51372 | 64691 | .each = .{ .once = &.{ |
| 51373 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 51374 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51375 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64692 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 64693 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51376 | 64694 | } }, |
| 51377 | 64695 | }, .{ |
| 51378 | | .required_features = .{ .sse2, null, null, null }, |
| 51379 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 51380 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64696 | .required_features = .{ .sse, null, null, null }, |
| 64697 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 64698 | .dst_constraints = .{.{ .float = .xword }}, |
| 51381 | 64699 | .patterns = &.{ |
| 51382 | 64700 | .{ .src = .{ .mem, .none, .none } }, |
| 51383 | 64701 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51384 | 64702 | }, |
| 64703 | .call_frame = .{ .alignment = .@"16" }, |
| 51385 | 64704 | .extra_temps = .{ |
| 51386 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51387 | | .unused, |
| 64705 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 64706 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51388 | 64707 | .unused, |
| 51389 | 64708 | .unused, |
| 51390 | 64709 | .unused, |
| ... | ... | @@ -51393,22 +64712,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51393 | 64712 | .unused, |
| 51394 | 64713 | .unused, |
| 51395 | 64714 | }, |
| 51396 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64715 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64716 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51397 | 64717 | .each = .{ .once = &.{ |
| 51398 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 51399 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51400 | | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64718 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 64719 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51401 | 64720 | } }, |
| 51402 | 64721 | }, .{ |
| 51403 | | .required_features = .{ .avx, null, null, null }, |
| 51404 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 51405 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64722 | .required_features = .{ .sse, null, null, null }, |
| 64723 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 64724 | .dst_constraints = .{.{ .float = .xword }}, |
| 51406 | 64725 | .patterns = &.{ |
| 51407 | | .{ .src = .{ .mem, .none, .none } }, |
| 51408 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64726 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 51409 | 64727 | }, |
| 64728 | .call_frame = .{ .alignment = .@"16" }, |
| 51410 | 64729 | .extra_temps = .{ |
| 51411 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64730 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51412 | 64731 | .unused, |
| 51413 | 64732 | .unused, |
| 51414 | 64733 | .unused, |
| ... | ... | @@ -51418,22 +64737,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51418 | 64737 | .unused, |
| 51419 | 64738 | .unused, |
| 51420 | 64739 | }, |
| 51421 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64740 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64741 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51422 | 64742 | .each = .{ .once = &.{ |
| 51423 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 51424 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51425 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64743 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51426 | 64744 | } }, |
| 51427 | 64745 | }, .{ |
| 51428 | | .required_features = .{ .sse2, null, null, null }, |
| 51429 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 51430 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64746 | .required_features = .{ .sse, null, null, null }, |
| 64747 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 64748 | .dst_constraints = .{.{ .float = .xword }}, |
| 51431 | 64749 | .patterns = &.{ |
| 51432 | | .{ .src = .{ .mem, .none, .none } }, |
| 51433 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64750 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 51434 | 64751 | }, |
| 64752 | .call_frame = .{ .alignment = .@"16" }, |
| 51435 | 64753 | .extra_temps = .{ |
| 51436 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64754 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51437 | 64755 | .unused, |
| 51438 | 64756 | .unused, |
| 51439 | 64757 | .unused, |
| ... | ... | @@ -51443,22 +64761,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51443 | 64761 | .unused, |
| 51444 | 64762 | .unused, |
| 51445 | 64763 | }, |
| 51446 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64764 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64765 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51447 | 64766 | .each = .{ .once = &.{ |
| 51448 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 51449 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51450 | | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64767 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51451 | 64768 | } }, |
| 51452 | 64769 | }, .{ |
| 51453 | | .required_features = .{ .avx, null, null, null }, |
| 51454 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 51455 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64770 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 64771 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 64772 | .dst_constraints = .{.{ .float = .xword }}, |
| 51456 | 64773 | .patterns = &.{ |
| 51457 | | .{ .src = .{ .mem, .none, .none } }, |
| 51458 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64774 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 51459 | 64775 | }, |
| 64776 | .call_frame = .{ .alignment = .@"16" }, |
| 51460 | 64777 | .extra_temps = .{ |
| 51461 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64778 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 51462 | 64779 | .unused, |
| 51463 | 64780 | .unused, |
| 51464 | 64781 | .unused, |
| ... | ... | @@ -51468,22 +64785,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51468 | 64785 | .unused, |
| 51469 | 64786 | .unused, |
| 51470 | 64787 | }, |
| 51471 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64788 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64789 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51472 | 64790 | .each = .{ .once = &.{ |
| 51473 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 51474 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51475 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, |
| 64791 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51476 | 64792 | } }, |
| 51477 | 64793 | }, .{ |
| 51478 | | .required_features = .{ .sse2, null, null, null }, |
| 51479 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 51480 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64794 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 64795 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 64796 | .dst_constraints = .{.{ .float = .xword }}, |
| 51481 | 64797 | .patterns = &.{ |
| 51482 | | .{ .src = .{ .mem, .none, .none } }, |
| 51483 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64798 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 51484 | 64799 | }, |
| 64800 | .call_frame = .{ .alignment = .@"16" }, |
| 51485 | 64801 | .extra_temps = .{ |
| 51486 | | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64802 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 51487 | 64803 | .unused, |
| 51488 | 64804 | .unused, |
| 51489 | 64805 | .unused, |
| ... | ... | @@ -51493,50 +64809,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51493 | 64809 | .unused, |
| 51494 | 64810 | .unused, |
| 51495 | 64811 | }, |
| 51496 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64812 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64813 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51497 | 64814 | .each = .{ .once = &.{ |
| 51498 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 51499 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51500 | | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, |
| 64815 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51501 | 64816 | } }, |
| 51502 | 64817 | }, .{ |
| 51503 | | .required_features = .{ .avx, null, null, null }, |
| 51504 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 51505 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64818 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 64819 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 64820 | .dst_constraints = .{.{ .float = .xword }}, |
| 51506 | 64821 | .patterns = &.{ |
| 51507 | | .{ .src = .{ .mem, .none, .none } }, |
| 51508 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64822 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 51509 | 64823 | }, |
| 51510 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64824 | .call_frame = .{ .alignment = .@"16" }, |
| 64825 | .extra_temps = .{ |
| 64826 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 64827 | .unused, |
| 64828 | .unused, |
| 64829 | .unused, |
| 64830 | .unused, |
| 64831 | .unused, |
| 64832 | .unused, |
| 64833 | .unused, |
| 64834 | .unused, |
| 64835 | }, |
| 64836 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64837 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51511 | 64838 | .each = .{ .once = &.{ |
| 51512 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51513 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, |
| 64839 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51514 | 64840 | } }, |
| 51515 | 64841 | }, .{ |
| 51516 | | .required_features = .{ .sse2, null, null, null }, |
| 51517 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 51518 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64842 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 64843 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 64844 | .dst_constraints = .{.{ .float = .xword }}, |
| 51519 | 64845 | .patterns = &.{ |
| 51520 | | .{ .src = .{ .mem, .none, .none } }, |
| 51521 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64846 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 51522 | 64847 | }, |
| 51523 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64848 | .call_frame = .{ .alignment = .@"16" }, |
| 64849 | .extra_temps = .{ |
| 64850 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 64851 | .unused, |
| 64852 | .unused, |
| 64853 | .unused, |
| 64854 | .unused, |
| 64855 | .unused, |
| 64856 | .unused, |
| 64857 | .unused, |
| 64858 | .unused, |
| 64859 | }, |
| 64860 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64861 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51524 | 64862 | .each = .{ .once = &.{ |
| 51525 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51526 | | .{ ._, ._sd, .cvtsi2, .dst0x, .src0d, ._, ._ }, |
| 64863 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51527 | 64864 | } }, |
| 51528 | 64865 | }, .{ |
| 51529 | | .required_features = .{ .avx, null, null, null }, |
| 51530 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 51531 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64866 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 64867 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64868 | .dst_constraints = .{.{ .float = .xword }}, |
| 51532 | 64869 | .patterns = &.{ |
| 51533 | | .{ .src = .{ .mem, .none, .none } }, |
| 51534 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64870 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51535 | 64871 | }, |
| 64872 | .call_frame = .{ .alignment = .@"16" }, |
| 51536 | 64873 | .extra_temps = .{ |
| 51537 | | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51538 | | .unused, |
| 51539 | | .unused, |
| 64874 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 64875 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 64876 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 51540 | 64877 | .unused, |
| 51541 | 64878 | .unused, |
| 51542 | 64879 | .unused, |
| ... | ... | @@ -51544,284 +64881,424 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51544 | 64881 | .unused, |
| 51545 | 64882 | .unused, |
| 51546 | 64883 | }, |
| 51547 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64884 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64885 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51548 | 64886 | .each = .{ .once = &.{ |
| 51549 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51550 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51551 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, |
| 64887 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 64888 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 64889 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51552 | 64890 | } }, |
| 51553 | 64891 | }, .{ |
| 51554 | | .required_features = .{ .sse2, null, null, null }, |
| 51555 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 51556 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64892 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 64893 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 64894 | .dst_constraints = .{.{ .float = .xword }}, |
| 51557 | 64895 | .patterns = &.{ |
| 51558 | | .{ .src = .{ .mem, .none, .none } }, |
| 51559 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64896 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51560 | 64897 | }, |
| 64898 | .call_frame = .{ .alignment = .@"16" }, |
| 51561 | 64899 | .extra_temps = .{ |
| 51562 | | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 64900 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 64901 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 64902 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 64903 | .unused, |
| 51563 | 64904 | .unused, |
| 51564 | 64905 | .unused, |
| 51565 | 64906 | .unused, |
| 51566 | 64907 | .unused, |
| 51567 | 64908 | .unused, |
| 64909 | }, |
| 64910 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 64911 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 64912 | .each = .{ .once = &.{ |
| 64913 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 64914 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 64915 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 64916 | } }, |
| 64917 | }, .{ |
| 64918 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 64919 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64920 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 64921 | .patterns = &.{ |
| 64922 | .{ .src = .{ .to_mem, .none, .none } }, |
| 64923 | }, |
| 64924 | .call_frame = .{ .alignment = .@"16" }, |
| 64925 | .extra_temps = .{ |
| 64926 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64927 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64928 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64929 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 64930 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 64931 | .unused, |
| 51568 | 64932 | .unused, |
| 51569 | 64933 | .unused, |
| 51570 | 64934 | .unused, |
| 51571 | 64935 | }, |
| 51572 | | .dst_temps = .{.{ .rc = .sse }}, |
| 64936 | .dst_temps = .{.mem}, |
| 64937 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51573 | 64938 | .each = .{ .once = &.{ |
| 51574 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51575 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51576 | | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0q, ._, ._ }, |
| 64939 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64940 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64941 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64942 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64943 | .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 64944 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64945 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 64946 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51577 | 64947 | } }, |
| 51578 | 64948 | }, .{ |
| 51579 | | .required_features = .{ .x87, null, null, null }, |
| 51580 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 51581 | | .dst_constraints = .{.{ .float = .qword }}, |
| 64949 | .required_features = .{ .avx, null, null, null }, |
| 64950 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64951 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51582 | 64952 | .patterns = &.{ |
| 51583 | | .{ .src = .{ .mem, .none, .none } }, |
| 51584 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 64953 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51585 | 64954 | }, |
| 64955 | .call_frame = .{ .alignment = .@"16" }, |
| 51586 | 64956 | .extra_temps = .{ |
| 51587 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51588 | | .{ .type = .i16, .kind = .mem }, |
| 51589 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 64957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64959 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64960 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 64961 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 64962 | .unused, |
| 51590 | 64963 | .unused, |
| 51591 | 64964 | .unused, |
| 51592 | 64965 | .unused, |
| 64966 | }, |
| 64967 | .dst_temps = .{.mem}, |
| 64968 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 64969 | .each = .{ .once = &.{ |
| 64970 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 64971 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 64972 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 64973 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 64974 | .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 64975 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 64976 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 64977 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 64978 | } }, |
| 64979 | }, .{ |
| 64980 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 64981 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 64982 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 64983 | .patterns = &.{ |
| 64984 | .{ .src = .{ .to_mem, .none, .none } }, |
| 64985 | }, |
| 64986 | .call_frame = .{ .alignment = .@"16" }, |
| 64987 | .extra_temps = .{ |
| 64988 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 64989 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 64990 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 64991 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 64992 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 64993 | .unused, |
| 51593 | 64994 | .unused, |
| 51594 | 64995 | .unused, |
| 51595 | 64996 | .unused, |
| 51596 | 64997 | }, |
| 51597 | 64998 | .dst_temps = .{.mem}, |
| 64999 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51598 | 65000 | .each = .{ .once = &.{ |
| 51599 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 51600 | | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 51601 | | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 51602 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65001 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65002 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65003 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65004 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65005 | .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65006 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65007 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 65008 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51603 | 65009 | } }, |
| 51604 | 65010 | }, .{ |
| 51605 | | .required_features = .{ .x87, null, null, null }, |
| 51606 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 51607 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65011 | .required_features = .{ .sse2, null, null, null }, |
| 65012 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65013 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51608 | 65014 | .patterns = &.{ |
| 51609 | | .{ .src = .{ .mem, .none, .none } }, |
| 51610 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65015 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51611 | 65016 | }, |
| 65017 | .call_frame = .{ .alignment = .@"16" }, |
| 51612 | 65018 | .extra_temps = .{ |
| 51613 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51614 | | .{ .type = .i16, .kind = .mem }, |
| 51615 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 65019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65020 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65021 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65022 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65023 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 65024 | .unused, |
| 65025 | .unused, |
| 51616 | 65026 | .unused, |
| 51617 | 65027 | .unused, |
| 65028 | }, |
| 65029 | .dst_temps = .{.mem}, |
| 65030 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 65031 | .each = .{ .once = &.{ |
| 65032 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65033 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65034 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65035 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65036 | .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65037 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65038 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 65039 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 65040 | } }, |
| 65041 | }, .{ |
| 65042 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 65043 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65044 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 65045 | .patterns = &.{ |
| 65046 | .{ .src = .{ .to_mem, .none, .none } }, |
| 65047 | }, |
| 65048 | .call_frame = .{ .alignment = .@"16" }, |
| 65049 | .extra_temps = .{ |
| 65050 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65051 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65052 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65053 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65054 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51618 | 65055 | .unused, |
| 51619 | 65056 | .unused, |
| 51620 | 65057 | .unused, |
| 51621 | 65058 | .unused, |
| 51622 | 65059 | }, |
| 51623 | 65060 | .dst_temps = .{.mem}, |
| 65061 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51624 | 65062 | .each = .{ .once = &.{ |
| 51625 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 51626 | | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 51627 | | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 51628 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65063 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65064 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65065 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65066 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65067 | .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65068 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65069 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 65070 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51629 | 65071 | } }, |
| 51630 | 65072 | }, .{ |
| 51631 | | .required_features = .{ .x87, null, null, null }, |
| 51632 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any }, |
| 51633 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65073 | .required_features = .{ .sse, null, null, null }, |
| 65074 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65075 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51634 | 65076 | .patterns = &.{ |
| 51635 | 65077 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51636 | 65078 | }, |
| 65079 | .call_frame = .{ .alignment = .@"16" }, |
| 51637 | 65080 | .extra_temps = .{ |
| 51638 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51639 | | .unused, |
| 51640 | | .unused, |
| 51641 | | .unused, |
| 51642 | | .unused, |
| 65081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65082 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65083 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65084 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65085 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51643 | 65086 | .unused, |
| 51644 | 65087 | .unused, |
| 51645 | 65088 | .unused, |
| 51646 | 65089 | .unused, |
| 51647 | 65090 | }, |
| 51648 | 65091 | .dst_temps = .{.mem}, |
| 65092 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51649 | 65093 | .each = .{ .once = &.{ |
| 51650 | | .{ ._, .fi_, .ld, .src0w, ._, ._, ._ }, |
| 51651 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65094 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65095 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65096 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65097 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65098 | .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65099 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65100 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 65101 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 51652 | 65102 | } }, |
| 51653 | 65103 | }, .{ |
| 51654 | | .required_features = .{ .x87, null, null, null }, |
| 51655 | | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any }, |
| 51656 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65104 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 65105 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65106 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51657 | 65107 | .patterns = &.{ |
| 51658 | | .{ .src = .{ .mem, .none, .none } }, |
| 51659 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65108 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51660 | 65109 | }, |
| 65110 | .call_frame = .{ .alignment = .@"16" }, |
| 51661 | 65111 | .extra_temps = .{ |
| 51662 | | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51663 | | .{ .type = .i32, .kind = .mem }, |
| 51664 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51665 | | .unused, |
| 51666 | | .unused, |
| 65112 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65113 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65114 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65115 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65116 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51667 | 65117 | .unused, |
| 51668 | 65118 | .unused, |
| 51669 | 65119 | .unused, |
| 51670 | 65120 | .unused, |
| 51671 | 65121 | }, |
| 51672 | 65122 | .dst_temps = .{.mem}, |
| 65123 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51673 | 65124 | .each = .{ .once = &.{ |
| 51674 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 51675 | | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 51676 | | .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ }, |
| 51677 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65125 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65126 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65127 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65128 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65129 | .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65130 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65131 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 65132 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51678 | 65133 | } }, |
| 51679 | 65134 | }, .{ |
| 51680 | | .required_features = .{ .x87, null, null, null }, |
| 51681 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 51682 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65135 | .required_features = .{ .avx, null, null, null }, |
| 65136 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65137 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51683 | 65138 | .patterns = &.{ |
| 51684 | 65139 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51685 | 65140 | }, |
| 65141 | .call_frame = .{ .alignment = .@"16" }, |
| 51686 | 65142 | .extra_temps = .{ |
| 51687 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51688 | | .unused, |
| 51689 | | .unused, |
| 51690 | | .unused, |
| 51691 | | .unused, |
| 65143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65144 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65145 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65146 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65147 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51692 | 65148 | .unused, |
| 51693 | 65149 | .unused, |
| 51694 | 65150 | .unused, |
| 51695 | 65151 | .unused, |
| 51696 | 65152 | }, |
| 51697 | 65153 | .dst_temps = .{.mem}, |
| 65154 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51698 | 65155 | .each = .{ .once = &.{ |
| 51699 | | .{ ._, .fi_, .ld, .src0d, ._, ._, ._ }, |
| 51700 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65156 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65157 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65158 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65159 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65160 | .{ ._, .v_dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65161 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65162 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 65163 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 51701 | 65164 | } }, |
| 51702 | 65165 | }, .{ |
| 51703 | | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51704 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 51705 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65166 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 65167 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65168 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51706 | 65169 | .patterns = &.{ |
| 51707 | | .{ .src = .{ .mem, .none, .none } }, |
| 51708 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65170 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51709 | 65171 | }, |
| 65172 | .call_frame = .{ .alignment = .@"16" }, |
| 51710 | 65173 | .extra_temps = .{ |
| 51711 | | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51712 | | .{ .type = .i64, .kind = .mem }, |
| 51713 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51714 | | .unused, |
| 51715 | | .unused, |
| 65174 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65175 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65176 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65177 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65178 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51716 | 65179 | .unused, |
| 51717 | 65180 | .unused, |
| 51718 | 65181 | .unused, |
| 51719 | 65182 | .unused, |
| 51720 | 65183 | }, |
| 51721 | 65184 | .dst_temps = .{.mem}, |
| 65185 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51722 | 65186 | .each = .{ .once = &.{ |
| 51723 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51724 | | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| 51725 | | .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ }, |
| 51726 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65187 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65188 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65189 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65190 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65191 | .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65192 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65193 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 65194 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51727 | 65195 | } }, |
| 51728 | 65196 | }, .{ |
| 51729 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51730 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 51731 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65197 | .required_features = .{ .sse2, null, null, null }, |
| 65198 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65199 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51732 | 65200 | .patterns = &.{ |
| 51733 | | .{ .src = .{ .mem, .none, .none } }, |
| 51734 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65201 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51735 | 65202 | }, |
| 51736 | | .dst_temps = .{.{ .rc = .sse }}, |
| 51737 | | .each = .{ .once = &.{ |
| 51738 | | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, |
| 51739 | | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, |
| 51740 | | } }, |
| 51741 | | }, .{ |
| 51742 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 51743 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 51744 | | .dst_constraints = .{.{ .float = .qword }}, |
| 51745 | | .patterns = &.{ |
| 51746 | | .{ .src = .{ .mem, .none, .none } }, |
| 51747 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65203 | .call_frame = .{ .alignment = .@"16" }, |
| 65204 | .extra_temps = .{ |
| 65205 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65206 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 65207 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65208 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65209 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 65210 | .unused, |
| 65211 | .unused, |
| 65212 | .unused, |
| 65213 | .unused, |
| 51748 | 65214 | }, |
| 51749 | | .dst_temps = .{.{ .rc = .sse }}, |
| 65215 | .dst_temps = .{.mem}, |
| 65216 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51750 | 65217 | .each = .{ .once = &.{ |
| 51751 | | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, |
| 51752 | | .{ ._, ._sd, .cvtsi2, .dst0x, .src0q, ._, ._ }, |
| 65218 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65219 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65220 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65221 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65222 | .{ ._, ._dqa, .mov, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65223 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65224 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 65225 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 51753 | 65226 | } }, |
| 51754 | 65227 | }, .{ |
| 51755 | | .required_features = .{ .@"64bit", .avx, null, null }, |
| 51756 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 51757 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65228 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 65229 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65230 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51758 | 65231 | .patterns = &.{ |
| 51759 | | .{ .src = .{ .mem, .none, .none } }, |
| 51760 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65232 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51761 | 65233 | }, |
| 65234 | .call_frame = .{ .alignment = .@"16" }, |
| 51762 | 65235 | .extra_temps = .{ |
| 51763 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 65236 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51764 | 65237 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51765 | | .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem }, |
| 51766 | | .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem }, |
| 51767 | | .unused, |
| 65238 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65239 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65240 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51768 | 65241 | .unused, |
| 51769 | 65242 | .unused, |
| 51770 | 65243 | .unused, |
| 51771 | 65244 | .unused, |
| 51772 | 65245 | }, |
| 51773 | | .dst_temps = .{.{ .rc = .sse }}, |
| 65246 | .dst_temps = .{.mem}, |
| 65247 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51774 | 65248 | .each = .{ .once = &.{ |
| 51775 | | .{ ._, .v_q, .mov, .tmp0x, .src0q, ._, ._ }, |
| 51776 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 51777 | | .{ ._, .vp_, .unpckldq, .tmp0x, .tmp0x, .lea(.tmp1x), ._ }, |
| 51778 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 51779 | | .{ ._, .v_pd, .sub, .tmp0x, .tmp0x, .lea(.tmp1x), ._ }, |
| 51780 | | .{ ._, .v_pd, .unpckh, .dst0x, .tmp0x, .tmp0x, ._ }, |
| 51781 | | .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ }, |
| 65249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65250 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65251 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65252 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65253 | .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65254 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65255 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 65256 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51782 | 65257 | } }, |
| 51783 | 65258 | }, .{ |
| 51784 | | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 51785 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 51786 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65259 | .required_features = .{ .sse, null, null, null }, |
| 65260 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 65261 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51787 | 65262 | .patterns = &.{ |
| 51788 | | .{ .src = .{ .mem, .none, .none } }, |
| 51789 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65263 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51790 | 65264 | }, |
| 65265 | .call_frame = .{ .alignment = .@"16" }, |
| 51791 | 65266 | .extra_temps = .{ |
| 51792 | | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, |
| 65267 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51793 | 65268 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51794 | | .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem }, |
| 51795 | | .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem }, |
| 51796 | | .unused, |
| 65269 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65270 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65271 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51797 | 65272 | .unused, |
| 51798 | 65273 | .unused, |
| 51799 | 65274 | .unused, |
| 51800 | 65275 | .unused, |
| 51801 | 65276 | }, |
| 51802 | | .dst_temps = .{.{ .rc = .sse }}, |
| 65277 | .dst_temps = .{.mem}, |
| 65278 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51803 | 65279 | .each = .{ .once = &.{ |
| 51804 | | .{ ._, ._q, .mov, .tmp0x, .src0q, ._, ._ }, |
| 51805 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 51806 | | .{ ._, .p_, .unpckldq, .tmp0x, .lea(.tmp1x), ._, ._ }, |
| 51807 | | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, |
| 51808 | | .{ ._, ._pd, .sub, .tmp0x, .lea(.tmp1x), ._, ._ }, |
| 51809 | | .{ ._, ._pd, .mova, .dst0x, .tmp0x, ._, ._ }, |
| 51810 | | .{ ._, ._pd, .unpckh, .dst0x, .dst0x, ._, ._ }, |
| 51811 | | .{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ }, |
| 65280 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65281 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 65282 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65283 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65284 | .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 65285 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 65286 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 65287 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 51812 | 65288 | } }, |
| 51813 | 65289 | }, .{ |
| 51814 | | .required_features = .{ .x87, null, null, null }, |
| 51815 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 51816 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65290 | .required_features = .{ .avx, null, null, null }, |
| 65291 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 65292 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51817 | 65293 | .patterns = &.{ |
| 51818 | 65294 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51819 | 65295 | }, |
| 65296 | .call_frame = .{ .alignment = .@"16" }, |
| 51820 | 65297 | .extra_temps = .{ |
| 51821 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51822 | | .unused, |
| 51823 | | .unused, |
| 51824 | | .unused, |
| 65298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65299 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65300 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65301 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51825 | 65302 | .unused, |
| 51826 | 65303 | .unused, |
| 51827 | 65304 | .unused, |
| ... | ... | @@ -51829,22 +65306,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51829 | 65306 | .unused, |
| 51830 | 65307 | }, |
| 51831 | 65308 | .dst_temps = .{.mem}, |
| 65309 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51832 | 65310 | .each = .{ .once = &.{ |
| 51833 | | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, |
| 51834 | | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65311 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65312 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65313 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65314 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65315 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 65316 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51835 | 65317 | } }, |
| 51836 | 65318 | }, .{ |
| 51837 | | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51838 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 51839 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65319 | .required_features = .{ .sse2, null, null, null }, |
| 65320 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 65321 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51840 | 65322 | .patterns = &.{ |
| 51841 | | .{ .src = .{ .to_mut_gpr, .none, .none } }, |
| 65323 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51842 | 65324 | }, |
| 65325 | .call_frame = .{ .alignment = .@"16" }, |
| 51843 | 65326 | .extra_temps = .{ |
| 51844 | | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 51845 | | .{ .type = .f64, .kind = .{ .reg = .st7 } }, |
| 51846 | | .unused, |
| 51847 | | .unused, |
| 65327 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65328 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65329 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65330 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51848 | 65331 | .unused, |
| 51849 | 65332 | .unused, |
| 51850 | 65333 | .unused, |
| ... | ... | @@ -51852,723 +65335,850 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51852 | 65335 | .unused, |
| 51853 | 65336 | }, |
| 51854 | 65337 | .dst_temps = .{.mem}, |
| 51855 | | .clobbers = .{ .eflags = true }, |
| 65338 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51856 | 65339 | .each = .{ .once = &.{ |
| 51857 | | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, |
| 51858 | | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, |
| 51859 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 51860 | | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, |
| 51861 | | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, |
| 51862 | | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, |
| 51863 | | .{ ._, ._, .mov, .dst0q, .src0q, ._, ._ }, |
| 51864 | | .{ ._, .fi_, .ld, .dst0q, ._, ._, ._ }, |
| 51865 | | .{ ._, .f_, .add, .tmp1t, .tmp1t, ._, ._ }, |
| 51866 | | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, |
| 51867 | | .{ .pseudo, .f_cstp, .in, ._, ._, ._, ._ }, |
| 51868 | | .{ .@"1:", ._, .mov, .dst0q, .src0q, ._, ._ }, |
| 51869 | | .{ ._, .fi_, .ld, .dst0q, ._, ._, ._ }, |
| 51870 | | .{ .@"0:", .f_p, .st, .dst0q, ._, ._, ._ }, |
| 65340 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65341 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65342 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65343 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65344 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 65345 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51871 | 65346 | } }, |
| 51872 | 65347 | }, .{ |
| 51873 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51874 | | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 51875 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65348 | .required_features = .{ .sse, null, null, null }, |
| 65349 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 65350 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51876 | 65351 | .patterns = &.{ |
| 51877 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 65352 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51878 | 65353 | }, |
| 51879 | 65354 | .call_frame = .{ .alignment = .@"16" }, |
| 51880 | 65355 | .extra_temps = .{ |
| 51881 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } }, |
| 51882 | | .unused, |
| 51883 | | .unused, |
| 51884 | | .unused, |
| 65356 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65357 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65358 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65359 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51885 | 65360 | .unused, |
| 51886 | 65361 | .unused, |
| 51887 | 65362 | .unused, |
| 51888 | 65363 | .unused, |
| 51889 | 65364 | .unused, |
| 51890 | 65365 | }, |
| 51891 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65366 | .dst_temps = .{.mem}, |
| 51892 | 65367 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51893 | 65368 | .each = .{ .once = &.{ |
| 51894 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 65369 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65370 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65371 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65372 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65373 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 65374 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51895 | 65375 | } }, |
| 51896 | 65376 | }, .{ |
| 51897 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51898 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 51899 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65377 | .required_features = .{ .avx, null, null, null }, |
| 65378 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 65379 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51900 | 65380 | .patterns = &.{ |
| 51901 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 65381 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51902 | 65382 | }, |
| 51903 | 65383 | .call_frame = .{ .alignment = .@"16" }, |
| 51904 | 65384 | .extra_temps = .{ |
| 51905 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } }, |
| 51906 | | .unused, |
| 51907 | | .unused, |
| 51908 | | .unused, |
| 65385 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65386 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65387 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65388 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51909 | 65389 | .unused, |
| 51910 | 65390 | .unused, |
| 51911 | 65391 | .unused, |
| 51912 | 65392 | .unused, |
| 51913 | 65393 | .unused, |
| 51914 | 65394 | }, |
| 51915 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65395 | .dst_temps = .{.mem}, |
| 51916 | 65396 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51917 | 65397 | .each = .{ .once = &.{ |
| 51918 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 65398 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65399 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65400 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65401 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65402 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 65403 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51919 | 65404 | } }, |
| 51920 | 65405 | }, .{ |
| 51921 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51922 | | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51923 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65406 | .required_features = .{ .sse2, null, null, null }, |
| 65407 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 65408 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51924 | 65409 | .patterns = &.{ |
| 51925 | 65410 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51926 | 65411 | }, |
| 51927 | 65412 | .call_frame = .{ .alignment = .@"16" }, |
| 51928 | 65413 | .extra_temps = .{ |
| 51929 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51930 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51931 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } }, |
| 51932 | | .unused, |
| 65414 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65415 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65416 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65417 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51933 | 65418 | .unused, |
| 51934 | 65419 | .unused, |
| 51935 | 65420 | .unused, |
| 51936 | 65421 | .unused, |
| 51937 | 65422 | .unused, |
| 51938 | 65423 | }, |
| 51939 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65424 | .dst_temps = .{.mem}, |
| 51940 | 65425 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51941 | 65426 | .each = .{ .once = &.{ |
| 51942 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51943 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 65427 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65428 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51944 | 65429 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65430 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65431 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 65432 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51945 | 65433 | } }, |
| 51946 | 65434 | }, .{ |
| 51947 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51948 | | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51949 | | .dst_constraints = .{.{ .float = .qword }}, |
| 65435 | .required_features = .{ .sse, null, null, null }, |
| 65436 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 65437 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51950 | 65438 | .patterns = &.{ |
| 51951 | 65439 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51952 | 65440 | }, |
| 51953 | 65441 | .call_frame = .{ .alignment = .@"16" }, |
| 51954 | 65442 | .extra_temps = .{ |
| 51955 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51956 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51957 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } }, |
| 51958 | | .unused, |
| 65443 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65444 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65445 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65446 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51959 | 65447 | .unused, |
| 51960 | 65448 | .unused, |
| 51961 | 65449 | .unused, |
| 51962 | 65450 | .unused, |
| 51963 | 65451 | .unused, |
| 51964 | 65452 | }, |
| 51965 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65453 | .dst_temps = .{.mem}, |
| 51966 | 65454 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51967 | 65455 | .each = .{ .once = &.{ |
| 51968 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51969 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 65456 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65457 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51970 | 65458 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65459 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65460 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 65461 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51971 | 65462 | } }, |
| 51972 | 65463 | }, .{ |
| 51973 | | .required_features = .{ .x87, null, null, null }, |
| 51974 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 51975 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65464 | .required_features = .{ .avx, null, null, null }, |
| 65465 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65466 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51976 | 65467 | .patterns = &.{ |
| 51977 | | .{ .src = .{ .mem, .none, .none } }, |
| 51978 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65468 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51979 | 65469 | }, |
| 65470 | .call_frame = .{ .alignment = .@"16" }, |
| 51980 | 65471 | .extra_temps = .{ |
| 51981 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 51982 | | .{ .type = .i16, .kind = .mem }, |
| 51983 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51984 | | .unused, |
| 65472 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65473 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65474 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65475 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51985 | 65476 | .unused, |
| 51986 | 65477 | .unused, |
| 51987 | 65478 | .unused, |
| 51988 | 65479 | .unused, |
| 51989 | 65480 | .unused, |
| 51990 | 65481 | }, |
| 51991 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65482 | .dst_temps = .{.mem}, |
| 65483 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51992 | 65484 | .each = .{ .once = &.{ |
| 51993 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 51994 | | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 51995 | | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 51996 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65485 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65486 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65487 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65488 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65489 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 65490 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51997 | 65491 | } }, |
| 51998 | 65492 | }, .{ |
| 51999 | | .required_features = .{ .x87, null, null, null }, |
| 52000 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 52001 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65493 | .required_features = .{ .sse2, null, null, null }, |
| 65494 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65495 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52002 | 65496 | .patterns = &.{ |
| 52003 | | .{ .src = .{ .mem, .none, .none } }, |
| 52004 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65497 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52005 | 65498 | }, |
| 65499 | .call_frame = .{ .alignment = .@"16" }, |
| 52006 | 65500 | .extra_temps = .{ |
| 52007 | | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 52008 | | .{ .type = .i16, .kind = .mem }, |
| 52009 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 52010 | | .unused, |
| 65501 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65502 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65503 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65504 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52011 | 65505 | .unused, |
| 52012 | 65506 | .unused, |
| 52013 | 65507 | .unused, |
| 52014 | 65508 | .unused, |
| 52015 | 65509 | .unused, |
| 52016 | 65510 | }, |
| 52017 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65511 | .dst_temps = .{.mem}, |
| 65512 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52018 | 65513 | .each = .{ .once = &.{ |
| 52019 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 52020 | | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, |
| 52021 | | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, |
| 52022 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65514 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65515 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65516 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65517 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65518 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 65519 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52023 | 65520 | } }, |
| 52024 | 65521 | }, .{ |
| 52025 | | .required_features = .{ .x87, null, null, null }, |
| 52026 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any }, |
| 52027 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65522 | .required_features = .{ .sse, null, null, null }, |
| 65523 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65524 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52028 | 65525 | .patterns = &.{ |
| 52029 | 65526 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52030 | 65527 | }, |
| 65528 | .call_frame = .{ .alignment = .@"16" }, |
| 52031 | 65529 | .extra_temps = .{ |
| 52032 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 52033 | | .unused, |
| 52034 | | .unused, |
| 52035 | | .unused, |
| 65530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65531 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 65532 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 65533 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52036 | 65534 | .unused, |
| 52037 | 65535 | .unused, |
| 52038 | 65536 | .unused, |
| 52039 | 65537 | .unused, |
| 52040 | 65538 | .unused, |
| 52041 | 65539 | }, |
| 52042 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65540 | .dst_temps = .{.mem}, |
| 65541 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52043 | 65542 | .each = .{ .once = &.{ |
| 52044 | | .{ ._, .fi_, .ld, .src0w, ._, ._, ._ }, |
| 52045 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65543 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65544 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65545 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65546 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65547 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 65548 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52046 | 65549 | } }, |
| 52047 | 65550 | }, .{ |
| 52048 | | .required_features = .{ .x87, null, null, null }, |
| 52049 | | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any }, |
| 52050 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65551 | .required_features = .{ .avx, null, null, null }, |
| 65552 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65553 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52051 | 65554 | .patterns = &.{ |
| 52052 | | .{ .src = .{ .mem, .none, .none } }, |
| 52053 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65555 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52054 | 65556 | }, |
| 65557 | .call_frame = .{ .alignment = .@"16" }, |
| 52055 | 65558 | .extra_temps = .{ |
| 52056 | | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 52057 | | .{ .type = .i32, .kind = .mem }, |
| 52058 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 52059 | | .unused, |
| 65559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65560 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65561 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65562 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52060 | 65563 | .unused, |
| 52061 | 65564 | .unused, |
| 52062 | 65565 | .unused, |
| 52063 | 65566 | .unused, |
| 52064 | 65567 | .unused, |
| 52065 | 65568 | }, |
| 52066 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65569 | .dst_temps = .{.mem}, |
| 65570 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52067 | 65571 | .each = .{ .once = &.{ |
| 52068 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 52069 | | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, |
| 52070 | | .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ }, |
| 52071 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65572 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65573 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65574 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65575 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65576 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 65577 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52072 | 65578 | } }, |
| 52073 | 65579 | }, .{ |
| 52074 | | .required_features = .{ .x87, null, null, null }, |
| 52075 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, |
| 52076 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65580 | .required_features = .{ .sse2, null, null, null }, |
| 65581 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65582 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52077 | 65583 | .patterns = &.{ |
| 52078 | 65584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52079 | 65585 | }, |
| 65586 | .call_frame = .{ .alignment = .@"16" }, |
| 52080 | 65587 | .extra_temps = .{ |
| 52081 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 52082 | | .unused, |
| 52083 | | .unused, |
| 52084 | | .unused, |
| 65588 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65589 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65590 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65591 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52085 | 65592 | .unused, |
| 52086 | 65593 | .unused, |
| 52087 | 65594 | .unused, |
| 52088 | 65595 | .unused, |
| 52089 | 65596 | .unused, |
| 52090 | 65597 | }, |
| 52091 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65598 | .dst_temps = .{.mem}, |
| 65599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52092 | 65600 | .each = .{ .once = &.{ |
| 52093 | | .{ ._, .fi_, .ld, .src0d, ._, ._, ._ }, |
| 52094 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65601 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65602 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65603 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65604 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65605 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 65606 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52095 | 65607 | } }, |
| 52096 | 65608 | }, .{ |
| 52097 | | .required_features = .{ .@"64bit", .x87, null, null }, |
| 52098 | | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, |
| 52099 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65609 | .required_features = .{ .sse, null, null, null }, |
| 65610 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65611 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52100 | 65612 | .patterns = &.{ |
| 52101 | | .{ .src = .{ .mem, .none, .none } }, |
| 52102 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65613 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52103 | 65614 | }, |
| 65615 | .call_frame = .{ .alignment = .@"16" }, |
| 52104 | 65616 | .extra_temps = .{ |
| 52105 | | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, |
| 52106 | | .{ .type = .i64, .kind = .mem }, |
| 52107 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 52108 | | .unused, |
| 65617 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65618 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 65619 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 65620 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52109 | 65621 | .unused, |
| 52110 | 65622 | .unused, |
| 52111 | 65623 | .unused, |
| 52112 | 65624 | .unused, |
| 52113 | 65625 | .unused, |
| 52114 | 65626 | }, |
| 52115 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65627 | .dst_temps = .{.mem}, |
| 65628 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52116 | 65629 | .each = .{ .once = &.{ |
| 52117 | | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, |
| 52118 | | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| 52119 | | .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ }, |
| 52120 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65630 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65631 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65632 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65633 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"4", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65634 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| 65635 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52121 | 65636 | } }, |
| 52122 | 65637 | }, .{ |
| 52123 | | .required_features = .{ .x87, null, null, null }, |
| 52124 | | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, |
| 52125 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65638 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 65639 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 65640 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52126 | 65641 | .patterns = &.{ |
| 52127 | 65642 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52128 | 65643 | }, |
| 65644 | .call_frame = .{ .alignment = .@"16" }, |
| 52129 | 65645 | .extra_temps = .{ |
| 52130 | | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 52131 | | .unused, |
| 52132 | | .unused, |
| 52133 | | .unused, |
| 65646 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65647 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 65648 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 65649 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52134 | 65650 | .unused, |
| 52135 | 65651 | .unused, |
| 52136 | 65652 | .unused, |
| 52137 | 65653 | .unused, |
| 52138 | 65654 | .unused, |
| 52139 | 65655 | }, |
| 52140 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 65656 | .dst_temps = .{.mem}, |
| 65657 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52141 | 65658 | .each = .{ .once = &.{ |
| 52142 | | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, |
| 52143 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65659 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65660 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65661 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65662 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65663 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 65664 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52144 | 65665 | } }, |
| 52145 | 65666 | }, .{ |
| 52146 | | .required_features = .{ .x87, null, null, null }, |
| 52147 | | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 52148 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65667 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 65668 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 65669 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52149 | 65670 | .patterns = &.{ |
| 52150 | 65671 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52151 | 65672 | }, |
| 65673 | .call_frame = .{ .alignment = .@"16" }, |
| 52152 | 65674 | .extra_temps = .{ |
| 52153 | | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52154 | | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 52155 | | .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem }, |
| 52156 | | .unused, |
| 65675 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65676 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 65677 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 65678 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52157 | 65679 | .unused, |
| 52158 | 65680 | .unused, |
| 52159 | 65681 | .unused, |
| 52160 | 65682 | .unused, |
| 52161 | 65683 | .unused, |
| 52162 | 65684 | }, |
| 52163 | | .dst_temps = .{.{ .rc = .x87 }}, |
| 52164 | | .clobbers = .{ .eflags = true }, |
| 65685 | .dst_temps = .{.mem}, |
| 65686 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52165 | 65687 | .each = .{ .once = &.{ |
| 52166 | | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, |
| 52167 | | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| 52168 | | .{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ }, |
| 52169 | | .{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ }, |
| 52170 | | .{ ._, .f_, .add, .leasi(.tmp0d, .@"4", .tmp1), ._, ._, ._ }, |
| 52171 | | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, |
| 65688 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65689 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65690 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65691 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65692 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 65693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52172 | 65694 | } }, |
| 52173 | 65695 | }, .{ |
| 52174 | 65696 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52175 | | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 52176 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65697 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 65698 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52177 | 65699 | .patterns = &.{ |
| 52178 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 65700 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52179 | 65701 | }, |
| 52180 | 65702 | .call_frame = .{ .alignment = .@"16" }, |
| 52181 | 65703 | .extra_temps = .{ |
| 52182 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattixf" } } }, |
| 52183 | | .unused, |
| 52184 | | .unused, |
| 52185 | | .unused, |
| 65704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65705 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 65706 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 65707 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52186 | 65708 | .unused, |
| 52187 | 65709 | .unused, |
| 52188 | 65710 | .unused, |
| 52189 | 65711 | .unused, |
| 52190 | 65712 | .unused, |
| 52191 | 65713 | }, |
| 52192 | | .dst_temps = .{.{ .reg = .st0 }}, |
| 65714 | .dst_temps = .{.mem}, |
| 52193 | 65715 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52194 | 65716 | .each = .{ .once = &.{ |
| 52195 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 65717 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65718 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65719 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65720 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65721 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 65722 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52196 | 65723 | } }, |
| 52197 | 65724 | }, .{ |
| 52198 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52199 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 52200 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65725 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 65726 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 65727 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52201 | 65728 | .patterns = &.{ |
| 52202 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 65729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52203 | 65730 | }, |
| 52204 | 65731 | .call_frame = .{ .alignment = .@"16" }, |
| 52205 | 65732 | .extra_temps = .{ |
| 52206 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntixf" } } }, |
| 52207 | | .unused, |
| 52208 | | .unused, |
| 52209 | | .unused, |
| 65733 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65734 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65735 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 65736 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52210 | 65737 | .unused, |
| 52211 | 65738 | .unused, |
| 52212 | 65739 | .unused, |
| 52213 | 65740 | .unused, |
| 52214 | 65741 | .unused, |
| 52215 | 65742 | }, |
| 52216 | | .dst_temps = .{.{ .reg = .st0 }}, |
| 65743 | .dst_temps = .{.mem}, |
| 52217 | 65744 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52218 | 65745 | .each = .{ .once = &.{ |
| 52219 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 65746 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65747 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65748 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65749 | .{ ._, .v_dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65750 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 65751 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52220 | 65752 | } }, |
| 52221 | 65753 | }, .{ |
| 52222 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52223 | | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52224 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65754 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 65755 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 65756 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52225 | 65757 | .patterns = &.{ |
| 52226 | 65758 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52227 | 65759 | }, |
| 52228 | 65760 | .call_frame = .{ .alignment = .@"16" }, |
| 52229 | 65761 | .extra_temps = .{ |
| 52230 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52231 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52232 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } }, |
| 52233 | | .unused, |
| 65762 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65763 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65764 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 65765 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52234 | 65766 | .unused, |
| 52235 | 65767 | .unused, |
| 52236 | 65768 | .unused, |
| 52237 | 65769 | .unused, |
| 52238 | 65770 | .unused, |
| 52239 | 65771 | }, |
| 52240 | | .dst_temps = .{.{ .reg = .st0 }}, |
| 65772 | .dst_temps = .{.mem}, |
| 52241 | 65773 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52242 | 65774 | .each = .{ .once = &.{ |
| 52243 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 52244 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 65775 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65776 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52245 | 65777 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65778 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65779 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 65780 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52246 | 65781 | } }, |
| 52247 | 65782 | }, .{ |
| 52248 | 65783 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52249 | | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52250 | | .dst_constraints = .{.{ .float = .tbyte }}, |
| 65784 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 65785 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52251 | 65786 | .patterns = &.{ |
| 52252 | 65787 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52253 | 65788 | }, |
| 52254 | 65789 | .call_frame = .{ .alignment = .@"16" }, |
| 52255 | 65790 | .extra_temps = .{ |
| 52256 | | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52257 | | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52258 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } }, |
| 52259 | | .unused, |
| 65791 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65792 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65793 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 65794 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52260 | 65795 | .unused, |
| 52261 | 65796 | .unused, |
| 52262 | 65797 | .unused, |
| 52263 | 65798 | .unused, |
| 52264 | 65799 | .unused, |
| 52265 | 65800 | }, |
| 52266 | | .dst_temps = .{.{ .reg = .st0 }}, |
| 65801 | .dst_temps = .{.mem}, |
| 52267 | 65802 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52268 | 65803 | .each = .{ .once = &.{ |
| 52269 | | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 52270 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 65804 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65805 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52271 | 65806 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 65807 | .{ ._, ._ps, .mova, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 65808 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 65809 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52272 | 65810 | } }, |
| 52273 | 65811 | }, .{ |
| 52274 | | .required_features = .{ .sse, null, null, null }, |
| 52275 | | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 52276 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65812 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 65813 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 65814 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52277 | 65815 | .patterns = &.{ |
| 52278 | | .{ .src = .{ .mem, .none, .none } }, |
| 52279 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65816 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52280 | 65817 | }, |
| 52281 | 65818 | .call_frame = .{ .alignment = .@"16" }, |
| 52282 | 65819 | .extra_temps = .{ |
| 52283 | | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 52284 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 52285 | | .unused, |
| 52286 | | .unused, |
| 52287 | | .unused, |
| 65820 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65821 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65822 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 65823 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 65824 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52288 | 65825 | .unused, |
| 52289 | 65826 | .unused, |
| 52290 | 65827 | .unused, |
| 52291 | 65828 | .unused, |
| 52292 | 65829 | }, |
| 52293 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65830 | .dst_temps = .{.mem}, |
| 52294 | 65831 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52295 | 65832 | .each = .{ .once = &.{ |
| 52296 | | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 52297 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 65833 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65834 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65835 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 65836 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65837 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 65838 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 65839 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52298 | 65840 | } }, |
| 52299 | 65841 | }, .{ |
| 52300 | | .required_features = .{ .sse, null, null, null }, |
| 52301 | | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 52302 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65842 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 65843 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 65844 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52303 | 65845 | .patterns = &.{ |
| 52304 | | .{ .src = .{ .mem, .none, .none } }, |
| 52305 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65846 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52306 | 65847 | }, |
| 52307 | 65848 | .call_frame = .{ .alignment = .@"16" }, |
| 52308 | 65849 | .extra_temps = .{ |
| 52309 | | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 52310 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 52311 | | .unused, |
| 52312 | | .unused, |
| 52313 | | .unused, |
| 65850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65851 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65852 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 65853 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 65854 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52314 | 65855 | .unused, |
| 52315 | 65856 | .unused, |
| 52316 | 65857 | .unused, |
| 52317 | 65858 | .unused, |
| 52318 | 65859 | }, |
| 52319 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65860 | .dst_temps = .{.mem}, |
| 52320 | 65861 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52321 | 65862 | .each = .{ .once = &.{ |
| 52322 | | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 52323 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 65863 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65864 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65865 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 65866 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65867 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 65868 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 65869 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52324 | 65870 | } }, |
| 52325 | 65871 | }, .{ |
| 52326 | | .required_features = .{ .sse, null, null, null }, |
| 52327 | | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 52328 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65872 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 65873 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 65874 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52329 | 65875 | .patterns = &.{ |
| 52330 | | .{ .src = .{ .mem, .none, .none } }, |
| 52331 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65876 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52332 | 65877 | }, |
| 52333 | 65878 | .call_frame = .{ .alignment = .@"16" }, |
| 52334 | 65879 | .extra_temps = .{ |
| 52335 | | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 52336 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 52337 | | .unused, |
| 52338 | | .unused, |
| 52339 | | .unused, |
| 65880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65881 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65882 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 65883 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 65884 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52340 | 65885 | .unused, |
| 52341 | 65886 | .unused, |
| 52342 | 65887 | .unused, |
| 52343 | 65888 | .unused, |
| 52344 | 65889 | }, |
| 52345 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65890 | .dst_temps = .{.mem}, |
| 52346 | 65891 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52347 | 65892 | .each = .{ .once = &.{ |
| 52348 | | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 52349 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 65893 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65894 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65895 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 65896 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65897 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 65898 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 65899 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52350 | 65900 | } }, |
| 52351 | 65901 | }, .{ |
| 52352 | | .required_features = .{ .sse, null, null, null }, |
| 52353 | | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 52354 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65902 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 65903 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 65904 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52355 | 65905 | .patterns = &.{ |
| 52356 | | .{ .src = .{ .mem, .none, .none } }, |
| 52357 | | .{ .src = .{ .to_gpr, .none, .none } }, |
| 65906 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52358 | 65907 | }, |
| 52359 | 65908 | .call_frame = .{ .alignment = .@"16" }, |
| 52360 | 65909 | .extra_temps = .{ |
| 52361 | | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 52362 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 52363 | | .unused, |
| 52364 | | .unused, |
| 52365 | | .unused, |
| 65910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65911 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65912 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 65913 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 65914 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52366 | 65915 | .unused, |
| 52367 | 65916 | .unused, |
| 52368 | 65917 | .unused, |
| 52369 | 65918 | .unused, |
| 52370 | 65919 | }, |
| 52371 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65920 | .dst_temps = .{.mem}, |
| 52372 | 65921 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52373 | 65922 | .each = .{ .once = &.{ |
| 52374 | | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 52375 | | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 65923 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65924 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65925 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 65926 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65927 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 65928 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 65929 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52376 | 65930 | } }, |
| 52377 | 65931 | }, .{ |
| 52378 | | .required_features = .{ .sse, null, null, null }, |
| 52379 | | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 52380 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65932 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 65933 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 65934 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52381 | 65935 | .patterns = &.{ |
| 52382 | | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 65936 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52383 | 65937 | }, |
| 52384 | 65938 | .call_frame = .{ .alignment = .@"16" }, |
| 52385 | 65939 | .extra_temps = .{ |
| 52386 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 52387 | | .unused, |
| 52388 | | .unused, |
| 52389 | | .unused, |
| 52390 | | .unused, |
| 65940 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65941 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65942 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 65943 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 65944 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52391 | 65945 | .unused, |
| 52392 | 65946 | .unused, |
| 52393 | 65947 | .unused, |
| 52394 | 65948 | .unused, |
| 52395 | 65949 | }, |
| 52396 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65950 | .dst_temps = .{.mem}, |
| 52397 | 65951 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52398 | 65952 | .each = .{ .once = &.{ |
| 52399 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 65953 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65954 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65955 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 65956 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65957 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 65958 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 65959 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52400 | 65960 | } }, |
| 52401 | 65961 | }, .{ |
| 52402 | | .required_features = .{ .sse, null, null, null }, |
| 52403 | | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 52404 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65962 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 65963 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 65964 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52405 | 65965 | .patterns = &.{ |
| 52406 | | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 65966 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52407 | 65967 | }, |
| 52408 | 65968 | .call_frame = .{ .alignment = .@"16" }, |
| 52409 | 65969 | .extra_temps = .{ |
| 52410 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 52411 | | .unused, |
| 52412 | | .unused, |
| 52413 | | .unused, |
| 52414 | | .unused, |
| 65970 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 65971 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 65972 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 65973 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 65974 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52415 | 65975 | .unused, |
| 52416 | 65976 | .unused, |
| 52417 | 65977 | .unused, |
| 52418 | 65978 | .unused, |
| 52419 | 65979 | }, |
| 52420 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 65980 | .dst_temps = .{.mem}, |
| 52421 | 65981 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52422 | 65982 | .each = .{ .once = &.{ |
| 52423 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 65983 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 65984 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 65985 | .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ }, |
| 65986 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 65987 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| 65988 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| 65989 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52424 | 65990 | } }, |
| 52425 | 65991 | }, .{ |
| 52426 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52427 | | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 52428 | | .dst_constraints = .{.{ .float = .xword }}, |
| 65992 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 65993 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 65994 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52429 | 65995 | .patterns = &.{ |
| 52430 | | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 65996 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52431 | 65997 | }, |
| 52432 | 65998 | .call_frame = .{ .alignment = .@"16" }, |
| 52433 | 65999 | .extra_temps = .{ |
| 52434 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 52435 | | .unused, |
| 52436 | | .unused, |
| 52437 | | .unused, |
| 52438 | | .unused, |
| 52439 | | .unused, |
| 66000 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 66001 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 66002 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 66003 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 66004 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 66005 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52440 | 66006 | .unused, |
| 52441 | 66007 | .unused, |
| 52442 | 66008 | .unused, |
| 52443 | 66009 | }, |
| 52444 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 66010 | .dst_temps = .{.mem}, |
| 52445 | 66011 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52446 | 66012 | .each = .{ .once = &.{ |
| 52447 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 66013 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 66014 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 66015 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 66016 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 66017 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 66018 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 66019 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 66020 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 66021 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52448 | 66022 | } }, |
| 52449 | 66023 | }, .{ |
| 52450 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52451 | | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 52452 | | .dst_constraints = .{.{ .float = .xword }}, |
| 66024 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 66025 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 66026 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52453 | 66027 | .patterns = &.{ |
| 52454 | | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 66028 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52455 | 66029 | }, |
| 52456 | 66030 | .call_frame = .{ .alignment = .@"16" }, |
| 52457 | 66031 | .extra_temps = .{ |
| 52458 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 52459 | | .unused, |
| 52460 | | .unused, |
| 52461 | | .unused, |
| 52462 | | .unused, |
| 52463 | | .unused, |
| 66032 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 66033 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 66034 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 66035 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 66036 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 66037 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52464 | 66038 | .unused, |
| 52465 | 66039 | .unused, |
| 52466 | 66040 | .unused, |
| 52467 | 66041 | }, |
| 52468 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 66042 | .dst_temps = .{.mem}, |
| 52469 | 66043 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52470 | 66044 | .each = .{ .once = &.{ |
| 52471 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 66045 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 66046 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 66047 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 66048 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 66049 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 66050 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 66051 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 66052 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 66053 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52472 | 66054 | } }, |
| 52473 | 66055 | }, .{ |
| 52474 | 66056 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52475 | | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 52476 | | .dst_constraints = .{.{ .float = .xword }}, |
| 66057 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 66058 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52477 | 66059 | .patterns = &.{ |
| 52478 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 66060 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52479 | 66061 | }, |
| 52480 | 66062 | .call_frame = .{ .alignment = .@"16" }, |
| 52481 | 66063 | .extra_temps = .{ |
| 52482 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 52483 | | .unused, |
| 52484 | | .unused, |
| 52485 | | .unused, |
| 52486 | | .unused, |
| 52487 | | .unused, |
| 66064 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 66065 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 66066 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 66067 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 66068 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 66069 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52488 | 66070 | .unused, |
| 52489 | 66071 | .unused, |
| 52490 | 66072 | .unused, |
| 52491 | 66073 | }, |
| 52492 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 66074 | .dst_temps = .{.mem}, |
| 52493 | 66075 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52494 | 66076 | .each = .{ .once = &.{ |
| 52495 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 66077 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 66078 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 66079 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 66080 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 66081 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 66082 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 66083 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 66084 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 66085 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52496 | 66086 | } }, |
| 52497 | 66087 | }, .{ |
| 52498 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52499 | | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 52500 | | .dst_constraints = .{.{ .float = .xword }}, |
| 66088 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 66089 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 66090 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52501 | 66091 | .patterns = &.{ |
| 52502 | | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 66092 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52503 | 66093 | }, |
| 52504 | 66094 | .call_frame = .{ .alignment = .@"16" }, |
| 52505 | 66095 | .extra_temps = .{ |
| 52506 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 52507 | | .unused, |
| 52508 | | .unused, |
| 52509 | | .unused, |
| 52510 | | .unused, |
| 52511 | | .unused, |
| 66096 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 66097 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 66098 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 66099 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 66100 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 66101 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52512 | 66102 | .unused, |
| 52513 | 66103 | .unused, |
| 52514 | 66104 | .unused, |
| 52515 | 66105 | }, |
| 52516 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 66106 | .dst_temps = .{.mem}, |
| 52517 | 66107 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52518 | 66108 | .each = .{ .once = &.{ |
| 52519 | | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 66109 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 66110 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 66111 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 66112 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 66113 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 66114 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 66115 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 66116 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 66117 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52520 | 66118 | } }, |
| 52521 | 66119 | }, .{ |
| 52522 | | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52523 | | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52524 | | .dst_constraints = .{.{ .float = .xword }}, |
| 66120 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 66121 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 66122 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52525 | 66123 | .patterns = &.{ |
| 52526 | 66124 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52527 | 66125 | }, |
| 52528 | 66126 | .call_frame = .{ .alignment = .@"16" }, |
| 52529 | 66127 | .extra_temps = .{ |
| 66128 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 66129 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52530 | 66130 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52531 | 66131 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52532 | | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 52533 | | .unused, |
| 52534 | | .unused, |
| 52535 | | .unused, |
| 66132 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 66133 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52536 | 66134 | .unused, |
| 52537 | 66135 | .unused, |
| 52538 | 66136 | .unused, |
| 52539 | 66137 | }, |
| 52540 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 66138 | .dst_temps = .{.mem}, |
| 52541 | 66139 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52542 | 66140 | .each = .{ .once = &.{ |
| 52543 | 66141 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 52544 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 52545 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 66142 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 66143 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 66144 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 66145 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 66146 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 66147 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 66148 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 66149 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52546 | 66150 | } }, |
| 52547 | 66151 | }, .{ |
| 52548 | 66152 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52549 | | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52550 | | .dst_constraints = .{.{ .float = .xword }}, |
| 66153 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 66154 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52551 | 66155 | .patterns = &.{ |
| 52552 | 66156 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52553 | 66157 | }, |
| 52554 | 66158 | .call_frame = .{ .alignment = .@"16" }, |
| 52555 | 66159 | .extra_temps = .{ |
| 66160 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 66161 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52556 | 66162 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52557 | 66163 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52558 | 66164 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 52559 | | .unused, |
| 52560 | | .unused, |
| 52561 | | .unused, |
| 66165 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52562 | 66166 | .unused, |
| 52563 | 66167 | .unused, |
| 52564 | 66168 | .unused, |
| 52565 | 66169 | }, |
| 52566 | | .dst_temps = .{.{ .reg = .xmm0 }}, |
| 66170 | .dst_temps = .{.mem}, |
| 52567 | 66171 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52568 | 66172 | .each = .{ .once = &.{ |
| 52569 | 66173 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 52570 | | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 52571 | | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 66174 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 66175 | .{ .@"0:", ._, .mov, .tmp2p, .tmp0p, ._, ._ }, |
| 66176 | .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_elem_size), ._, ._ }, |
| 66177 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 66178 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp1, .add_unaligned_size), .tmp5x, ._, ._ }, |
| 66179 | .{ ._, ._, .lea, .tmp0p, .leaa(.tmp0, .add_src0_elem_size), ._, ._ }, |
| 66180 | .{ ._, ._, .add, .tmp1p, .si(16), ._, ._ }, |
| 66181 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52572 | 66182 | } }, |
| 52573 | 66183 | } }) catch |err| switch (err) { |
| 52574 | 66184 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| ... | ... | @@ -66427,14 +80037,18 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 66427 | 80037 | .insert = .{ .p_w, .insr }, |
| 66428 | 80038 | .extract = .{ .p_w, .extr }, |
| 66429 | 80039 | } }, |
| 66430 | | 3...4 => return .{ .move = if (self.hasFeature(.avx)) |
| 66431 | | .{ .v_d, .mov } |
| 80040 | 3...4 => return .{ .move = .{ if (self.hasFeature(.avx)) |
| 80041 | .v_d |
| 80042 | else if (self.hasFeature(.sse2)) |
| 80043 | ._d |
| 66432 | 80044 | else |
| 66433 | | .{ ._d, .mov } }, |
| 80045 | ._ss, .mov } }, |
| 66434 | 80046 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) |
| 66435 | 80047 | .{ .v_q, .mov } |
| 80048 | else if (self.hasFeature(.sse2)) |
| 80049 | .{ ._q, .mov } |
| 66436 | 80050 | else |
| 66437 | | .{ ._q, .mov } }, |
| 80051 | .{ ._ps, .movl } }, |
| 66438 | 80052 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) |
| 66439 | 80053 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 66440 | 80054 | else if (self.hasFeature(.sse2)) |
| ... | ... | @@ -66494,10 +80108,40 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 66494 | 80108 | }, |
| 66495 | 80109 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { |
| 66496 | 80110 | .bool => switch (ty.vectorLen(zcu)) { |
| 80111 | 1...8 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{ |
| 80112 | .insert = .{ .vp_b, .insr }, |
| 80113 | .extract = .{ .vp_b, .extr }, |
| 80114 | } } else if (self.hasFeature(.sse4_2)) return .{ .insert_extract = .{ |
| 80115 | .insert = .{ .p_b, .insr }, |
| 80116 | .extract = .{ .p_b, .extr }, |
| 80117 | } }, |
| 80118 | 9...16 => return if (self.hasFeature(.avx)) .{ .vex_insert_extract = .{ |
| 80119 | .insert = .{ .vp_w, .insr }, |
| 80120 | .extract = .{ .vp_w, .extr }, |
| 80121 | } } else .{ .insert_extract = .{ |
| 80122 | .insert = .{ .p_w, .insr }, |
| 80123 | .extract = .{ .p_w, .extr }, |
| 80124 | } }, |
| 80125 | 17...32 => return .{ .move = .{ if (self.hasFeature(.avx)) |
| 80126 | .v_d |
| 80127 | else if (self.hasFeature(.sse2)) |
| 80128 | ._d |
| 80129 | else |
| 80130 | ._ss, .mov } }, |
| 66497 | 80131 | 33...64 => return .{ .move = if (self.hasFeature(.avx)) |
| 66498 | 80132 | .{ .v_q, .mov } |
| 80133 | else if (self.hasFeature(.sse2)) |
| 80134 | .{ ._q, .mov } |
| 66499 | 80135 | else |
| 66500 | | .{ ._q, .mov } }, |
| 80136 | .{ ._ps, .movl } }, |
| 80137 | 65...128 => return .{ .move = if (self.hasFeature(.avx)) |
| 80138 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 80139 | else if (self.hasFeature(.sse2)) |
| 80140 | .{ if (aligned) ._dqa else ._dqu, .mov } |
| 80141 | else |
| 80142 | .{ ._ps, if (aligned) .mova else .movu } }, |
| 80143 | 129...256 => if (self.hasFeature(.avx)) |
| 80144 | return .{ .move = .{ if (aligned) .v_dqa else .v_dqu, .mov } }, |
| 66501 | 80145 | else => {}, |
| 66502 | 80146 | }, |
| 66503 | 80147 | .int => switch (ty.childType(zcu).intInfo(zcu).bits) { |
| ... | ... | @@ -70347,6 +83991,11 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 70347 | 83991 | if (mask_len % 64 <= 32) acc_reg.to32() else acc_reg.to64(), |
| 70348 | 83992 | .u((@as(u64, std.math.maxInt(u64)) >> @truncate(-%mask_len))), |
| 70349 | 83993 | ); |
| 83994 | const operand_mem_mcv: MCValue = if (!operand_mcv.isBase()) operand_mem: { |
| 83995 | const frame_index = try self.allocFrameIndex(.initSpill(operand_ty, zcu)); |
| 83996 | try self.genSetMem(.{ .frame = frame_index }, 0, operand_ty, operand_mcv, .{}); |
| 83997 | break :operand_mem .{ .load_frame = .{ .index = frame_index } }; |
| 83998 | } else operand_mcv; |
| 70350 | 83999 | var first = true; |
| 70351 | 84000 | while (true) : (limb_offset -= 8) { |
| 70352 | 84001 | try self.asmRegisterMemory( |
| ... | ... | @@ -70356,7 +84005,7 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 70356 | 84005 | else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), |
| 70357 | 84006 | } }, |
| 70358 | 84007 | acc_reg.to64(), |
| 70359 | | try operand_mcv.mem(self, .{ |
| 84008 | try operand_mem_mcv.mem(self, .{ |
| 70360 | 84009 | .size = .qword, |
| 70361 | 84010 | .disp = limb_offset, |
| 70362 | 84011 | }), |
| ... | ... | @@ -74704,6 +88353,7 @@ const Select = struct { |
| 74704 | 88353 | f64_0x1p52_0x1p84_mem, |
| 74705 | 88354 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, |
| 74706 | 88355 | f32_0_0x1p64_mem, |
| 88356 | pshufb_cm_mem: struct { from: Memory.Size, to: Memory.Size }, |
| 74707 | 88357 | frame: FrameIndex, |
| 74708 | 88358 | symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 }, |
| 74709 | 88359 | |
| ... | ... | @@ -74875,6 +88525,23 @@ const Select = struct { |
| 74875 | 88525 | (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(), |
| 74876 | 88526 | } }, |
| 74877 | 88527 | } }))), true }, |
| 88528 | .pshufb_cm_mem => |info| { |
| 88529 | var bytes: [16]u8 = @splat(1 << 7); |
| 88530 | const from_bytes: u32 = @intCast(@divExact(info.from.bitSize(cg.target), 8)); |
| 88531 | const to_bytes: u32 = @intCast(@divExact(info.to.bitSize(cg.target), 8)); |
| 88532 | var from_index: u32 = 0; |
| 88533 | var to_index: u32 = 0; |
| 88534 | while (from_index < bytes.len) { |
| 88535 | for (0..to_bytes) |byte_off| bytes[to_index + byte_off] = @intCast(from_index + byte_off); |
| 88536 | from_index += from_bytes; |
| 88537 | to_index += to_bytes; |
| 88538 | } |
| 88539 | const zcu = pt.zcu; |
| 88540 | return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{ |
| 88541 | .ty = (try pt.vectorType(.{ .len = bytes.len, .child = .u8_type })).toIntern(), |
| 88542 | .storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, &bytes, .maybe_embedded_nulls) }, |
| 88543 | } }))), true }; |
| 88544 | }, |
| 74878 | 88545 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, |
| 74879 | 88546 | .symbol => |symbol| .{ try cg.tempInit(spec.type, .{ .lea_symbol = .{ |
| 74880 | 88547 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| |
| ... | ... | @@ -74938,6 +88605,7 @@ const Select = struct { |
| 74938 | 88605 | elem_limbs, |
| 74939 | 88606 | elem_size, |
| 74940 | 88607 | src0_elem_size, |
| 88608 | dst0_elem_size, |
| 74941 | 88609 | src0_elem_size_times_src1, |
| 74942 | 88610 | log2_src0_elem_size, |
| 74943 | 88611 | smin, |
| ... | ... | @@ -74977,6 +88645,7 @@ const Select = struct { |
| 74977 | 88645 | const add_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"1" }; |
| 74978 | 88646 | const sub_len: Adjust = .{ .sign = .neg, .lhs = .len, .op = .mul, .rhs = .@"1" }; |
| 74979 | 88647 | const add_elem_size_div_8: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .div, .rhs = .@"8" }; |
| 88648 | const add_8_elem_size: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .mul, .rhs = .@"8" }; |
| 74980 | 88649 | const add_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" }; |
| 74981 | 88650 | const add_2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"2" }; |
| 74982 | 88651 | const add_4_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"4" }; |
| ... | ... | @@ -74986,6 +88655,7 @@ const Select = struct { |
| 74986 | 88655 | const add_src0_elem_size_times_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" }; |
| 74987 | 88656 | const sub_src0_elem_size_times_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" }; |
| 74988 | 88657 | const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" }; |
| 88658 | const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; |
| 74989 | 88659 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; |
| 74990 | 88660 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| 74991 | 88661 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| ... | ... | @@ -75391,6 +89061,13 @@ const Select = struct { |
| 75391 | 89061 | .index = .{ .ref = index, .scale = scale }, |
| 75392 | 89062 | }; |
| 75393 | 89063 | } |
| 89064 | fn leasia(base: Ref.Sized, scale: Memory.Scale, index: Ref, adjust: Adjust) Select.Operand { |
| 89065 | return .{ |
| 89066 | .flags = .{ .tag = .lea, .adjust = adjust }, |
| 89067 | .base = base, |
| 89068 | .index = .{ .ref = index, .scale = scale }, |
| 89069 | }; |
| 89070 | } |
| 75394 | 89071 | fn leasid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { |
| 75395 | 89072 | return .{ |
| 75396 | 89073 | .flags = .{ .tag = .lea }, |
| ... | ... | @@ -75522,6 +89199,7 @@ const Select = struct { |
| 75522 | 89199 | )), |
| 75523 | 89200 | .elem_size => @intCast(op.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), |
| 75524 | 89201 | .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), |
| 89202 | .dst0_elem_size => @intCast(Select.Operand.Ref.dst0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), |
| 75525 | 89203 | .src0_elem_size_times_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * |
| 75526 | 89204 | Select.Operand.Ref.src1.valueOf(s).immediate), |
| 75527 | 89205 | .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))), |
Jacob Young <jacobly@ziglang.org> 2025-02-10 21:37:28-05:00
src