| ... | @@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2414,7 +2414,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2414 | } | 2414 | } |
| 2415 | | 2415 | |
| 2416 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2416 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2417 | @setEvalBranchQuota(9_800); | 2417 | @setEvalBranchQuota(11_900); |
| 2418 | const pt = cg.pt; | 2418 | const pt = cg.pt; |
| 2419 | const zcu = pt.zcu; | 2419 | const zcu = pt.zcu; |
| 2420 | const ip = &zcu.intern_pool; | 2420 | const ip = &zcu.intern_pool; |
| ... | @@ -23900,8 +23900,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23900,8 +23900,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23900 | .any, | 23900 | .any, |
| 23901 | }, | 23901 | }, |
| 23902 | .patterns = &.{ | 23902 | .patterns = &.{ |
| 23903 | .{ .src = .{ .to_sse, .mem, .none } }, | | |
| 23904 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, | 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 | .{ .src = .{ .to_sse, .to_sse, .none } }, | 23926 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 23906 | }, | 23927 | }, |
| 23907 | .dst_temps = .{.{ .mut_rc_mask = .{ | 23928 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | @@ -23925,7 +23946,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23925,7 +23946,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23925 | }, | 23946 | }, |
| 23926 | .patterns = &.{ | 23947 | .patterns = &.{ |
| 23927 | .{ .src = .{ .to_mut_sse, .mem, .none } }, | 23948 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 23928 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, | | |
| 23929 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, | 23949 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 23930 | }, | 23950 | }, |
| 23931 | .dst_temps = .{.{ .ref_mask = .{ | 23951 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | @@ -23947,8 +23967,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23947,8 +23967,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23947 | .any, | 23967 | .any, |
| 23948 | }, | 23968 | }, |
| 23949 | .patterns = &.{ | 23969 | .patterns = &.{ |
| 23950 | .{ .src = .{ .to_sse, .mem, .none } }, | | |
| 23951 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, | 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 | .{ .src = .{ .to_sse, .to_sse, .none } }, | 23993 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 23953 | }, | 23994 | }, |
| 23954 | .dst_temps = .{.{ .mut_rc_mask = .{ | 23995 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | @@ -23972,7 +24013,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23972,7 +24013,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23972 | }, | 24013 | }, |
| 23973 | .patterns = &.{ | 24014 | .patterns = &.{ |
| 23974 | .{ .src = .{ .to_mut_sse, .mem, .none } }, | 24015 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 23975 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, | | |
| 23976 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, | 24016 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 23977 | }, | 24017 | }, |
| 23978 | .dst_temps = .{.{ .ref_mask = .{ | 24018 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | @@ -23994,8 +24034,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -23994,8 +24034,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 23994 | .any, | 24034 | .any, |
| 23995 | }, | 24035 | }, |
| 23996 | .patterns = &.{ | 24036 | .patterns = &.{ |
| 23997 | .{ .src = .{ .to_sse, .mem, .none } }, | | |
| 23998 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, | 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 | .{ .src = .{ .to_sse, .to_sse, .none } }, | 24060 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24000 | }, | 24061 | }, |
| 24001 | .dst_temps = .{.{ .mut_rc_mask = .{ | 24062 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | @@ -24018,8 +24079,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24018,8 +24079,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24018 | .any, | 24079 | .any, |
| 24019 | }, | 24080 | }, |
| 24020 | .patterns = &.{ | 24081 | .patterns = &.{ |
| 24021 | .{ .src = .{ .to_sse, .mem, .none } }, | | |
| 24022 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, | 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 | .{ .src = .{ .to_sse, .to_sse, .none } }, | 24105 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24024 | }, | 24106 | }, |
| 24025 | .dst_temps = .{.{ .mut_rc_mask = .{ | 24107 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | @@ -24043,7 +24125,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24043,7 +24125,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24043 | }, | 24125 | }, |
| 24044 | .patterns = &.{ | 24126 | .patterns = &.{ |
| 24045 | .{ .src = .{ .to_mut_sse, .mem, .none } }, | 24127 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 24046 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, | | |
| 24047 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, | 24128 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 24048 | }, | 24129 | }, |
| 24049 | .dst_temps = .{.{ .ref_mask = .{ | 24130 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | @@ -24065,8 +24146,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24065,8 +24146,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24065 | .any, | 24146 | .any, |
| 24066 | }, | 24147 | }, |
| 24067 | .patterns = &.{ | 24148 | .patterns = &.{ |
| 24068 | .{ .src = .{ .to_sse, .mem, .none } }, | | |
| 24069 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, | 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 | .{ .src = .{ .to_sse, .to_sse, .none } }, | 24172 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24071 | }, | 24173 | }, |
| 24072 | .dst_temps = .{.{ .mut_rc_mask = .{ | 24174 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | @@ -24090,7 +24192,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24090,7 +24192,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24090 | }, | 24192 | }, |
| 24091 | .patterns = &.{ | 24193 | .patterns = &.{ |
| 24092 | .{ .src = .{ .to_mut_sse, .mem, .none } }, | 24194 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| 24093 | .{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } }, | | |
| 24094 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, | 24195 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| 24095 | }, | 24196 | }, |
| 24096 | .dst_temps = .{.{ .ref_mask = .{ | 24197 | .dst_temps = .{.{ .ref_mask = .{ |
| ... | @@ -24112,8 +24213,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -24112,8 +24213,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 24112 | .any, | 24213 | .any, |
| 24113 | }, | 24214 | }, |
| 24114 | .patterns = &.{ | 24215 | .patterns = &.{ |
| 24115 | .{ .src = .{ .to_sse, .mem, .none } }, | | |
| 24116 | .{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } }, | 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 | .{ .src = .{ .to_sse, .to_sse, .none } }, | 24239 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| 24118 | }, | 24240 | }, |
| 24119 | .dst_temps = .{.{ .mut_rc_mask = .{ | 24241 | .dst_temps = .{.{ .mut_rc_mask = .{ |
| ... | @@ -26088,306 +26210,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26088,306 +26210,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26088 | })) { | 26210 | })) { |
| 26089 | else => unreachable, | 26211 | else => unreachable, |
| 26090 | inline .e, .ne => |cc| comptime &.{ .{ | 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 | .src_constraints = .{ .{ .bool_vec = .byte }, .{ .bool_vec = .byte }, .any }, | 26213 | .src_constraints = .{ .{ .bool_vec = .byte }, .{ .bool_vec = .byte }, .any }, |
| 26392 | .patterns = &.{ | 26214 | .patterns = &.{ |
| 26393 | .{ .src = .{ .mut_mem, .imm8, .none } }, | 26215 | .{ .src = .{ .mut_mem, .imm8, .none } }, |
| ... | @@ -26526,6 +26348,366 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -26526,6 +26348,366 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 26526 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 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 | .required_features = .{ .avx2, null, null, null }, | 26712 | .required_features = .{ .avx2, null, null, null }, |
| 26531 | .src_constraints = .{ .{ .scalar_int_is = .byte }, .{ .scalar_int_is = .byte }, .any }, | 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,7 +27693,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27511 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, | 27693 | .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, |
| 27512 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, | 27694 | .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, |
| 27513 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 27695 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 27514 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 27696 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27515 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 27697 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27516 | } }, | 27698 | } }, |
| 27517 | }, .{ | 27699 | }, .{ |
| ... | @@ -27683,7 +27865,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27683,7 +27865,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27683 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, | 27865 | .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, |
| 27684 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, | 27866 | .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, |
| 27685 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, | 27867 | .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, |
| 27686 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, | 27868 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 27687 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 27869 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 27688 | } }, | 27870 | } }, |
| 27689 | }, .{ | 27871 | }, .{ |
| ... | @@ -27852,8 +28034,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27852,8 +28034,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27852 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, | 28034 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, |
| 27853 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, | 28035 | .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, |
| 27854 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, | 28036 | .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| 27855 | .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, | 28037 | .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, |
| 27856 | .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, | 28038 | .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, |
| 27857 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, | 28039 | .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, |
| 27858 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, | 28040 | .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, |
| 27859 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, | 28041 | .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, |
| ... | @@ -27944,6 +28126,133 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -27944,6 +28126,133 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 27944 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, | 28126 | .{ ._, ._r, .sh, .tmp1d, .ui(6), ._, ._ }, |
| 27945 | .{ ._, ._, .mov, .memsi(.dst0p, .@"8", .tmp1), .tmp2p, ._, ._ }, | 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 | .required_features = .{ .f16c, null, null, null }, | 28257 | .required_features = .{ .f16c, null, null, null }, |
| 27949 | .src_constraints = .{ | 28258 | .src_constraints = .{ |
| ... | @@ -48604,9 +48913,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -48604,9 +48913,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 48604 | try ops[0].toPair(&len, cg); | 48913 | try ops[0].toPair(&len, cg); |
| 48605 | try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); | 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 | const ty_op = air_datas[@intFromEnum(inst)].ty_op; | 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 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); | 48918 | var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); |
| 48611 | var res: [1]Temp = undefined; | 48919 | var res: [1]Temp = undefined; |
| 48612 | cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ | 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,292 +49299,226 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 48991 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 49299 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 48992 | } }, | 49300 | } }, |
| 48993 | }, .{ | 49301 | }, .{ |
| 48994 | .required_features = .{ .avx, null, null, null }, | 49302 | .required_features = .{ .f16c, null, null, null }, |
| 48995 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49303 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 48996 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, | 49304 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 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 }}, | | |
| 49033 | .patterns = &.{ | 49305 | .patterns = &.{ |
| 49034 | .{ .src = .{ .mem, .none, .none } }, | 49306 | .{ .src = .{ .mem, .none, .none } }, |
| 49035 | .{ .src = .{ .to_sse, .none, .none } }, | 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 | .extra_temps = .{ | 49309 | .extra_temps = .{ |
| 49049 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 49310 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 49050 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49311 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 49051 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49312 | .unused, |
| 49052 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, | 49313 | .unused, |
| 49053 | .unused, | 49314 | .unused, |
| 49054 | .unused, | 49315 | .unused, |
| 49055 | .unused, | 49316 | .unused, |
| 49056 | .unused, | 49317 | .unused, |
| 49057 | .unused, | 49318 | .unused, |
| 49058 | }, | 49319 | }, |
| 49059 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49320 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 49060 | .clobbers = .{ .eflags = true }, | | |
| 49061 | .each = .{ .once = &.{ | 49321 | .each = .{ .once = &.{ |
| 49062 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, | 49322 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 49063 | .{ ._, .v_, .cvttss2si, .tmp2q, .src0d, ._, ._ }, | 49323 | .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, |
| 49064 | .{ ._, .v_ss, .sub, .tmp0x, .src0x, .lea(.tmp1d), ._ }, | 49324 | .{ ._, .v_, .cvttps2dq, .dst0x, .dst0x, ._, ._ }, |
| 49065 | .{ ._, .v_, .cvttss2si, .dst0q, .tmp0d, ._, ._ }, | 49325 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 49066 | .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ }, | | |
| 49067 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, | | |
| 49068 | .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ }, | | |
| 49069 | .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ }, | | |
| 49070 | } }, | 49326 | } }, |
| 49071 | }, .{ | 49327 | }, .{ |
| 49072 | .required_features = .{ .@"64bit", .sse, null, null }, | 49328 | .required_features = .{ .f16c, null, null, null }, |
| 49073 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49329 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49074 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, | 49330 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 49075 | .patterns = &.{ | 49331 | .patterns = &.{ |
| 49076 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 49332 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49077 | }, | 49333 | }, |
| 49078 | .extra_temps = .{ | 49334 | .extra_temps = .{ |
| 49079 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49335 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49080 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49336 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 49081 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, | 49337 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 49082 | .unused, | 49338 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| 49083 | .unused, | 49339 | .unused, |
| 49084 | .unused, | 49340 | .unused, |
| 49085 | .unused, | 49341 | .unused, |
| 49086 | .unused, | 49342 | .unused, |
| 49087 | .unused, | 49343 | .unused, |
| 49088 | }, | 49344 | }, |
| 49089 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49345 | .dst_temps = .{.mem}, |
| 49090 | .clobbers = .{ .eflags = true }, | | |
| 49091 | .each = .{ .once = &.{ | 49346 | .each = .{ .once = &.{ |
| 49092 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 49347 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 49093 | .{ ._, ._, .cvttss2si, .tmp1q, .src0d, ._, ._ }, | 49348 | .{ ._, .v_dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 49094 | .{ ._, ._ss, .sub, .src0x, .lea(.tmp0d), ._, ._ }, | 49349 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49095 | .{ ._, ._, .cvttss2si, .dst0q, .src0d, ._, ._ }, | 49350 | .{ .@"0:", .v_ps, .cvtph2, .tmp3x, .memsia(.src0q, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 49096 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, | 49351 | .{ ._, .v_, .cvttps2dq, .tmp3x, .tmp3x, ._, ._ }, |
| 49097 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 49352 | .{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| 49098 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, | 49353 | .{ ._, .v_d, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 49099 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, | 49354 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 49355 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49100 | } }, | 49356 | } }, |
| 49101 | }, .{ | 49357 | }, .{ |
| 49102 | .required_features = .{ .@"64bit", .sse, null, null }, | 49358 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 49103 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49359 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49104 | .dst_constraints = .{.{ .signed_int = .xword }}, | 49360 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49105 | .patterns = &.{ | 49361 | .patterns = &.{ |
| 49106 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49362 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49107 | }, | 49363 | }, |
| 49108 | .call_frame = .{ .alignment = .@"16" }, | 49364 | .call_frame = .{ .alignment = .@"16" }, |
| 49109 | .extra_temps = .{ | 49365 | .extra_temps = .{ |
| 49110 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } }, | 49366 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49111 | .unused, | 49367 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49112 | .unused, | 49368 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49113 | .unused, | 49369 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49114 | .unused, | 49370 | .unused, |
| 49115 | .unused, | 49371 | .unused, |
| 49116 | .unused, | 49372 | .unused, |
| 49117 | .unused, | 49373 | .unused, |
| 49118 | .unused, | 49374 | .unused, |
| 49119 | }, | 49375 | }, |
| 49120 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 49376 | .dst_temps = .{.mem}, |
| 49121 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49377 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49122 | .each = .{ .once = &.{ | 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 }, | 49388 | .required_features = .{ .avx, null, null, null }, |
| 49127 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49389 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49128 | .dst_constraints = .{.{ .unsigned_int = .xword }}, | 49390 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49129 | .patterns = &.{ | 49391 | .patterns = &.{ |
| 49130 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49392 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49131 | }, | 49393 | }, |
| 49132 | .call_frame = .{ .alignment = .@"16" }, | 49394 | .call_frame = .{ .alignment = .@"16" }, |
| 49133 | .extra_temps = .{ | 49395 | .extra_temps = .{ |
| 49134 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, | 49396 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49135 | .unused, | 49397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49136 | .unused, | 49398 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49137 | .unused, | 49399 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49138 | .unused, | 49400 | .unused, |
| 49139 | .unused, | 49401 | .unused, |
| 49140 | .unused, | 49402 | .unused, |
| 49141 | .unused, | 49403 | .unused, |
| 49142 | .unused, | 49404 | .unused, |
| 49143 | }, | 49405 | }, |
| 49144 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 49406 | .dst_temps = .{.mem}, |
| 49145 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49407 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49146 | .each = .{ .once = &.{ | 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 }, | 49418 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 49151 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49419 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49152 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 49420 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49153 | .patterns = &.{ | 49421 | .patterns = &.{ |
| 49154 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49422 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49155 | }, | 49423 | }, |
| 49156 | .call_frame = .{ .alignment = .@"16" }, | 49424 | .call_frame = .{ .alignment = .@"16" }, |
| 49157 | .extra_temps = .{ | 49425 | .extra_temps = .{ |
| 49158 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49426 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49159 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 49427 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49160 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, | 49428 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49161 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, | 49429 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49162 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, | 49430 | .unused, |
| 49163 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 49431 | .unused, |
| 49164 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 49432 | .unused, |
| 49165 | .unused, | 49433 | .unused, |
| 49166 | .unused, | 49434 | .unused, |
| 49167 | }, | 49435 | }, |
| 49168 | .dst_temps = .{.mem}, | 49436 | .dst_temps = .{.mem}, |
| 49169 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49437 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49170 | .each = .{ .once = &.{ | 49438 | .each = .{ .once = &.{ |
| 49171 | .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ }, | 49439 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49172 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, | 49440 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49173 | .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, | 49441 | .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49174 | .{ ._, .v_ps, .@"and", .src0x, .src0x, .lea(.tmp1x), ._ }, | 49442 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49175 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 49443 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 49176 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 49444 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 49177 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, | 49445 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 49187 | } }, | 49446 | } }, |
| 49188 | }, .{ | 49447 | }, .{ |
| 49189 | .required_features = .{ .@"64bit", .sse2, null, null }, | 49448 | .required_features = .{ .sse2, null, null, null }, |
| 49190 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49449 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49191 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 49450 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49192 | .patterns = &.{ | 49451 | .patterns = &.{ |
| 49193 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49452 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49194 | }, | 49453 | }, |
| 49195 | .call_frame = .{ .alignment = .@"16" }, | 49454 | .call_frame = .{ .alignment = .@"16" }, |
| 49196 | .extra_temps = .{ | 49455 | .extra_temps = .{ |
| 49197 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49456 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49198 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 49457 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49199 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, | 49458 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49200 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, | 49459 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49201 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, | 49460 | .unused, |
| 49202 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 49461 | .unused, |
| 49203 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 49462 | .unused, |
| 49204 | .unused, | 49463 | .unused, |
| 49205 | .unused, | 49464 | .unused, |
| 49206 | }, | 49465 | }, |
| 49207 | .dst_temps = .{.mem}, | 49466 | .dst_temps = .{.mem}, |
| 49208 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49467 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49209 | .each = .{ .once = &.{ | 49468 | .each = .{ .once = &.{ |
| 49210 | .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ }, | 49469 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49211 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, | 49470 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| 49212 | .{ ._, ._d, .movsx, .tmp0q, .tmp0d, ._, ._ }, | 49471 | .{ ._, .p_w, .insr, .tmp1x, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49213 | .{ ._, ._ps, .@"and", .src0x, .lea(.tmp1x), ._, ._ }, | 49472 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49214 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, | 49473 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 49215 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 49474 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 49216 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, | 49475 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 49226 | } }, | 49476 | } }, |
| 49227 | }, .{ | 49477 | }, .{ |
| 49228 | .required_features = .{ .@"64bit", .sse, null, null }, | 49478 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 49229 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49479 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49230 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, | 49480 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49231 | .patterns = &.{ | 49481 | .patterns = &.{ |
| 49232 | .{ .src = .{ .to_mem, .none, .none } }, | 49482 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49233 | }, | 49483 | }, |
| 49234 | .call_frame = .{ .alignment = .@"16" }, | 49484 | .call_frame = .{ .alignment = .@"16" }, |
| 49235 | .extra_temps = .{ | 49485 | .extra_temps = .{ |
| 49236 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, | 49486 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49237 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 49487 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49238 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, | 49488 | .{ .type = .f32, .kind = .mem }, |
| 49239 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, | 49489 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49240 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 49490 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49241 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, | 49491 | .unused, |
| 49242 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 49492 | .unused, |
| 49243 | .unused, | 49493 | .unused, |
| 49244 | .unused, | 49494 | .unused, |
| 49245 | }, | 49495 | }, |
| 49246 | .dst_temps = .{.mem}, | 49496 | .dst_temps = .{.mem}, |
| 49247 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49497 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49248 | .each = .{ .once = &.{ | 49498 | .each = .{ .once = &.{ |
| 49249 | .{ ._, ._ss, .mov, .tmp0x, .src0d, ._, ._ }, | 49499 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49250 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, | 49500 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 49251 | .{ ._, ._ps, .@"and", .tmp0x, .lea(.tmp1x), ._, ._ }, | 49501 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49252 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, | 49502 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49253 | .{ ._, ._d, .movsx, .tmp4q, .src0d, ._, ._ }, | 49503 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49254 | .{ ._, ._r, .sa, .tmp4q, .ui(63), ._, ._ }, | 49504 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 49255 | .{ ._, ._, .xor, .tmp1q, .tmp4q, ._, ._ }, | 49505 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 49256 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, | 49506 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._, ._, ._ }, | | |
| 49265 | } }, | 49507 | } }, |
| 49266 | }, .{ | 49508 | }, .{ |
| 49267 | .required_features = .{ .@"64bit", .sse, null, null }, | 49509 | .required_features = .{ .sse, null, null, null }, |
| 49268 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, | 49510 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49269 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .qword, .is = .qword } }}, | 49511 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 49270 | .patterns = &.{ | 49512 | .patterns = &.{ |
| 49271 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49513 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49272 | }, | 49514 | }, |
| 49273 | .call_frame = .{ .alignment = .@"16" }, | 49515 | .call_frame = .{ .alignment = .@"16" }, |
| 49274 | .extra_temps = .{ | 49516 | .extra_temps = .{ |
| 49275 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, | 49517 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49276 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 49518 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49277 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, | 49519 | .{ .type = .f32, .kind = .mem }, |
| 49278 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 49520 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49279 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, | 49521 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49280 | .unused, | 49522 | .unused, |
| 49281 | .unused, | 49523 | .unused, |
| 49282 | .unused, | 49524 | .unused, |
| ... | @@ -49285,48 +49527,53 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49285,48 +49527,53 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49285 | .dst_temps = .{.mem}, | 49527 | .dst_temps = .{.mem}, |
| 49286 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49528 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49287 | .each = .{ .once = &.{ | 49529 | .each = .{ .once = &.{ |
| 49288 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 49530 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 49289 | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, | 49531 | .{ .@"0:", ._, .movzx, .tmp1d, .memsia(.src0w, .@"2", .tmp0, .add_unaligned_size), ._, ._ }, |
| 49290 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ }, | 49532 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49291 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, | 49533 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49292 | .{ ._, ._, .lea, .tmp3p, .memd(.dst0, 16), ._, ._ }, | 49534 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49293 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .dst0, .add_size_div_8), ._, ._ }, | 49535 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 49294 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 49536 | .{ ._, ._c, .in, .tmp0p, .si(1), ._, ._ }, |
| | 49537 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 49295 | } }, | 49538 | } }, |
| 49296 | }, .{ | 49539 | }, .{ |
| 49297 | .required_features = .{ .avx, null, null, null }, | 49540 | .required_features = .{ .f16c, null, null, null }, |
| 49298 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49541 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49299 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, | 49542 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .dword, .is = .word } }}, |
| 49300 | .patterns = &.{ | 49543 | .patterns = &.{ |
| 49301 | .{ .src = .{ .mem, .none, .none } }, | 49544 | .{ .src = .{ .mem, .none, .none } }, |
| 49302 | .{ .src = .{ .to_sse, .none, .none } }, | 49545 | .{ .src = .{ .to_sse, .none, .none } }, |
| 49303 | }, | 49546 | }, |
| 49304 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49547 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 49305 | .each = .{ .once = &.{ | 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 }, | 49554 | .required_features = .{ .f16c, null, null, null }, |
| 49310 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49555 | .src_constraints = .{ .{ .scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49311 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, | 49556 | .dst_constraints = .{.{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 49312 | .patterns = &.{ | 49557 | .patterns = &.{ |
| 49313 | .{ .src = .{ .mem, .none, .none } }, | 49558 | .{ .src = .{ .mem, .none, .none } }, |
| 49314 | .{ .src = .{ .to_sse, .none, .none } }, | 49559 | .{ .src = .{ .to_sse, .none, .none } }, |
| 49315 | }, | 49560 | }, |
| 49316 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49561 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 49317 | .each = .{ .once = &.{ | 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 }, | 49568 | .required_features = .{ .f16c, null, null, null }, |
| 49322 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49569 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49323 | .dst_constraints = .{.{ .signed_int = .byte }}, | 49570 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 49324 | .patterns = &.{ | 49571 | .patterns = &.{ |
| 49325 | .{ .src = .{ .to_mem, .none, .none } }, | 49572 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49326 | }, | 49573 | }, |
| 49327 | .extra_temps = .{ | 49574 | .extra_temps = .{ |
| 49328 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49575 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49329 | .{ .type = .i16, .kind = .mem }, | 49576 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 49330 | .unused, | 49577 | .unused, |
| 49331 | .unused, | 49578 | .unused, |
| 49332 | .unused, | 49579 | .unused, |
| ... | @@ -49335,22 +49582,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49335,22 +49582,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49335 | .unused, | 49582 | .unused, |
| 49336 | .unused, | 49583 | .unused, |
| 49337 | }, | 49584 | }, |
| 49338 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49585 | .dst_temps = .{.mem}, |
| 49339 | .each = .{ .once = &.{ | 49586 | .each = .{ .once = &.{ |
| 49340 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 49587 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49341 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, | 49588 | .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49342 | .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ }, | 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 }, | 49596 | .required_features = .{ .f16c, null, null, null }, |
| 49346 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49597 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49347 | .dst_constraints = .{.{ .unsigned_int = .byte }}, | 49598 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 49348 | .patterns = &.{ | 49599 | .patterns = &.{ |
| 49349 | .{ .src = .{ .to_mem, .none, .none } }, | 49600 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49350 | }, | 49601 | }, |
| 49351 | .extra_temps = .{ | 49602 | .extra_temps = .{ |
| 49352 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49603 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49353 | .{ .type = .i16, .kind = .mem }, | 49604 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 49354 | .unused, | 49605 | .unused, |
| 49355 | .unused, | 49606 | .unused, |
| 49356 | .unused, | 49607 | .unused, |
| ... | @@ -49359,24 +49610,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49359,24 +49610,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49359 | .unused, | 49610 | .unused, |
| 49360 | .unused, | 49611 | .unused, |
| 49361 | }, | 49612 | }, |
| 49362 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49613 | .dst_temps = .{.mem}, |
| 49363 | .each = .{ .once = &.{ | 49614 | .each = .{ .once = &.{ |
| 49364 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 49615 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49365 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, | 49616 | .{ .@"0:", .v_ps, .cvtph2, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49366 | .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ }, | 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 }, | 49624 | .required_features = .{ .avx, null, null, null }, |
| 49370 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49625 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49371 | .dst_constraints = .{.{ .signed_or_exclusive_int = .word }}, | 49626 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 49372 | .patterns = &.{ | 49627 | .patterns = &.{ |
| 49373 | .{ .src = .{ .to_mem, .none, .none } }, | 49628 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49374 | }, | 49629 | }, |
| | 49630 | .call_frame = .{ .alignment = .@"16" }, |
| 49375 | .extra_temps = .{ | 49631 | .extra_temps = .{ |
| 49376 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49632 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49377 | .unused, | 49633 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49378 | .unused, | 49634 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49379 | .unused, | 49635 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49380 | .unused, | 49636 | .unused, |
| 49381 | .unused, | 49637 | .unused, |
| 49382 | .unused, | 49638 | .unused, |
| ... | @@ -49384,22 +49640,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49384,22 +49640,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49384 | .unused, | 49640 | .unused, |
| 49385 | }, | 49641 | }, |
| 49386 | .dst_temps = .{.mem}, | 49642 | .dst_temps = .{.mem}, |
| | 49643 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49387 | .each = .{ .once = &.{ | 49644 | .each = .{ .once = &.{ |
| 49388 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 49645 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49389 | .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ }, | 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 }, | 49654 | .required_features = .{ .sse2, null, null, null }, |
| 49393 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49655 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49394 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, | 49656 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 49395 | .patterns = &.{ | 49657 | .patterns = &.{ |
| 49396 | .{ .src = .{ .to_mem, .none, .none } }, | 49658 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49397 | }, | 49659 | }, |
| | 49660 | .call_frame = .{ .alignment = .@"16" }, |
| 49398 | .extra_temps = .{ | 49661 | .extra_temps = .{ |
| 49399 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49662 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49400 | .unused, | 49663 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49401 | .unused, | 49664 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49402 | .unused, | 49665 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49403 | .unused, | 49666 | .unused, |
| 49404 | .unused, | 49667 | .unused, |
| 49405 | .unused, | 49668 | .unused, |
| ... | @@ -49407,44 +49670,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49407,44 +49670,57 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49407 | .unused, | 49670 | .unused, |
| 49408 | }, | 49671 | }, |
| 49409 | .dst_temps = .{.mem}, | 49672 | .dst_temps = .{.mem}, |
| | 49673 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49410 | .each = .{ .once = &.{ | 49674 | .each = .{ .once = &.{ |
| 49411 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 49675 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49412 | .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ }, | 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 }, | 49684 | .required_features = .{ .sse, null, null, null }, |
| 49416 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49685 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49417 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, | 49686 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 49418 | .patterns = &.{ | 49687 | .patterns = &.{ |
| 49419 | .{ .src = .{ .mem, .none, .none } }, | 49688 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49420 | .{ .src = .{ .to_sse, .none, .none } }, | | |
| 49421 | }, | 49689 | }, |
| 49422 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49690 | .call_frame = .{ .alignment = .@"16" }, |
| 49423 | .each = .{ .once = &.{ | 49691 | .extra_temps = .{ |
| 49424 | .{ ._, .v_, .cvttsd2si, .dst0q, .src0q, ._, ._ }, | 49692 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49425 | } }, | 49693 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49426 | }, .{ | 49694 | .{ .type = .f32, .kind = .mem }, |
| 49427 | .required_features = .{ .@"64bit", .sse2, null, null }, | 49695 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49428 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49696 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49429 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, | 49697 | .unused, |
| 49430 | .patterns = &.{ | 49698 | .unused, |
| 49431 | .{ .src = .{ .mem, .none, .none } }, | 49699 | .unused, |
| 49432 | .{ .src = .{ .to_sse, .none, .none } }, | 49700 | .unused, |
| 49433 | }, | 49701 | }, |
| 49434 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49702 | .dst_temps = .{.mem}, |
| | 49703 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49435 | .each = .{ .once = &.{ | 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 }, | 49715 | .required_features = .{ .f16c, null, null, null }, |
| 49440 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49716 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .qword, .is = .word } }, .any, .any }, |
| 49441 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, | 49717 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }}, |
| 49442 | .patterns = &.{ | 49718 | .patterns = &.{ |
| 49443 | .{ .src = .{ .to_mem, .none, .none } }, | 49719 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49444 | }, | 49720 | }, |
| 49445 | .extra_temps = .{ | 49721 | .extra_temps = .{ |
| 49446 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49722 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49447 | .unused, | 49723 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| 49448 | .unused, | 49724 | .unused, |
| 49449 | .unused, | 49725 | .unused, |
| 49450 | .unused, | 49726 | .unused, |
| ... | @@ -49455,164 +49731,176 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49455,164 +49731,176 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49455 | }, | 49731 | }, |
| 49456 | .dst_temps = .{.mem}, | 49732 | .dst_temps = .{.mem}, |
| 49457 | .each = .{ .once = &.{ | 49733 | .each = .{ .once = &.{ |
| 49458 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 49734 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49459 | .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ }, | 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 }, | 49742 | .required_features = .{ .f16c, null, null, null }, |
| 49463 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49743 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49464 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, | 49744 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49465 | .patterns = &.{ | 49745 | .patterns = &.{ |
| 49466 | .{ .src = .{ .to_sse, .none, .none } }, | 49746 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49467 | }, | 49747 | }, |
| 49468 | .extra_temps = .{ | 49748 | .extra_temps = .{ |
| 49469 | .{ .type = .f64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, | 49749 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49470 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49750 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 49471 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49751 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 49472 | .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } }, | 49752 | .unused, |
| 49473 | .unused, | 49753 | .unused, |
| 49474 | .unused, | 49754 | .unused, |
| 49475 | .unused, | 49755 | .unused, |
| 49476 | .unused, | 49756 | .unused, |
| 49477 | .unused, | 49757 | .unused, |
| 49478 | }, | 49758 | }, |
| 49479 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49759 | .dst_temps = .{.mem}, |
| 49480 | .clobbers = .{ .eflags = true }, | | |
| 49481 | .each = .{ .once = &.{ | 49760 | .each = .{ .once = &.{ |
| 49482 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, | 49761 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49483 | .{ ._, .v_, .cvttsd2si, .tmp2q, .src0d, ._, ._ }, | 49762 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49484 | .{ ._, .v_sd, .sub, .tmp0x, .src0x, .lea(.tmp1q), ._ }, | 49763 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49485 | .{ ._, .v_, .cvttsd2si, .dst0q, .tmp0d, ._, ._ }, | 49764 | .{ ._, .v_ps, .cvtph2, .tmp1x, .tmp1q, ._, ._ }, |
| 49486 | .{ ._, ._, .mov, .tmp1q, .tmp2q, ._, ._ }, | 49765 | .{ ._, .v_, .cvttss2si, .tmp2q, .tmp1x, ._, ._ }, |
| 49487 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, | 49766 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| 49488 | .{ ._, ._, .@"and", .dst0q, .tmp2q, ._, ._ }, | 49767 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49489 | .{ ._, ._, .@"or", .dst0q, .tmp1q, ._, ._ }, | 49768 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49490 | } }, | 49769 | } }, |
| 49491 | }, .{ | 49770 | }, .{ |
| 49492 | .required_features = .{ .@"64bit", .sse2, null, null }, | 49771 | .required_features = .{ .avx, null, null, null }, |
| 49493 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49772 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49494 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, | 49773 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49495 | .patterns = &.{ | 49774 | .patterns = &.{ |
| 49496 | .{ .src = .{ .to_mut_sse, .none, .none } }, | 49775 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49497 | }, | 49776 | }, |
| | 49777 | .call_frame = .{ .alignment = .@"16" }, |
| 49498 | .extra_temps = .{ | 49778 | .extra_temps = .{ |
| 49499 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49779 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49500 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49780 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49501 | .{ .type = .f64, .kind = .{ .@"0x1p63_mem" = .{} } }, | 49781 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49502 | .unused, | 49782 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49503 | .unused, | 49783 | .unused, |
| 49504 | .unused, | 49784 | .unused, |
| 49505 | .unused, | 49785 | .unused, |
| 49506 | .unused, | 49786 | .unused, |
| 49507 | .unused, | 49787 | .unused, |
| 49508 | }, | 49788 | }, |
| 49509 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49789 | .dst_temps = .{.mem}, |
| 49510 | .clobbers = .{ .eflags = true }, | 49790 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49511 | .each = .{ .once = &.{ | 49791 | .each = .{ .once = &.{ |
| 49512 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 49792 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49513 | .{ ._, ._, .cvttsd2si, .tmp1q, .src0d, ._, ._ }, | 49793 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49514 | .{ ._, ._sd, .sub, .src0x, .lea(.tmp0q), ._, ._ }, | 49794 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49515 | .{ ._, ._, .cvttsd2si, .dst0q, .src0d, ._, ._ }, | 49795 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49516 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, | 49796 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 49517 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, | 49797 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49518 | .{ ._, ._, .@"and", .dst0q, .tmp1q, ._, ._ }, | 49798 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49519 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, | | |
| 49520 | } }, | 49799 | } }, |
| 49521 | }, .{ | 49800 | }, .{ |
| 49522 | .required_features = .{ .@"64bit", .x87, null, null }, | 49801 | .required_features = .{ .avx, null, null, null }, |
| 49523 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49802 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49524 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, | 49803 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49525 | .patterns = &.{ | 49804 | .patterns = &.{ |
| 49526 | .{ .src = .{ .to_mem, .none, .none } }, | 49805 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49527 | }, | 49806 | }, |
| | 49807 | .call_frame = .{ .alignment = .@"16" }, |
| 49528 | .extra_temps = .{ | 49808 | .extra_temps = .{ |
| 49529 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 49809 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49530 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, | 49810 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49531 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, | 49811 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } }, |
| 49532 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49812 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 49533 | .{ .type = .i64, .kind = .mem }, | 49813 | .unused, |
| 49534 | .unused, | 49814 | .unused, |
| 49535 | .unused, | 49815 | .unused, |
| 49536 | .unused, | 49816 | .unused, |
| 49537 | .unused, | 49817 | .unused, |
| 49538 | }, | 49818 | }, |
| 49539 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49819 | .dst_temps = .{.mem}, |
| 49540 | .clobbers = .{ .eflags = true }, | 49820 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49541 | .each = .{ .once = &.{ | 49821 | .each = .{ .once = &.{ |
| 49542 | .{ ._, .f_, .ld, .src0q, ._, ._, ._ }, | 49822 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49543 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 49823 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49544 | .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ }, | 49824 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49545 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, | 49825 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 49546 | .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ }, | 49826 | .{ ._, ._, .mov, .memsia(.dst0d, .@"2", .tmp0, .add_unaligned_size), .tmp3d, ._, ._ }, |
| 49547 | .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ }, | 49827 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49548 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, | 49828 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49549 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, | | |
| 49550 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, | | |
| 49551 | .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, | | |
| 49552 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, | | |
| 49553 | } }, | 49829 | } }, |
| 49554 | }, .{ | 49830 | }, .{ |
| 49555 | .required_features = .{ .@"64bit", .sse, null, null }, | 49831 | .required_features = .{ .sse2, null, null, null }, |
| 49556 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49832 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49557 | .dst_constraints = .{.{ .signed_int = .xword }}, | 49833 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49558 | .patterns = &.{ | 49834 | .patterns = &.{ |
| 49559 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49835 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49560 | }, | 49836 | }, |
| 49561 | .call_frame = .{ .alignment = .@"16" }, | 49837 | .call_frame = .{ .alignment = .@"16" }, |
| 49562 | .extra_temps = .{ | 49838 | .extra_temps = .{ |
| 49563 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfti" } } }, | 49839 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49564 | .unused, | 49840 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49565 | .unused, | 49841 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49566 | .unused, | 49842 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49567 | .unused, | 49843 | .unused, |
| 49568 | .unused, | 49844 | .unused, |
| 49569 | .unused, | 49845 | .unused, |
| 49570 | .unused, | 49846 | .unused, |
| 49571 | .unused, | 49847 | .unused, |
| 49572 | }, | 49848 | }, |
| 49573 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 49849 | .dst_temps = .{.mem}, |
| 49574 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49850 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49575 | .each = .{ .once = &.{ | 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 }, | 49861 | .required_features = .{ .sse2, null, null, null }, |
| 49580 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49862 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49581 | .dst_constraints = .{.{ .unsigned_int = .xword }}, | 49863 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49582 | .patterns = &.{ | 49864 | .patterns = &.{ |
| 49583 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49865 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49584 | }, | 49866 | }, |
| 49585 | .call_frame = .{ .alignment = .@"16" }, | 49867 | .call_frame = .{ .alignment = .@"16" }, |
| 49586 | .extra_temps = .{ | 49868 | .extra_temps = .{ |
| 49587 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfti" } } }, | 49869 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49588 | .unused, | 49870 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49589 | .unused, | 49871 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } }, |
| 49590 | .unused, | 49872 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 49591 | .unused, | 49873 | .unused, |
| 49592 | .unused, | 49874 | .unused, |
| 49593 | .unused, | 49875 | .unused, |
| 49594 | .unused, | 49876 | .unused, |
| 49595 | .unused, | 49877 | .unused, |
| 49596 | }, | 49878 | }, |
| 49597 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 49879 | .dst_temps = .{.mem}, |
| 49598 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49880 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49599 | .each = .{ .once = &.{ | 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 }, | 49891 | .required_features = .{ .sse, null, null, null }, |
| 49604 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49892 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49605 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 49893 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49606 | .patterns = &.{ | 49894 | .patterns = &.{ |
| 49607 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49895 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49608 | }, | 49896 | }, |
| 49609 | .call_frame = .{ .alignment = .@"16" }, | 49897 | .call_frame = .{ .alignment = .@"16" }, |
| 49610 | .extra_temps = .{ | 49898 | .extra_temps = .{ |
| 49611 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 49899 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49612 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 49900 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 49613 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixdfei" } } }, | 49901 | .{ .type = .f32, .kind = .mem }, |
| 49614 | .unused, | 49902 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49615 | .unused, | 49903 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfsi" } } }, |
| 49616 | .unused, | 49904 | .unused, |
| 49617 | .unused, | 49905 | .unused, |
| 49618 | .unused, | 49906 | .unused, |
| ... | @@ -49621,24 +49909,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49621,24 +49909,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49621 | .dst_temps = .{.mem}, | 49909 | .dst_temps = .{.mem}, |
| 49622 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49910 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49623 | .each = .{ .once = &.{ | 49911 | .each = .{ .once = &.{ |
| 49624 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 49912 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49625 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 49913 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49626 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 49922 | .required_features = .{ .sse, null, null, null }, |
| 49630 | .src_constraints = .{ .{ .float = .qword }, .any, .any }, | 49923 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49631 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 49924 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 49632 | .patterns = &.{ | 49925 | .patterns = &.{ |
| 49633 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 49926 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49634 | }, | 49927 | }, |
| 49635 | .call_frame = .{ .alignment = .@"16" }, | 49928 | .call_frame = .{ .alignment = .@"16" }, |
| 49636 | .extra_temps = .{ | 49929 | .extra_temps = .{ |
| 49637 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 49930 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49638 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 49931 | .{ .type = .u32, .kind = .{ .reg = .eax } }, |
| 49639 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsdfei" } } }, | 49932 | .{ .type = .f32, .kind = .mem }, |
| 49640 | .unused, | 49933 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49641 | .unused, | 49934 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfsi" } } }, |
| 49642 | .unused, | 49935 | .unused, |
| 49643 | .unused, | 49936 | .unused, |
| 49644 | .unused, | 49937 | .unused, |
| ... | @@ -49647,22 +49940,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49647,22 +49940,26 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49647 | .dst_temps = .{.mem}, | 49940 | .dst_temps = .{.mem}, |
| 49648 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 49941 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49649 | .each = .{ .once = &.{ | 49942 | .each = .{ .once = &.{ |
| 49650 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 49943 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49651 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 49944 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49652 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 49953 | .required_features = .{ .@"64bit", .f16c, null, null }, |
| 49656 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 49954 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49657 | .dst_constraints = .{.{ .signed_int = .byte }}, | 49955 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49658 | .patterns = &.{ | 49956 | .patterns = &.{ |
| 49659 | .{ .src = .{ .mem, .none, .none } }, | 49957 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49660 | .{ .src = .{ .to_x87, .none, .none } }, | | |
| 49661 | }, | 49958 | }, |
| 49662 | .extra_temps = .{ | 49959 | .extra_temps = .{ |
| 49663 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49960 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49664 | .{ .type = .i16, .kind = .mem }, | 49961 | .{ .type = .f32, .kind = .{ .rc = .sse } }, |
| 49665 | .unused, | 49962 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 49666 | .unused, | 49963 | .unused, |
| 49667 | .unused, | 49964 | .unused, |
| 49668 | .unused, | 49965 | .unused, |
| ... | @@ -49670,50 +49967,60 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49670,50 +49967,60 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49670 | .unused, | 49967 | .unused, |
| 49671 | .unused, | 49968 | .unused, |
| 49672 | }, | 49969 | }, |
| 49673 | .dst_temps = .{.{ .rc = .general_purpose }}, | 49970 | .dst_temps = .{.mem}, |
| 49674 | .each = .{ .once = &.{ | 49971 | .each = .{ .once = &.{ |
| 49675 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 49972 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49676 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, | 49973 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49677 | .{ ._, ._, .movsx, .dst0d, .tmp1b, ._, ._ }, | 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 }, | 49982 | .required_features = .{ .avx, null, null, null }, |
| 49681 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 49983 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49682 | .dst_constraints = .{.{ .unsigned_int = .byte }}, | 49984 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49683 | .patterns = &.{ | 49985 | .patterns = &.{ |
| 49684 | .{ .src = .{ .mem, .none, .none } }, | 49986 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49685 | .{ .src = .{ .to_x87, .none, .none } }, | | |
| 49686 | }, | 49987 | }, |
| | 49988 | .call_frame = .{ .alignment = .@"16" }, |
| 49687 | .extra_temps = .{ | 49989 | .extra_temps = .{ |
| 49688 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 49990 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49689 | .{ .type = .i16, .kind = .mem }, | 49991 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49690 | .unused, | 49992 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } }, |
| 49691 | .unused, | 49993 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49692 | .unused, | 49994 | .unused, |
| 49693 | .unused, | 49995 | .unused, |
| 49694 | .unused, | 49996 | .unused, |
| 49695 | .unused, | 49997 | .unused, |
| 49696 | .unused, | 49998 | .unused, |
| 49697 | }, | 49999 | }, |
| 49698 | .dst_temps = .{.{ .rc = .general_purpose }}, | 50000 | .dst_temps = .{.mem}, |
| | 50001 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49699 | .each = .{ .once = &.{ | 50002 | .each = .{ .once = &.{ |
| 49700 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 50003 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49701 | .{ ._, .fi_p, .stt, .tmp1w, ._, ._, ._ }, | 50004 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| 49702 | .{ ._, ._, .movzx, .dst0d, .tmp1b, ._, ._ }, | 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 }, | 50012 | .required_features = .{ .avx, null, null, null }, |
| 49706 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50013 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49707 | .dst_constraints = .{.{ .signed_or_exclusive_int = .word }}, | 50014 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49708 | .patterns = &.{ | 50015 | .patterns = &.{ |
| 49709 | .{ .src = .{ .mem, .none, .none } }, | 50016 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49710 | .{ .src = .{ .to_x87, .none, .none } }, | | |
| 49711 | }, | 50017 | }, |
| | 50018 | .call_frame = .{ .alignment = .@"16" }, |
| 49712 | .extra_temps = .{ | 50019 | .extra_temps = .{ |
| 49713 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 50020 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49714 | .unused, | 50021 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49715 | .unused, | 50022 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } }, |
| 49716 | .unused, | 50023 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49717 | .unused, | 50024 | .unused, |
| 49718 | .unused, | 50025 | .unused, |
| 49719 | .unused, | 50026 | .unused, |
| ... | @@ -49721,23 +50028,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49721,23 +50028,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49721 | .unused, | 50028 | .unused, |
| 49722 | }, | 50029 | }, |
| 49723 | .dst_temps = .{.mem}, | 50030 | .dst_temps = .{.mem}, |
| | 50031 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49724 | .each = .{ .once = &.{ | 50032 | .each = .{ .once = &.{ |
| 49725 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 50033 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49726 | .{ ._, .fi_p, .stt, .dst0w, ._, ._, ._ }, | 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 }, | 50042 | .required_features = .{ .sse2, null, null, null }, |
| 49730 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50043 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49731 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, | 50044 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49732 | .patterns = &.{ | 50045 | .patterns = &.{ |
| 49733 | .{ .src = .{ .mem, .none, .none } }, | 50046 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49734 | .{ .src = .{ .to_x87, .none, .none } }, | | |
| 49735 | }, | 50047 | }, |
| | 50048 | .call_frame = .{ .alignment = .@"16" }, |
| 49736 | .extra_temps = .{ | 50049 | .extra_temps = .{ |
| 49737 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 50050 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49738 | .unused, | 50051 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49739 | .unused, | 50052 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } }, |
| 49740 | .unused, | 50053 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49741 | .unused, | 50054 | .unused, |
| 49742 | .unused, | 50055 | .unused, |
| 49743 | .unused, | 50056 | .unused, |
| ... | @@ -49745,23 +50058,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49745,23 +50058,29 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49745 | .unused, | 50058 | .unused, |
| 49746 | }, | 50059 | }, |
| 49747 | .dst_temps = .{.mem}, | 50060 | .dst_temps = .{.mem}, |
| | 50061 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49748 | .each = .{ .once = &.{ | 50062 | .each = .{ .once = &.{ |
| 49749 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 50063 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49750 | .{ ._, .fi_p, .stt, .dst0d, ._, ._, ._ }, | 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 }, | 50072 | .required_features = .{ .sse2, null, null, null }, |
| 49754 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50073 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49755 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, | 50074 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49756 | .patterns = &.{ | 50075 | .patterns = &.{ |
| 49757 | .{ .src = .{ .mem, .none, .none } }, | 50076 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49758 | .{ .src = .{ .to_x87, .none, .none } }, | | |
| 49759 | }, | 50077 | }, |
| | 50078 | .call_frame = .{ .alignment = .@"16" }, |
| 49760 | .extra_temps = .{ | 50079 | .extra_temps = .{ |
| 49761 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 50080 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49762 | .unused, | 50081 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49763 | .unused, | 50082 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } }, |
| 49764 | .unused, | 50083 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49765 | .unused, | 50084 | .unused, |
| 49766 | .unused, | 50085 | .unused, |
| 49767 | .unused, | 50086 | .unused, |
| ... | @@ -49769,215 +50088,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49769,215 +50088,249 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49769 | .unused, | 50088 | .unused, |
| 49770 | }, | 50089 | }, |
| 49771 | .dst_temps = .{.mem}, | 50090 | .dst_temps = .{.mem}, |
| | 50091 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49772 | .each = .{ .once = &.{ | 50092 | .each = .{ .once = &.{ |
| 49773 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 50093 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49774 | .{ ._, .fi_p, .stt, .dst0q, ._, ._, ._ }, | 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 }, | 50102 | .required_features = .{ .sse, null, null, null }, |
| 49778 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50103 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49779 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, | 50104 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 49780 | .patterns = &.{ | 50105 | .patterns = &.{ |
| 49781 | .{ .src = .{ .mem, .none, .none } }, | 50106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49782 | .{ .src = .{ .to_x87, .none, .none } }, | | |
| 49783 | }, | 50107 | }, |
| | 50108 | .call_frame = .{ .alignment = .@"16" }, |
| 49784 | .extra_temps = .{ | 50109 | .extra_temps = .{ |
| 49785 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, | 50110 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49786 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, | 50111 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 49787 | .{ .type = .f64, .kind = .{ .reg = .st6 } }, | 50112 | .{ .type = .f32, .kind = .mem }, |
| 49788 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 50113 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49789 | .{ .type = .i64, .kind = .mem }, | 50114 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfdi" } } }, |
| 49790 | .unused, | 50115 | .unused, |
| 49791 | .unused, | 50116 | .unused, |
| 49792 | .unused, | 50117 | .unused, |
| 49793 | .unused, | 50118 | .unused, |
| 49794 | }, | 50119 | }, |
| 49795 | .dst_temps = .{.{ .rc = .general_purpose }}, | 50120 | .dst_temps = .{.mem}, |
| 49796 | .clobbers = .{ .eflags = true }, | 50121 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49797 | .each = .{ .once = &.{ | 50122 | .each = .{ .once = &.{ |
| 49798 | .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, | 50123 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49799 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, | 50124 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49800 | .{ ._, .f_, .ld, .tmp3t, ._, ._, ._ }, | 50125 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49801 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, | 50126 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49802 | .{ ._, ._, .mov, .dst0q, .tmp4q, ._, ._ }, | 50127 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, |
| 49803 | .{ ._, .f_, .sub, .lea(.tmp0d), ._, ._, ._ }, | 50128 | .{ ._, ._, .mov, .memsia(.dst0q, .@"4", .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| 49804 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, | 50129 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 49805 | .{ ._, .fi_p, .stt, .tmp4q, ._, ._, ._ }, | 50130 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 49806 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, | | |
| 49807 | .{ ._, ._, .@"and", .dst0q, .tmp4q, ._, ._ }, | | |
| 49808 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, | | |
| 49809 | } }, | 50131 | } }, |
| 49810 | }, .{ | 50132 | }, .{ |
| 49811 | .required_features = .{ .@"64bit", .avx, null, null }, | 50133 | .required_features = .{ .sse, null, null, null }, |
| 49812 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50134 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49813 | .dst_constraints = .{.{ .signed_int = .xword }}, | 50135 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }}, |
| 49814 | .patterns = &.{ | 50136 | .patterns = &.{ |
| 49815 | .{ .src = .{ .to_mem, .none, .none } }, | 50137 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49816 | }, | 50138 | }, |
| 49817 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50139 | .call_frame = .{ .alignment = .@"16" }, |
| 49818 | .extra_temps = .{ | 50140 | .extra_temps = .{ |
| 49819 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50141 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49820 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50142 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49821 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, | 50143 | .{ .type = .f32, .kind = .mem }, |
| 49822 | .unused, | 50144 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49823 | .unused, | 50145 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfdi" } } }, |
| 49824 | .unused, | 50146 | .unused, |
| 49825 | .unused, | 50147 | .unused, |
| 49826 | .unused, | 50148 | .unused, |
| 49827 | .unused, | 50149 | .unused, |
| 49828 | }, | 50150 | }, |
| 49829 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 50151 | .dst_temps = .{.mem}, |
| 49830 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50152 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49831 | .each = .{ .once = &.{ | 50153 | .each = .{ .once = &.{ |
| 49832 | .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, | 50154 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49833 | .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, | 50155 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49834 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50164 | .required_features = .{ .avx, null, null, null }, |
| 49838 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50165 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49839 | .dst_constraints = .{.{ .signed_int = .xword }}, | 50166 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 49840 | .patterns = &.{ | 50167 | .patterns = &.{ |
| 49841 | .{ .src = .{ .to_mem, .none, .none } }, | 50168 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49842 | }, | 50169 | }, |
| 49843 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50170 | .call_frame = .{ .alignment = .@"16" }, |
| 49844 | .extra_temps = .{ | 50171 | .extra_temps = .{ |
| 49845 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50172 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49846 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50173 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49847 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, | 50174 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } }, |
| 49848 | .unused, | 50175 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49849 | .unused, | 50176 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49850 | .unused, | 50177 | .unused, |
| 49851 | .unused, | 50178 | .unused, |
| 49852 | .unused, | 50179 | .unused, |
| 49853 | .unused, | 50180 | .unused, |
| 49854 | }, | 50181 | }, |
| 49855 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 50182 | .dst_temps = .{.mem}, |
| 49856 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50183 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49857 | .each = .{ .once = &.{ | 50184 | .each = .{ .once = &.{ |
| 49858 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, | 50185 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49859 | .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, | 50186 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| | 50187 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49860 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50195 | .required_features = .{ .avx, null, null, null }, |
| 49864 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50196 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49865 | .dst_constraints = .{.{ .signed_int = .xword }}, | 50197 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 49866 | .patterns = &.{ | 50198 | .patterns = &.{ |
| 49867 | .{ .src = .{ .to_mem, .none, .none } }, | 50199 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49868 | }, | 50200 | }, |
| 49869 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50201 | .call_frame = .{ .alignment = .@"16" }, |
| 49870 | .extra_temps = .{ | 50202 | .extra_temps = .{ |
| 49871 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49872 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50204 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49873 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfti" } } }, | 50205 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } }, |
| 49874 | .unused, | 50206 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49875 | .unused, | 50207 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 49876 | .unused, | 50208 | .unused, |
| 49877 | .unused, | 50209 | .unused, |
| 49878 | .unused, | 50210 | .unused, |
| 49879 | .unused, | 50211 | .unused, |
| 49880 | }, | 50212 | }, |
| 49881 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 50213 | .dst_temps = .{.mem}, |
| 49882 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50214 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49883 | .each = .{ .once = &.{ | 50215 | .each = .{ .once = &.{ |
| 49884 | .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, | 50216 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49885 | .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ }, | 50217 | .{ .@"0:", .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| | 50218 | .{ ._, .vp_w, .insr, .tmp1x, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) }, |
| 49886 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50226 | .required_features = .{ .sse2, null, null, null }, |
| 49890 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50227 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49891 | .dst_constraints = .{.{ .unsigned_int = .xword }}, | 50228 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 49892 | .patterns = &.{ | 50229 | .patterns = &.{ |
| 49893 | .{ .src = .{ .to_mem, .none, .none } }, | 50230 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49894 | }, | 50231 | }, |
| 49895 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50232 | .call_frame = .{ .alignment = .@"16" }, |
| 49896 | .extra_temps = .{ | 50233 | .extra_temps = .{ |
| 49897 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50234 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49898 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50235 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49899 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, | 50236 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } }, |
| 49900 | .unused, | 50237 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49901 | .unused, | 50238 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49902 | .unused, | 50239 | .unused, |
| 49903 | .unused, | 50240 | .unused, |
| 49904 | .unused, | 50241 | .unused, |
| 49905 | .unused, | 50242 | .unused, |
| 49906 | }, | 50243 | }, |
| 49907 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 50244 | .dst_temps = .{.mem}, |
| 49908 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50245 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49909 | .each = .{ .once = &.{ | 50246 | .each = .{ .once = &.{ |
| 49910 | .{ ._, .v_dqa, .mov, .tmp0x, .src0x, ._, ._ }, | 50247 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49911 | .{ ._, .v_dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, | 50248 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 50249 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49912 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50257 | .required_features = .{ .sse2, null, null, null }, |
| 49916 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50258 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49917 | .dst_constraints = .{.{ .unsigned_int = .xword }}, | 50259 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 49918 | .patterns = &.{ | 50260 | .patterns = &.{ |
| 49919 | .{ .src = .{ .to_mem, .none, .none } }, | 50261 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49920 | }, | 50262 | }, |
| 49921 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50263 | .call_frame = .{ .alignment = .@"16" }, |
| 49922 | .extra_temps = .{ | 50264 | .extra_temps = .{ |
| 49923 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50265 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49924 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50266 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49925 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, | 50267 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } }, |
| 49926 | .unused, | 50268 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49927 | .unused, | 50269 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 49928 | .unused, | 50270 | .unused, |
| 49929 | .unused, | 50271 | .unused, |
| 49930 | .unused, | 50272 | .unused, |
| 49931 | .unused, | 50273 | .unused, |
| 49932 | }, | 50274 | }, |
| 49933 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 50275 | .dst_temps = .{.mem}, |
| 49934 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50276 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49935 | .each = .{ .once = &.{ | 50277 | .each = .{ .once = &.{ |
| 49936 | .{ ._, ._dqa, .mov, .tmp0x, .src0x, ._, ._ }, | 50278 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49937 | .{ ._, ._dqa, .mov, .tmp1x, .tmp0x, ._, ._ }, | 50279 | .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 50280 | .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ }, |
| 49938 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50288 | .required_features = .{ .sse, null, null, null }, |
| 49942 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50289 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49943 | .dst_constraints = .{.{ .unsigned_int = .xword }}, | 50290 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }}, |
| 49944 | .patterns = &.{ | 50291 | .patterns = &.{ |
| 49945 | .{ .src = .{ .to_mem, .none, .none } }, | 50292 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49946 | }, | 50293 | }, |
| 49947 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50294 | .call_frame = .{ .alignment = .@"16" }, |
| 49948 | .extra_temps = .{ | 50295 | .extra_temps = .{ |
| 49949 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50296 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49950 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50297 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49951 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfti" } } }, | 50298 | .{ .type = .f32, .kind = .mem }, |
| 49952 | .unused, | 50299 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49953 | .unused, | 50300 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfti" } } }, |
| 49954 | .unused, | 50301 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| 49955 | .unused, | 50302 | .unused, |
| 49956 | .unused, | 50303 | .unused, |
| 49957 | .unused, | 50304 | .unused, |
| 49958 | }, | 50305 | }, |
| 49959 | .dst_temps = .{.{ .reg_pair = .{ .rax, .rdx } }}, | 50306 | .dst_temps = .{.mem}, |
| 49960 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50307 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49961 | .each = .{ .once = &.{ | 50308 | .each = .{ .once = &.{ |
| 49962 | .{ ._, ._ps, .mova, .tmp0x, .src0x, ._, ._ }, | 50309 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49963 | .{ ._, ._ps, .mova, .tmp1x, .tmp0x, ._, ._ }, | 50310 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49964 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50320 | .required_features = .{ .sse, null, null, null }, |
| 49968 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50321 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49969 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 50322 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }}, |
| 49970 | .patterns = &.{ | 50323 | .patterns = &.{ |
| 49971 | .{ .src = .{ .to_mem, .none, .none } }, | 50324 | .{ .src = .{ .to_mem, .none, .none } }, |
| 49972 | }, | 50325 | }, |
| 49973 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50326 | .call_frame = .{ .alignment = .@"16" }, |
| 49974 | .extra_temps = .{ | 50327 | .extra_temps = .{ |
| 49975 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50328 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 49976 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50329 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 49977 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50330 | .{ .type = .f32, .kind = .mem }, |
| 49978 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50331 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 49979 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, | 50332 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfti" } } }, |
| 49980 | .unused, | 50333 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| 49981 | .unused, | 50334 | .unused, |
| 49982 | .unused, | 50335 | .unused, |
| 49983 | .unused, | 50336 | .unused, |
| ... | @@ -49985,27 +50338,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -49985,27 +50338,31 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 49985 | .dst_temps = .{.mem}, | 50338 | .dst_temps = .{.mem}, |
| 49986 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50339 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 49987 | .each = .{ .once = &.{ | 50340 | .each = .{ .once = &.{ |
| 49988 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50341 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 49989 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50342 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 49990 | .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ }, | 50343 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| 49991 | .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, | 50344 | .{ ._, ._ss, .mov, .tmp3x, .tmp2d, ._, ._ }, |
| 49992 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 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 }, | 50352 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 49996 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50353 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 49997 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 50354 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 49998 | .patterns = &.{ | 50355 | .patterns = &.{ |
| 49999 | .{ .src = .{ .to_mem, .none, .none } }, | 50356 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50000 | }, | 50357 | }, |
| 50001 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50358 | .call_frame = .{ .alignment = .@"16" }, |
| 50002 | .extra_temps = .{ | 50359 | .extra_temps = .{ |
| | 50360 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 50361 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50003 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50362 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50004 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50363 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50005 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50364 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50006 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50365 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfei" } } }, |
| 50007 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, | | |
| 50008 | .unused, | | |
| 50009 | .unused, | 50366 | .unused, |
| 50010 | .unused, | 50367 | .unused, |
| 50011 | .unused, | 50368 | .unused, |
| ... | @@ -50013,27 +50370,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50013,27 +50370,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50013 | .dst_temps = .{.mem}, | 50370 | .dst_temps = .{.mem}, |
| 50014 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50371 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50015 | .each = .{ .once = &.{ | 50372 | .each = .{ .once = &.{ |
| 50016 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50373 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50017 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50374 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50018 | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, | 50375 | .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, |
| 50019 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, | 50376 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50020 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 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 }, | 50385 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50024 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50386 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50025 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 50387 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50026 | .patterns = &.{ | 50388 | .patterns = &.{ |
| 50027 | .{ .src = .{ .to_mem, .none, .none } }, | 50389 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50028 | }, | 50390 | }, |
| 50029 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50391 | .call_frame = .{ .alignment = .@"16" }, |
| 50030 | .extra_temps = .{ | 50392 | .extra_temps = .{ |
| | 50393 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 50394 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50031 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50395 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50032 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50396 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50033 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50397 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50034 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50398 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfei" } } }, |
| 50035 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixxfei" } } }, | | |
| 50036 | .unused, | | |
| 50037 | .unused, | 50399 | .unused, |
| 50038 | .unused, | 50400 | .unused, |
| 50039 | .unused, | 50401 | .unused, |
| ... | @@ -50041,27 +50403,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50041,27 +50403,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50041 | .dst_temps = .{.mem}, | 50403 | .dst_temps = .{.mem}, |
| 50042 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50404 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50043 | .each = .{ .once = &.{ | 50405 | .each = .{ .once = &.{ |
| 50044 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50406 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50045 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50407 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50046 | .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ }, | 50408 | .{ .@"0:", .v_ps, .xor, .tmp4x, .tmp4x, .tmp4x, ._ }, |
| 50047 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 50409 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50048 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 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 }, | 50418 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 50052 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50419 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50053 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 50420 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50054 | .patterns = &.{ | 50421 | .patterns = &.{ |
| 50055 | .{ .src = .{ .to_mem, .none, .none } }, | 50422 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50056 | }, | 50423 | }, |
| 50057 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50424 | .call_frame = .{ .alignment = .@"16" }, |
| 50058 | .extra_temps = .{ | 50425 | .extra_temps = .{ |
| | 50426 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 50427 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50059 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50428 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50060 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50429 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50061 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50430 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50062 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50431 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfei" } } }, |
| 50063 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, | | |
| 50064 | .unused, | | |
| 50065 | .unused, | 50432 | .unused, |
| 50066 | .unused, | 50433 | .unused, |
| 50067 | .unused, | 50434 | .unused, |
| ... | @@ -50069,27 +50436,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50069,27 +50436,32 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50069 | .dst_temps = .{.mem}, | 50436 | .dst_temps = .{.mem}, |
| 50070 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50437 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50071 | .each = .{ .once = &.{ | 50438 | .each = .{ .once = &.{ |
| 50072 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50439 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50073 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50440 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50074 | .{ ._, .v_dqa, .mov, .tmp2x, .src0x, ._, ._ }, | 50441 | .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 50075 | .{ ._, .v_dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, | 50442 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50076 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 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 | .required_features = .{ .@"64bit", .sse2, null, null }, | 50451 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 50080 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50452 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50081 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 50453 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50082 | .patterns = &.{ | 50454 | .patterns = &.{ |
| 50083 | .{ .src = .{ .to_mem, .none, .none } }, | 50455 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50084 | }, | 50456 | }, |
| 50085 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50457 | .call_frame = .{ .alignment = .@"16" }, |
| 50086 | .extra_temps = .{ | 50458 | .extra_temps = .{ |
| | 50459 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 50460 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50087 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50461 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50088 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50462 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50089 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50463 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50090 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50464 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfei" } } }, |
| 50091 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, | | |
| 50092 | .unused, | | |
| 50093 | .unused, | 50465 | .unused, |
| 50094 | .unused, | 50466 | .unused, |
| 50095 | .unused, | 50467 | .unused, |
| ... | @@ -50097,124 +50469,174 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50097,124 +50469,174 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50097 | .dst_temps = .{.mem}, | 50469 | .dst_temps = .{.mem}, |
| 50098 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50470 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50099 | .each = .{ .once = &.{ | 50471 | .each = .{ .once = &.{ |
| 50100 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50472 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50101 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50473 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50102 | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, | 50474 | .{ .@"0:", ._ps, .xor, .tmp4x, .tmp4x, ._, ._ }, |
| 50103 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, | 50475 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50104 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 50484 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50108 | .src_constraints = .{ .{ .float = .tbyte }, .any, .any }, | 50485 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50109 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 50486 | .dst_constraints = .{.{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }}, |
| 50110 | .patterns = &.{ | 50487 | .patterns = &.{ |
| 50111 | .{ .src = .{ .to_mem, .none, .none } }, | 50488 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50112 | }, | 50489 | }, |
| 50113 | .call_frame = .{ .size = 16, .alignment = .@"16" }, | 50490 | .call_frame = .{ .alignment = .@"16" }, |
| 50114 | .extra_temps = .{ | 50491 | .extra_temps = .{ |
| | 50492 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 50493 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50115 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50494 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50116 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50495 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50117 | .{ .type = .f80, .kind = .{ .reg = .xmm0 } }, | 50496 | .{ .type = .f32, .kind = .mem }, |
| 50118 | .{ .type = .f80, .kind = .{ .frame = .call_frame } }, | 50497 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50119 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunsxfei" } } }, | 50498 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixhfei" } } }, |
| 50120 | .unused, | | |
| 50121 | .unused, | | |
| 50122 | .unused, | 50499 | .unused, |
| 50123 | .unused, | 50500 | .unused, |
| 50124 | }, | 50501 | }, |
| 50125 | .dst_temps = .{.mem}, | 50502 | .dst_temps = .{.mem}, |
| 50126 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50503 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50127 | .each = .{ .once = &.{ | 50504 | .each = .{ .once = &.{ |
| 50128 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50505 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50129 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50506 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50130 | .{ ._, ._ps, .mova, .tmp2x, .src0x, ._, ._ }, | 50507 | .{ .@"0:", ._, .movzx, .tmp3d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 50131 | .{ ._, ._ps, .mova, .tmp3x, .tmp2x, ._, ._ }, | 50508 | .{ ._, ._, .mov, .tmp2p, .tmp1p, ._, ._ }, |
| 50132 | .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, | 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 }, | 50518 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50136 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50519 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50137 | .dst_constraints = .{.{ .signed_int = .dword }}, | 50520 | .dst_constraints = .{.{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, |
| 50138 | .patterns = &.{ | 50521 | .patterns = &.{ |
| 50139 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 50522 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50140 | }, | 50523 | }, |
| 50141 | .call_frame = .{ .alignment = .@"16" }, | 50524 | .call_frame = .{ .alignment = .@"16" }, |
| 50142 | .extra_temps = .{ | 50525 | .extra_temps = .{ |
| 50143 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfsi" } } }, | 50526 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50144 | .unused, | 50527 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50145 | .unused, | 50528 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50146 | .unused, | 50529 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50147 | .unused, | 50530 | .{ .type = .f32, .kind = .mem }, |
| 50148 | .unused, | 50531 | .{ .type = .f16, .kind = .{ .reg = .xmm0 } }, |
| 50149 | .unused, | 50532 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunshfei" } } }, |
| 50150 | .unused, | 50533 | .unused, |
| 50151 | .unused, | 50534 | .unused, |
| 50152 | }, | 50535 | }, |
| 50153 | .dst_temps = .{.{ .reg = .eax }}, | 50536 | .dst_temps = .{.mem}, |
| 50154 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50537 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50155 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse, null, null, null }, | 50564 | .required_features = .{ .sse, null, null, null }, |
| 50160 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50565 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50161 | .dst_constraints = .{.{ .unsigned_int = .dword }}, | 50566 | .dst_constraints = .{.{ .signed_or_exclusive_int = .dword }}, |
| 50162 | .patterns = &.{ | 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" }, | 50571 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50166 | .extra_temps = .{ | 50572 | .each = .{ .once = &.{ |
| 50167 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfsi" } } }, | 50573 | .{ ._, ._, .cvttss2si, .dst0d, .src0d, ._, ._ }, |
| 50168 | .unused, | 50574 | } }, |
| 50169 | .unused, | 50575 | }, .{ |
| 50170 | .unused, | 50576 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50171 | .unused, | 50577 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50172 | .unused, | 50578 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 50173 | .unused, | 50579 | .patterns = &.{ |
| 50174 | .unused, | 50580 | .{ .src = .{ .mem, .none, .none } }, |
| 50175 | .unused, | 50581 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50176 | }, | 50582 | }, |
| 50177 | .dst_temps = .{.{ .reg = .eax }}, | 50583 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50178 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 50179 | .each = .{ .once = &.{ | 50584 | .each = .{ .once = &.{ |
| 50180 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 50585 | .{ ._, .v_, .cvttss2si, .dst0q, .src0d, ._, ._ }, |
| 50181 | } }, | 50586 | } }, |
| 50182 | }, .{ | 50587 | }, .{ |
| 50183 | .required_features = .{ .@"64bit", .sse, null, null }, | 50588 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50184 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50589 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50185 | .dst_constraints = .{.{ .signed_int = .qword }}, | 50590 | .dst_constraints = .{.{ .signed_or_exclusive_int = .qword }}, |
| 50186 | .patterns = &.{ | 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 | .extra_temps = .{ | 50606 | .extra_temps = .{ |
| 50191 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfdi" } } }, | 50607 | .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, |
| 50192 | .unused, | 50608 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50193 | .unused, | 50609 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50194 | .unused, | 50610 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 50195 | .unused, | 50611 | .unused, |
| 50196 | .unused, | 50612 | .unused, |
| 50197 | .unused, | 50613 | .unused, |
| 50198 | .unused, | 50614 | .unused, |
| 50199 | .unused, | 50615 | .unused, |
| 50200 | }, | 50616 | }, |
| 50201 | .dst_temps = .{.{ .reg = .rax }}, | 50617 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50202 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50618 | .clobbers = .{ .eflags = true }, |
| 50203 | .each = .{ .once = &.{ | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 50630 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50208 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50631 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50209 | .dst_constraints = .{.{ .unsigned_int = .qword }}, | 50632 | .dst_constraints = .{.{ .exact_unsigned_int = 64 }}, |
| 50210 | .patterns = &.{ | 50633 | .patterns = &.{ |
| 50211 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 50634 | .{ .src = .{ .to_mut_sse, .none, .none } }, |
| 50212 | }, | 50635 | }, |
| 50213 | .call_frame = .{ .alignment = .@"16" }, | | |
| 50214 | .extra_temps = .{ | 50636 | .extra_temps = .{ |
| 50215 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfdi" } } }, | 50637 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50216 | .unused, | 50638 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 50217 | .unused, | 50639 | .{ .type = .f32, .kind = .{ .@"0x1p63_mem" = .{} } }, |
| 50218 | .unused, | 50640 | .unused, |
| 50219 | .unused, | 50641 | .unused, |
| 50220 | .unused, | 50642 | .unused, |
| ... | @@ -50222,21 +50644,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50222,21 +50644,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50222 | .unused, | 50644 | .unused, |
| 50223 | .unused, | 50645 | .unused, |
| 50224 | }, | 50646 | }, |
| 50225 | .dst_temps = .{.{ .reg = .rax }}, | 50647 | .dst_temps = .{.{ .rc = .general_purpose }}, |
| 50226 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50648 | .clobbers = .{ .eflags = true }, |
| 50227 | .each = .{ .once = &.{ | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 50660 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50232 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50661 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50233 | .dst_constraints = .{.{ .signed_int = .xword }}, | 50662 | .dst_constraints = .{.{ .signed_int = .xword }}, |
| 50234 | .patterns = &.{ | 50663 | .patterns = &.{ |
| 50235 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 50664 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50236 | }, | 50665 | }, |
| 50237 | .call_frame = .{ .alignment = .@"16" }, | 50666 | .call_frame = .{ .alignment = .@"16" }, |
| 50238 | .extra_temps = .{ | 50667 | .extra_temps = .{ |
| 50239 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfti" } } }, | 50668 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfti" } } }, |
| 50240 | .unused, | 50669 | .unused, |
| 50241 | .unused, | 50670 | .unused, |
| 50242 | .unused, | 50671 | .unused, |
| ... | @@ -50253,14 +50682,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50253,14 +50682,14 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50253 | } }, | 50682 | } }, |
| 50254 | }, .{ | 50683 | }, .{ |
| 50255 | .required_features = .{ .@"64bit", .sse, null, null }, | 50684 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50256 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50685 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50257 | .dst_constraints = .{.{ .unsigned_int = .xword }}, | 50686 | .dst_constraints = .{.{ .unsigned_int = .xword }}, |
| 50258 | .patterns = &.{ | 50687 | .patterns = &.{ |
| 50259 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 50688 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50260 | }, | 50689 | }, |
| 50261 | .call_frame = .{ .alignment = .@"16" }, | 50690 | .call_frame = .{ .alignment = .@"16" }, |
| 50262 | .extra_temps = .{ | 50691 | .extra_temps = .{ |
| 50263 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfti" } } }, | 50692 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50264 | .unused, | 50693 | .unused, |
| 50265 | .unused, | 50694 | .unused, |
| 50266 | .unused, | 50695 | .unused, |
| ... | @@ -50276,110 +50705,163 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50276,110 +50705,163 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50276 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 50705 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50277 | } }, | 50706 | } }, |
| 50278 | }, .{ | 50707 | }, .{ |
| 50279 | .required_features = .{ .@"64bit", .sse, null, null }, | 50708 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 50280 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50709 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50281 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }}, | 50710 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 50282 | .patterns = &.{ | 50711 | .patterns = &.{ |
| 50283 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 50712 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50284 | }, | 50713 | }, |
| 50285 | .call_frame = .{ .alignment = .@"16" }, | 50714 | .call_frame = .{ .alignment = .@"16" }, |
| 50286 | .extra_temps = .{ | 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 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50721 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50288 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50722 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 50289 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixtfei" } } }, | | |
| 50290 | .unused, | | |
| 50291 | .unused, | | |
| 50292 | .unused, | | |
| 50293 | .unused, | | |
| 50294 | .unused, | 50723 | .unused, |
| 50295 | .unused, | 50724 | .unused, |
| 50296 | }, | 50725 | }, |
| 50297 | .dst_temps = .{.mem}, | 50726 | .dst_temps = .{.mem}, |
| 50298 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50727 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50299 | .each = .{ .once = &.{ | 50728 | .each = .{ .once = &.{ |
| 50300 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50729 | .{ ._, .v_d, .mov, .tmp0d, .src0x, ._, ._ }, |
| 50301 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50730 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 50302 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 50747 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 50306 | .src_constraints = .{ .{ .float = .xword }, .any, .any }, | 50748 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50307 | .dst_constraints = .{.{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }}, | 50749 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 50308 | .patterns = &.{ | 50750 | .patterns = &.{ |
| 50309 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, | 50751 | .{ .src = .{ .{ .to_reg = .xmm0 }, .none, .none } }, |
| 50310 | }, | 50752 | }, |
| 50311 | .call_frame = .{ .alignment = .@"16" }, | 50753 | .call_frame = .{ .alignment = .@"16" }, |
| 50312 | .extra_temps = .{ | 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 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 50760 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50314 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 50761 | .{ .type = .u32, .kind = .{ .reg = .ecx } }, |
| 50315 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunstfei" } } }, | | |
| 50316 | .unused, | | |
| 50317 | .unused, | | |
| 50318 | .unused, | | |
| 50319 | .unused, | | |
| 50320 | .unused, | 50762 | .unused, |
| 50321 | .unused, | 50763 | .unused, |
| 50322 | }, | 50764 | }, |
| 50323 | .dst_temps = .{.mem}, | 50765 | .dst_temps = .{.mem}, |
| 50324 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 50766 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50325 | .each = .{ .once = &.{ | 50767 | .each = .{ .once = &.{ |
| 50326 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, | 50768 | .{ ._, ._d, .mov, .tmp0d, .src0x, ._, ._ }, |
| 50327 | .{ ._, ._, .mov, .tmp1d, .sa(.dst0, .add_8_size), ._, ._ }, | 50769 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, |
| 50328 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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) { | 50785 | }, .{ |
| 50331 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 50786 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50332 | @tagName(air_tag), | 50787 | .src_constraints = .{ .{ .float = .dword }, .any, .any }, |
| 50333 | ty_op.ty.toType().fmt(pt), | 50788 | .dst_constraints = .{.{ .remainder_signed_int = .{ .of = .qword, .is = .qword } }}, |
| 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 }}, | | |
| 50350 | .patterns = &.{ | 50789 | .patterns = &.{ |
| 50351 | .{ .src = .{ .mem, .none, .none } }, | 50790 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50352 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50353 | }, | 50791 | }, |
| | 50792 | .call_frame = .{ .alignment = .@"16" }, |
| 50354 | .extra_temps = .{ | 50793 | .extra_temps = .{ |
| 50355 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 50794 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 50356 | .unused, | 50795 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 50357 | .unused, | 50796 | .{ .type = .vector_4_f32, .kind = .{ .smax_mem = .{} } }, |
| 50358 | .unused, | 50797 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixunssfti" } } }, |
| 50359 | .unused, | 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 | .unused, | 50838 | .unused, |
| 50361 | .unused, | 50839 | .unused, |
| 50362 | .unused, | 50840 | .unused, |
| 50363 | .unused, | 50841 | .unused, |
| 50364 | }, | 50842 | }, |
| 50365 | .dst_temps = .{.{ .rc = .sse }}, | 50843 | .dst_temps = .{.mem}, |
| | 50844 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50366 | .each = .{ .once = &.{ | 50845 | .each = .{ .once = &.{ |
| 50367 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 50846 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 50368 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 50847 | .{ ._, ._, .mov, .dst0q, .tmp1q, ._, ._ }, |
| 50369 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 50848 | .{ ._, ._, .mov, .memd(.dst0q, 8), .tmp2q, ._, ._ }, |
| 50370 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 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 }, | 50855 | .required_features = .{ .avx, null, null, null }, |
| 50374 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 50856 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50375 | .dst_constraints = .{.{ .float = .word }}, | 50857 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50376 | .patterns = &.{ | 50858 | .patterns = &.{ |
| 50377 | .{ .src = .{ .mem, .none, .none } }, | 50859 | .{ .src = .{ .mem, .none, .none } }, |
| 50378 | .{ .src = .{ .to_gpr, .none, .none } }, | 50860 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50379 | }, | 50861 | }, |
| 50380 | .extra_temps = .{ | 50862 | .extra_temps = .{ |
| 50381 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 50863 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50382 | .unused, | 50864 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 50383 | .unused, | 50865 | .unused, |
| 50384 | .unused, | 50866 | .unused, |
| 50385 | .unused, | 50867 | .unused, |
| ... | @@ -50388,24 +50870,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50388,24 +50870,23 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50388 | .unused, | 50870 | .unused, |
| 50389 | .unused, | 50871 | .unused, |
| 50390 | }, | 50872 | }, |
| 50391 | .dst_temps = .{.{ .rc = .sse }}, | 50873 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 50392 | .each = .{ .once = &.{ | 50874 | .each = .{ .once = &.{ |
| 50393 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 50875 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50394 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 50876 | .{ ._, .v_, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 50395 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 50877 | .{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| 50396 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | | |
| 50397 | } }, | 50878 | } }, |
| 50398 | }, .{ | 50879 | }, .{ |
| 50399 | .required_features = .{ .f16c, null, null, null }, | 50880 | .required_features = .{ .ssse3, null, null, null }, |
| 50400 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 50881 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50401 | .dst_constraints = .{.{ .float = .word }}, | 50882 | .dst_constraints = .{.{ .scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50402 | .patterns = &.{ | 50883 | .patterns = &.{ |
| 50403 | .{ .src = .{ .mem, .none, .none } }, | 50884 | .{ .src = .{ .mem, .none, .none } }, |
| 50404 | .{ .src = .{ .to_gpr, .none, .none } }, | 50885 | .{ .src = .{ .to_sse, .none, .none } }, |
| 50405 | }, | 50886 | }, |
| 50406 | .extra_temps = .{ | 50887 | .extra_temps = .{ |
| 50407 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 50888 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50408 | .unused, | 50889 | .{ .type = .vector_16_u8, .kind = .{ .pshufb_cm_mem = .{ .from = .dword, .to = .byte } } }, |
| 50409 | .unused, | 50890 | .unused, |
| 50410 | .unused, | 50891 | .unused, |
| 50411 | .unused, | 50892 | .unused, |
| ... | @@ -50414,64 +50895,106 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50414,64 +50895,106 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50414 | .unused, | 50895 | .unused, |
| 50415 | .unused, | 50896 | .unused, |
| 50416 | }, | 50897 | }, |
| 50417 | .dst_temps = .{.{ .rc = .sse }}, | 50898 | .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, |
| 50418 | .each = .{ .once = &.{ | 50899 | .each = .{ .once = &.{ |
| 50419 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 50900 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50420 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 50901 | .{ ._, ._, .cvttps2dq, .dst0x, .src0x, ._, ._ }, |
| 50421 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 50902 | .{ ._, .p_b, .shuf, .dst0x, .lea(.tmp0x), ._, ._ }, |
| 50422 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | | |
| 50423 | } }, | 50903 | } }, |
| 50424 | }, .{ | 50904 | }, .{ |
| 50425 | .required_features = .{ .f16c, null, null, null }, | 50905 | .required_features = .{ .avx, null, null, null }, |
| 50426 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 50906 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50427 | .dst_constraints = .{.{ .float = .word }}, | 50907 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .dword, .is = .byte } }}, |
| 50428 | .patterns = &.{ | 50908 | .patterns = &.{ |
| 50429 | .{ .src = .{ .mem, .none, .none } }, | 50909 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50430 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50431 | }, | 50910 | }, |
| 50432 | .extra_temps = .{ | 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 | .unused, | 50918 | .unused, |
| 50435 | .unused, | 50919 | .unused, |
| 50436 | .unused, | 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 | .unused, | 50945 | .unused, |
| 50438 | .unused, | 50946 | .unused, |
| 50439 | .unused, | 50947 | .unused, |
| 50440 | .unused, | 50948 | .unused, |
| 50441 | .unused, | 50949 | .unused, |
| 50442 | }, | 50950 | }, |
| 50443 | .dst_temps = .{.{ .rc = .sse }}, | 50951 | .dst_temps = .{.mem}, |
| 50444 | .each = .{ .once = &.{ | 50952 | .each = .{ .once = &.{ |
| 50445 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 50953 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| 50446 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 50954 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| 50447 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 50955 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50448 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 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 }, | 50963 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 50452 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 50964 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50453 | .dst_constraints = .{.{ .float = .word }}, | 50965 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50454 | .patterns = &.{ | 50966 | .patterns = &.{ |
| 50455 | .{ .src = .{ .mem, .none, .none } }, | 50967 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50456 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 50981 | .each = .{ .once = &.{ |
| 50460 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 50982 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50461 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, | 50983 | .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50462 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 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 }, | 50989 | .required_features = .{ .sse, null, null, null }, |
| 50466 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 50990 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50467 | .dst_constraints = .{.{ .float = .word }}, | 50991 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50468 | .patterns = &.{ | 50992 | .patterns = &.{ |
| 50469 | .{ .src = .{ .mem, .none, .none } }, | 50993 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50470 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50471 | }, | 50994 | }, |
| 50472 | .extra_temps = .{ | 50995 | .extra_temps = .{ |
| 50473 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 50996 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50474 | .unused, | 50997 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 50475 | .unused, | 50998 | .unused, |
| 50476 | .unused, | 50999 | .unused, |
| 50477 | .unused, | 51000 | .unused, |
| ... | @@ -50480,97 +51003,192 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50480,97 +51003,192 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50480 | .unused, | 51003 | .unused, |
| 50481 | .unused, | 51004 | .unused, |
| 50482 | }, | 51005 | }, |
| 50483 | .dst_temps = .{.{ .rc = .sse }}, | 51006 | .dst_temps = .{.mem}, |
| 50484 | .each = .{ .once = &.{ | 51007 | .each = .{ .once = &.{ |
| 50485 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 51008 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50486 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 51009 | .{ .@"0:", ._, .cvttss2si, .tmp1d, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50487 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, | 51010 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| 50488 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 51011 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 51012 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 50489 | } }, | 51013 | } }, |
| 50490 | }, .{ | 51014 | }, .{ |
| 50491 | .required_features = .{ .@"64bit", .f16c, null, null }, | 51015 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 50492 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 51016 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50493 | .dst_constraints = .{.{ .float = .word }}, | 51017 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50494 | .patterns = &.{ | 51018 | .patterns = &.{ |
| 50495 | .{ .src = .{ .mem, .none, .none } }, | 51019 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50496 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 51035 | .each = .{ .once = &.{ |
| 50500 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 51036 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50501 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, | 51037 | .{ .@"0:", .v_ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50502 | .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ }, | 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 }, | 51044 | .required_features = .{ .avx, null, null, null }, |
| 50506 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 51045 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50507 | .dst_constraints = .{.{ .float = .word }}, | 51046 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50508 | .patterns = &.{ | 51047 | .patterns = &.{ |
| 50509 | .{ .src = .{ .to_mut_gpr, .none, .none } }, | 51048 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50510 | }, | 51049 | }, |
| | 51050 | .call_frame = .{ .alignment = .@"16" }, |
| 50511 | .extra_temps = .{ | 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 | .unused, | 51056 | .unused, |
| 50514 | .unused, | 51057 | .unused, |
| 50515 | .unused, | 51058 | .unused, |
| 50516 | .unused, | 51059 | .unused, |
| 50517 | .unused, | 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 | .unused, | 51087 | .unused, |
| 50519 | .unused, | 51088 | .unused, |
| 50520 | .unused, | 51089 | .unused, |
| 50521 | }, | 51090 | }, |
| 50522 | .dst_temps = .{.{ .rc = .sse }}, | 51091 | .dst_temps = .{.mem}, |
| 50523 | .clobbers = .{ .eflags = true }, | 51092 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50524 | .each = .{ .once = &.{ | 51093 | .each = .{ .once = &.{ |
| 50525 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 51094 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50526 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, | 51095 | .{ .@"0:", ._ss, .mov, .tmp1x, .memsia(.src0d, .@"4", .tmp0, .add_unaligned_size), ._, ._ }, |
| 50527 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 51096 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50528 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 51097 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp3b, ._, ._ }, |
| 50529 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, | 51098 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| 50530 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, | 51099 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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(.{}), ._ }, | | |
| 50537 | } }, | 51100 | } }, |
| 50538 | }, .{ | 51101 | }, .{ |
| 50539 | .required_features = .{ .sse, null, null, null }, | 51102 | .required_features = .{ .sse, null, null, null }, |
| 50540 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 51103 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50541 | .dst_constraints = .{.{ .float = .word }}, | 51104 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .byte, .is = .byte } }}, |
| 50542 | .patterns = &.{ | 51105 | .patterns = &.{ |
| 50543 | .{ .src = .{ .{ .to_reg = .dil }, .none, .none } }, | 51106 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50544 | }, | 51107 | }, |
| 50545 | .call_frame = .{ .alignment = .@"16" }, | 51108 | .call_frame = .{ .alignment = .@"16" }, |
| 50546 | .extra_temps = .{ | 51109 | .extra_temps = .{ |
| 50547 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, | 51110 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50548 | .unused, | 51111 | .{ .type = .f32, .kind = .{ .reg = .xmm0 } }, |
| 50549 | .unused, | 51112 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fixsfsi" } } }, |
| 50550 | .unused, | 51113 | .{ .type = .i32, .kind = .{ .reg = .eax } }, |
| 50551 | .unused, | 51114 | .unused, |
| 50552 | .unused, | 51115 | .unused, |
| 50553 | .unused, | 51116 | .unused, |
| 50554 | .unused, | 51117 | .unused, |
| 50555 | .unused, | 51118 | .unused, |
| 50556 | }, | 51119 | }, |
| 50557 | .dst_temps = .{.{ .reg = .xmm0 }}, | 51120 | .dst_temps = .{.mem}, |
| 50558 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 51121 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50559 | .each = .{ .once = &.{ | 51122 | .each = .{ .once = &.{ |
| 50560 | .{ ._, ._, .movsx, .src0d, .src0b, ._, ._ }, | 51123 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50561 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 }, | 51131 | .required_features = .{ .avx, null, null, null }, |
| 50565 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 51132 | .src_constraints = .{ .{ .scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50566 | .dst_constraints = .{.{ .float = .word }}, | 51133 | .dst_constraints = .{.{ .scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 50567 | .patterns = &.{ | 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 | .extra_temps = .{ | 51189 | .extra_temps = .{ |
| 50572 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, | 51190 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50573 | .unused, | 51191 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 50574 | .unused, | 51192 | .unused, |
| 50575 | .unused, | 51193 | .unused, |
| 50576 | .unused, | 51194 | .unused, |
| ... | @@ -50579,23 +51197,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50579,23 +51197,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50579 | .unused, | 51197 | .unused, |
| 50580 | .unused, | 51198 | .unused, |
| 50581 | }, | 51199 | }, |
| 50582 | .dst_temps = .{.{ .reg = .xmm0 }}, | 51200 | .dst_temps = .{.mem}, |
| 50583 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 50584 | .each = .{ .once = &.{ | 51201 | .each = .{ .once = &.{ |
| 50585 | .{ ._, ._, .movzx, .src0d, .src0b, ._, ._ }, | 51202 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50586 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 }, | 51210 | .required_features = .{ .sse2, null, null, null }, |
| 50590 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 51211 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50591 | .dst_constraints = .{.{ .float = .word }}, | 51212 | .dst_constraints = .{.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .word } }}, |
| 50592 | .patterns = &.{ | 51213 | .patterns = &.{ |
| 50593 | .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, | 51214 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50594 | }, | 51215 | }, |
| 50595 | .call_frame = .{ .alignment = .@"16" }, | | |
| 50596 | .extra_temps = .{ | 51216 | .extra_temps = .{ |
| 50597 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsihf" } } }, | 51217 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50598 | .unused, | 51218 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| 50599 | .unused, | 51219 | .unused, |
| 50600 | .unused, | 51220 | .unused, |
| 50601 | .unused, | 51221 | .unused, |
| ... | @@ -50604,23 +51224,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50604,23 +51224,25 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50604 | .unused, | 51224 | .unused, |
| 50605 | .unused, | 51225 | .unused, |
| 50606 | }, | 51226 | }, |
| 50607 | .dst_temps = .{.{ .reg = .xmm0 }}, | 51227 | .dst_temps = .{.mem}, |
| 50608 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 50609 | .each = .{ .once = &.{ | 51228 | .each = .{ .once = &.{ |
| 50610 | .{ ._, ._, .movsx, .src0d, .src0w, ._, ._ }, | 51229 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50611 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 }, | 51237 | .required_features = .{ .avx, null, null, null }, |
| 50615 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 51238 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50616 | .dst_constraints = .{.{ .float = .word }}, | 51239 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 50617 | .patterns = &.{ | 51240 | .patterns = &.{ |
| 50618 | .{ .src = .{ .{ .to_reg = .di }, .none, .none } }, | 51241 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50619 | }, | 51242 | }, |
| 50620 | .call_frame = .{ .alignment = .@"16" }, | | |
| 50621 | .extra_temps = .{ | 51243 | .extra_temps = .{ |
| 50622 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsihf" } } }, | 51244 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50623 | .unused, | 51245 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| 50624 | .unused, | 51246 | .unused, |
| 50625 | .unused, | 51247 | .unused, |
| 50626 | .unused, | 51248 | .unused, |
| ... | @@ -50629,70 +51251,12586 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50629,70 +51251,12586 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50629 | .unused, | 51251 | .unused, |
| 50630 | .unused, | 51252 | .unused, |
| 50631 | }, | 51253 | }, |
| 50632 | .dst_temps = .{.{ .reg = .xmm0 }}, | 51254 | .dst_temps = .{.mem}, |
| 50633 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 50634 | .each = .{ .once = &.{ | 51255 | .each = .{ .once = &.{ |
| 50635 | .{ ._, ._, .movzx, .src0d, .src0w, ._, ._ }, | 51256 | .{ ._, ._, .mov, .tmp0p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 50636 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 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 }, | 51264 | .required_features = .{ .sse4_1, null, null, null }, |
| 50640 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, | 51265 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } }, .any, .any }, |
| 50641 | .dst_constraints = .{.{ .float = .word }}, | 51266 | .dst_constraints = .{.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }}, |
| 50642 | .patterns = &.{ | 51267 | .patterns = &.{ |
| 50643 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, | 51268 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50644 | }, | 51269 | }, |
| 50645 | .call_frame = .{ .alignment = .@"16" }, | | |
| 50646 | .extra_temps = .{ | 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 | .unused, | 51276 | .unused, |
| 50649 | .unused, | 51277 | .unused, |
| 50650 | .unused, | 51278 | .unused, |
| 50651 | .unused, | 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 | .unused, | 51304 | .unused, |
| 50653 | .unused, | 51305 | .unused, |
| 50654 | .unused, | 51306 | .unused, |
| 50655 | .unused, | 51307 | .unused, |
| 50656 | }, | 51308 | }, |
| 50657 | .dst_temps = .{.{ .reg = .xmm0 }}, | 51309 | .dst_temps = .{.mem}, |
| 50658 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 51310 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50659 | .each = .{ .once = &.{ | 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 | .required_features = .{ .sse, null, null, null }, | 51320 | .required_features = .{ .sse, null, null, null }, |
| 50664 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, | 51321 | .src_constraints = .{ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50665 | .dst_constraints = .{.{ .float = .word }}, | 51322 | .dst_constraints = .{.{ .multiple_scalar_int = .{ .of = .word, .is = .word } }}, |
| 50666 | .patterns = &.{ | 51323 | .patterns = &.{ |
| 50667 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, | 51324 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50668 | }, | 51325 | }, |
| 50669 | .call_frame = .{ .alignment = .@"16" }, | 51326 | .call_frame = .{ .alignment = .@"16" }, |
| 50670 | .extra_temps = .{ | 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 | .unused, | 51333 | .unused, |
| 50673 | .unused, | 51334 | .unused, |
| 50674 | .unused, | 51335 | .unused, |
| 50675 | .unused, | 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 | .unused, | 51385 | .unused, |
| 50677 | .unused, | 51386 | .unused, |
| 50678 | .unused, | 51387 | .unused, |
| 50679 | .unused, | 51388 | .unused, |
| 50680 | }, | 51389 | }, |
| 50681 | .dst_temps = .{.{ .reg = .xmm0 }}, | 51390 | .dst_temps = .{.mem}, |
| 50682 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 50683 | .each = .{ .once = &.{ | 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 }, | 51399 | .required_features = .{ .sse2, null, null, null }, |
| 50688 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, | 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 | .dst_constraints = .{.{ .float = .word }}, | 56628 | .dst_constraints = .{.{ .float = .word }}, |
| 50690 | .patterns = &.{ | 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 | .extra_temps = .{ | 63832 | .extra_temps = .{ |
| 50695 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdihf" } } }, | 63833 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50696 | .unused, | 63834 | .unused, |
| 50697 | .unused, | 63835 | .unused, |
| 50698 | .unused, | 63836 | .unused, |
| ... | @@ -50702,45 +63840,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50702,45 +63840,49 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50702 | .unused, | 63840 | .unused, |
| 50703 | .unused, | 63841 | .unused, |
| 50704 | }, | 63842 | }, |
| 50705 | .dst_temps = .{.{ .reg = .xmm0 }}, | 63843 | .dst_temps = .{.{ .rc = .x87 }}, |
| 50706 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | | |
| 50707 | .each = .{ .once = &.{ | 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 }, | 63849 | .required_features = .{ .x87, null, null, null }, |
| 50712 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, | 63850 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, |
| 50713 | .dst_constraints = .{.{ .float = .word }}, | 63851 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50714 | .patterns = &.{ | 63852 | .patterns = &.{ |
| 50715 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, | 63853 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50716 | }, | 63854 | }, |
| 50717 | .call_frame = .{ .alignment = .@"16" }, | | |
| 50718 | .extra_temps = .{ | 63855 | .extra_temps = .{ |
| 50719 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundihf" } } }, | 63856 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50720 | .unused, | 63857 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, |
| 50721 | .unused, | 63858 | .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem }, |
| 50722 | .unused, | 63859 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50723 | .unused, | 63860 | .unused, |
| 50724 | .unused, | 63861 | .unused, |
| 50725 | .unused, | 63862 | .unused, |
| 50726 | .unused, | 63863 | .unused, |
| 50727 | .unused, | 63864 | .unused, |
| 50728 | }, | 63865 | }, |
| 50729 | .dst_temps = .{.{ .reg = .xmm0 }}, | 63866 | .dst_temps = .{.{ .rc = .x87 }}, |
| 50730 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 63867 | .clobbers = .{ .eflags = true }, |
| 50731 | .each = .{ .once = &.{ | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 63877 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50736 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, | 63878 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 50737 | .dst_constraints = .{.{ .float = .word }}, | 63879 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50738 | .patterns = &.{ | 63880 | .patterns = &.{ |
| 50739 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 63881 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 50740 | }, | 63882 | }, |
| 50741 | .call_frame = .{ .alignment = .@"16" }, | 63883 | .call_frame = .{ .alignment = .@"16" }, |
| 50742 | .extra_temps = .{ | 63884 | .extra_temps = .{ |
| 50743 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattihf" } } }, | 63885 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattixf" } } }, |
| 50744 | .unused, | 63886 | .unused, |
| 50745 | .unused, | 63887 | .unused, |
| 50746 | .unused, | 63888 | .unused, |
| ... | @@ -50750,7 +63892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50750,7 +63892,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50750 | .unused, | 63892 | .unused, |
| 50751 | .unused, | 63893 | .unused, |
| 50752 | }, | 63894 | }, |
| 50753 | .dst_temps = .{.{ .reg = .xmm0 }}, | 63895 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50754 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 63896 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50755 | .each = .{ .once = &.{ | 63897 | .each = .{ .once = &.{ |
| 50756 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 63898 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| ... | @@ -50758,13 +63900,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50758,13 +63900,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50758 | }, .{ | 63900 | }, .{ |
| 50759 | .required_features = .{ .@"64bit", .sse, null, null }, | 63901 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50760 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, | 63902 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 50761 | .dst_constraints = .{.{ .float = .word }}, | 63903 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50762 | .patterns = &.{ | 63904 | .patterns = &.{ |
| 50763 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 63905 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 50764 | }, | 63906 | }, |
| 50765 | .call_frame = .{ .alignment = .@"16" }, | 63907 | .call_frame = .{ .alignment = .@"16" }, |
| 50766 | .extra_temps = .{ | 63908 | .extra_temps = .{ |
| 50767 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntihf" } } }, | 63909 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntixf" } } }, |
| 50768 | .unused, | 63910 | .unused, |
| 50769 | .unused, | 63911 | .unused, |
| 50770 | .unused, | 63912 | .unused, |
| ... | @@ -50774,7 +63916,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50774,7 +63916,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50774 | .unused, | 63916 | .unused, |
| 50775 | .unused, | 63917 | .unused, |
| 50776 | }, | 63918 | }, |
| 50777 | .dst_temps = .{.{ .reg = .xmm0 }}, | 63919 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50778 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 63920 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50779 | .each = .{ .once = &.{ | 63921 | .each = .{ .once = &.{ |
| 50780 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, | 63922 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| ... | @@ -50782,7 +63924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50782,7 +63924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50782 | }, .{ | 63924 | }, .{ |
| 50783 | .required_features = .{ .@"64bit", .sse, null, null }, | 63925 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50784 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 63926 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50785 | .dst_constraints = .{.{ .float = .word }}, | 63927 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50786 | .patterns = &.{ | 63928 | .patterns = &.{ |
| 50787 | .{ .src = .{ .to_mem, .none, .none } }, | 63929 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50788 | }, | 63930 | }, |
| ... | @@ -50790,7 +63932,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50790,7 +63932,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50790 | .extra_temps = .{ | 63932 | .extra_temps = .{ |
| 50791 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 63933 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50792 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 63934 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50793 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateihf" } } }, | 63935 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } }, |
| 50794 | .unused, | 63936 | .unused, |
| 50795 | .unused, | 63937 | .unused, |
| 50796 | .unused, | 63938 | .unused, |
| ... | @@ -50798,7 +63940,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50798,7 +63940,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50798 | .unused, | 63940 | .unused, |
| 50799 | .unused, | 63941 | .unused, |
| 50800 | }, | 63942 | }, |
| 50801 | .dst_temps = .{.{ .reg = .xmm0 }}, | 63943 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50802 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 63944 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50803 | .each = .{ .once = &.{ | 63945 | .each = .{ .once = &.{ |
| 50804 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 63946 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| ... | @@ -50808,7 +63950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50808,7 +63950,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50808 | }, .{ | 63950 | }, .{ |
| 50809 | .required_features = .{ .@"64bit", .sse, null, null }, | 63951 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 50810 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 63952 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 50811 | .dst_constraints = .{.{ .float = .word }}, | 63953 | .dst_constraints = .{.{ .float = .tbyte }}, |
| 50812 | .patterns = &.{ | 63954 | .patterns = &.{ |
| 50813 | .{ .src = .{ .to_mem, .none, .none } }, | 63955 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50814 | }, | 63956 | }, |
| ... | @@ -50816,7 +63958,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50816,7 +63958,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50816 | .extra_temps = .{ | 63958 | .extra_temps = .{ |
| 50817 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 63959 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 50818 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 63960 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 50819 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneihf" } } }, | 63961 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } }, |
| 50820 | .unused, | 63962 | .unused, |
| 50821 | .unused, | 63963 | .unused, |
| 50822 | .unused, | 63964 | .unused, |
| ... | @@ -50824,7 +63966,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50824,7 +63966,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50824 | .unused, | 63966 | .unused, |
| 50825 | .unused, | 63967 | .unused, |
| 50826 | }, | 63968 | }, |
| 50827 | .dst_temps = .{.{ .reg = .xmm0 }}, | 63969 | .dst_temps = .{.{ .reg = .st0 }}, |
| 50828 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 63970 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50829 | .each = .{ .once = &.{ | 63971 | .each = .{ .once = &.{ |
| 50830 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 63972 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| ... | @@ -50832,166 +63974,267 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -50832,166 +63974,267 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 50832 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 63974 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 50833 | } }, | 63975 | } }, |
| 50834 | }, .{ | 63976 | }, .{ |
| 50835 | .required_features = .{ .avx, null, null, null }, | 63977 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 50836 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 63978 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 50837 | .dst_constraints = .{.{ .float = .dword }}, | 63979 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50838 | .patterns = &.{ | 63980 | .patterns = &.{ |
| 50839 | .{ .src = .{ .mem, .none, .none } }, | 63981 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50840 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50841 | }, | 63982 | }, |
| 50842 | .extra_temps = .{ | 63983 | .extra_temps = .{ |
| 50843 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 63984 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50844 | .unused, | 63985 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50845 | .unused, | 63986 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 50846 | .unused, | 63987 | .{ .type = .i16, .kind = .mem }, |
| 50847 | .unused, | 63988 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50848 | .unused, | 63989 | .unused, |
| 50849 | .unused, | 63990 | .unused, |
| 50850 | .unused, | 63991 | .unused, |
| 50851 | .unused, | 63992 | .unused, |
| 50852 | }, | 63993 | }, |
| 50853 | .dst_temps = .{.{ .rc = .sse }}, | 63994 | .dst_temps = .{.mem}, |
| | 63995 | .clobbers = .{ .eflags = true }, |
| 50854 | .each = .{ .once = &.{ | 63996 | .each = .{ .once = &.{ |
| 50855 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 63997 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50856 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 63998 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50857 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 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 }, | 64008 | .required_features = .{ .x87, null, null, null }, |
| 50861 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 64009 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 50862 | .dst_constraints = .{.{ .float = .dword }}, | 64010 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50863 | .patterns = &.{ | 64011 | .patterns = &.{ |
| 50864 | .{ .src = .{ .mem, .none, .none } }, | 64012 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50865 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50866 | }, | 64013 | }, |
| 50867 | .extra_temps = .{ | 64014 | .extra_temps = .{ |
| 50868 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64015 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50869 | .unused, | 64016 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50870 | .unused, | 64017 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 50871 | .unused, | 64018 | .{ .type = .i16, .kind = .mem }, |
| 50872 | .unused, | 64019 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50873 | .unused, | 64020 | .unused, |
| 50874 | .unused, | 64021 | .unused, |
| 50875 | .unused, | 64022 | .unused, |
| 50876 | .unused, | 64023 | .unused, |
| 50877 | }, | 64024 | }, |
| 50878 | .dst_temps = .{.{ .rc = .sse }}, | 64025 | .dst_temps = .{.mem}, |
| | 64026 | .clobbers = .{ .eflags = true }, |
| 50879 | .each = .{ .once = &.{ | 64027 | .each = .{ .once = &.{ |
| 50880 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 64028 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50881 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64029 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50882 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | 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 }, | 64039 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 50886 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 64040 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 50887 | .dst_constraints = .{.{ .float = .dword }}, | 64041 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50888 | .patterns = &.{ | 64042 | .patterns = &.{ |
| 50889 | .{ .src = .{ .mem, .none, .none } }, | 64043 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50890 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50891 | }, | 64044 | }, |
| 50892 | .extra_temps = .{ | 64045 | .extra_temps = .{ |
| 50893 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64046 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50894 | .unused, | 64047 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50895 | .unused, | 64048 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 50896 | .unused, | 64049 | .{ .type = .i16, .kind = .mem }, |
| 50897 | .unused, | 64050 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50898 | .unused, | 64051 | .unused, |
| 50899 | .unused, | 64052 | .unused, |
| 50900 | .unused, | 64053 | .unused, |
| 50901 | .unused, | 64054 | .unused, |
| 50902 | }, | 64055 | }, |
| 50903 | .dst_temps = .{.{ .rc = .sse }}, | 64056 | .dst_temps = .{.mem}, |
| | 64057 | .clobbers = .{ .eflags = true }, |
| 50904 | .each = .{ .once = &.{ | 64058 | .each = .{ .once = &.{ |
| 50905 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 64059 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50906 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64060 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50907 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 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 }, | 64070 | .required_features = .{ .x87, null, null, null }, |
| 50911 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 64071 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 50912 | .dst_constraints = .{.{ .float = .dword }}, | 64072 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50913 | .patterns = &.{ | 64073 | .patterns = &.{ |
| 50914 | .{ .src = .{ .mem, .none, .none } }, | 64074 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50915 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50916 | }, | 64075 | }, |
| 50917 | .extra_temps = .{ | 64076 | .extra_temps = .{ |
| 50918 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64077 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50919 | .unused, | 64078 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 50920 | .unused, | 64079 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 50921 | .unused, | 64080 | .{ .type = .i16, .kind = .mem }, |
| 50922 | .unused, | 64081 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50923 | .unused, | 64082 | .unused, |
| 50924 | .unused, | 64083 | .unused, |
| 50925 | .unused, | 64084 | .unused, |
| 50926 | .unused, | 64085 | .unused, |
| 50927 | }, | 64086 | }, |
| 50928 | .dst_temps = .{.{ .rc = .sse }}, | 64087 | .dst_temps = .{.mem}, |
| | 64088 | .clobbers = .{ .eflags = true }, |
| 50929 | .each = .{ .once = &.{ | 64089 | .each = .{ .once = &.{ |
| 50930 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 64090 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50931 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64091 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50932 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | 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 }, | 64101 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 50936 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 64102 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 50937 | .dst_constraints = .{.{ .float = .dword }}, | 64103 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50938 | .patterns = &.{ | 64104 | .patterns = &.{ |
| 50939 | .{ .src = .{ .mem, .none, .none } }, | 64105 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50940 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50941 | }, | 64106 | }, |
| | 64107 | .call_frame = .{ .alignment = .@"16" }, |
| 50942 | .extra_temps = .{ | 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 | .unused, | 64114 | .unused, |
| 50945 | .unused, | 64115 | .unused, |
| 50946 | .unused, | 64116 | .unused, |
| 50947 | .unused, | 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 | .unused, | 64146 | .unused, |
| 50949 | .unused, | 64147 | .unused, |
| 50950 | .unused, | 64148 | .unused, |
| 50951 | .unused, | 64149 | .unused, |
| 50952 | }, | 64150 | }, |
| 50953 | .dst_temps = .{.{ .rc = .sse }}, | 64151 | .dst_temps = .{.mem}, |
| | 64152 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50954 | .each = .{ .once = &.{ | 64153 | .each = .{ .once = &.{ |
| 50955 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 64154 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50956 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64155 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50957 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 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 }, | 64165 | .required_features = .{ .x87, .slow_incdec, null, null }, |
| 50961 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 64166 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 50962 | .dst_constraints = .{.{ .float = .dword }}, | 64167 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50963 | .patterns = &.{ | 64168 | .patterns = &.{ |
| 50964 | .{ .src = .{ .mem, .none, .none } }, | 64169 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50965 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50966 | }, | 64170 | }, |
| | 64171 | .call_frame = .{ .alignment = .@"16" }, |
| 50967 | .extra_temps = .{ | 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 | .unused, | 64178 | .unused, |
| 50970 | .unused, | 64179 | .unused, |
| 50971 | .unused, | 64180 | .unused, |
| 50972 | .unused, | 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 | .unused, | 64210 | .unused, |
| 50974 | .unused, | 64211 | .unused, |
| 50975 | .unused, | 64212 | .unused, |
| 50976 | .unused, | 64213 | .unused, |
| 50977 | }, | 64214 | }, |
| 50978 | .dst_temps = .{.{ .rc = .sse }}, | 64215 | .dst_temps = .{.mem}, |
| | 64216 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 50979 | .each = .{ .once = &.{ | 64217 | .each = .{ .once = &.{ |
| 50980 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 64218 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 50981 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64219 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 50982 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | 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 }, | 64229 | .required_features = .{ .x87, null, null, null }, |
| 50986 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 64230 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 50987 | .dst_constraints = .{.{ .float = .dword }}, | 64231 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 50988 | .patterns = &.{ | 64232 | .patterns = &.{ |
| 50989 | .{ .src = .{ .mem, .none, .none } }, | 64233 | .{ .src = .{ .to_mem, .none, .none } }, |
| 50990 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 50991 | }, | 64234 | }, |
| 50992 | .extra_temps = .{ | 64235 | .extra_temps = .{ |
| 50993 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64236 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 50994 | .unused, | 64237 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 50995 | .unused, | 64238 | .unused, |
| 50996 | .unused, | 64239 | .unused, |
| 50997 | .unused, | 64240 | .unused, |
| ... | @@ -51000,74 +64243,85 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51000,74 +64243,85 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51000 | .unused, | 64243 | .unused, |
| 51001 | .unused, | 64244 | .unused, |
| 51002 | }, | 64245 | }, |
| 51003 | .dst_temps = .{.{ .rc = .sse }}, | 64246 | .dst_temps = .{.mem}, |
| | 64247 | .clobbers = .{ .eflags = true }, |
| 51004 | .each = .{ .once = &.{ | 64248 | .each = .{ .once = &.{ |
| 51005 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 64249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51006 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64250 | .{ .@"0:", .fi_, .ld, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 51007 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | 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 }, | 64256 | .required_features = .{ .x87, null, null, null }, |
| 51011 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 64257 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51012 | .dst_constraints = .{.{ .float = .dword }}, | 64258 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51013 | .patterns = &.{ | 64259 | .patterns = &.{ |
| 51014 | .{ .src = .{ .mem, .none, .none } }, | 64260 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51015 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51016 | }, | 64261 | }, |
| | 64262 | .call_frame = .{ .alignment = .@"16" }, |
| 51017 | .extra_temps = .{ | 64263 | .extra_temps = .{ |
| 51018 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64264 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51019 | .unused, | 64265 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51020 | .unused, | 64266 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsixf" } } }, |
| 51021 | .unused, | 64267 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51022 | .unused, | 64268 | .unused, |
| 51023 | .unused, | 64269 | .unused, |
| 51024 | .unused, | 64270 | .unused, |
| 51025 | .unused, | 64271 | .unused, |
| 51026 | .unused, | 64272 | .unused, |
| 51027 | }, | 64273 | }, |
| 51028 | .dst_temps = .{.{ .rc = .sse }}, | 64274 | .dst_temps = .{.mem}, |
| | 64275 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51029 | .each = .{ .once = &.{ | 64276 | .each = .{ .once = &.{ |
| 51030 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 64277 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51031 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64278 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51032 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | 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 }, | 64286 | .required_features = .{ .x87, null, null, null }, |
| 51036 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 64287 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51037 | .dst_constraints = .{.{ .float = .dword }}, | 64288 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51038 | .patterns = &.{ | 64289 | .patterns = &.{ |
| 51039 | .{ .src = .{ .mem, .none, .none } }, | 64290 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51040 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51041 | }, | 64291 | }, |
| 51042 | .dst_temps = .{.{ .rc = .sse }}, | 64292 | .call_frame = .{ .alignment = .@"16" }, |
| 51043 | .each = .{ .once = &.{ | 64293 | .extra_temps = .{ |
| 51044 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64294 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51045 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, | 64295 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51046 | } }, | 64296 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsixf" } } }, |
| 51047 | }, .{ | 64297 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51048 | .required_features = .{ .sse, null, null, null }, | 64298 | .unused, |
| 51049 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 64299 | .unused, |
| 51050 | .dst_constraints = .{.{ .float = .dword }}, | 64300 | .unused, |
| 51051 | .patterns = &.{ | 64301 | .unused, |
| 51052 | .{ .src = .{ .mem, .none, .none } }, | 64302 | .unused, |
| 51053 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51054 | }, | 64303 | }, |
| 51055 | .dst_temps = .{.{ .rc = .sse }}, | 64304 | .dst_temps = .{.mem}, |
| | 64305 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51056 | .each = .{ .once = &.{ | 64306 | .each = .{ .once = &.{ |
| 51057 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64307 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51058 | .{ ._, ._ss, .cvtsi2, .dst0x, .src0d, ._, ._ }, | 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 }, | 64316 | .required_features = .{ .x87, null, null, null }, |
| 51062 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 64317 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51063 | .dst_constraints = .{.{ .float = .dword }}, | 64318 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51064 | .patterns = &.{ | 64319 | .patterns = &.{ |
| 51065 | .{ .src = .{ .mem, .none, .none } }, | 64320 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51066 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51067 | }, | 64321 | }, |
| 51068 | .extra_temps = .{ | 64322 | .extra_temps = .{ |
| 51069 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64323 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51070 | .unused, | 64324 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51071 | .unused, | 64325 | .unused, |
| 51072 | .unused, | 64326 | .unused, |
| 51073 | .unused, | 64327 | .unused, |
| ... | @@ -51076,73 +64330,85 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51076,73 +64330,85 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51076 | .unused, | 64330 | .unused, |
| 51077 | .unused, | 64331 | .unused, |
| 51078 | }, | 64332 | }, |
| 51079 | .dst_temps = .{.{ .rc = .sse }}, | 64333 | .dst_temps = .{.mem}, |
| | 64334 | .clobbers = .{ .eflags = true }, |
| 51080 | .each = .{ .once = &.{ | 64335 | .each = .{ .once = &.{ |
| 51081 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 64336 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51082 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64337 | .{ .@"0:", .fi_, .ld, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 51083 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, | 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 }, | 64343 | .required_features = .{ .x87, null, null, null }, |
| 51087 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 64344 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51088 | .dst_constraints = .{.{ .float = .dword }}, | 64345 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51089 | .patterns = &.{ | 64346 | .patterns = &.{ |
| 51090 | .{ .src = .{ .mem, .none, .none } }, | 64347 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51091 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51092 | }, | 64348 | }, |
| | 64349 | .call_frame = .{ .alignment = .@"16" }, |
| 51093 | .extra_temps = .{ | 64350 | .extra_temps = .{ |
| 51094 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64351 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51095 | .unused, | 64352 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51096 | .unused, | 64353 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsixf" } } }, |
| 51097 | .unused, | 64354 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51098 | .unused, | 64355 | .unused, |
| 51099 | .unused, | 64356 | .unused, |
| 51100 | .unused, | 64357 | .unused, |
| 51101 | .unused, | 64358 | .unused, |
| 51102 | .unused, | 64359 | .unused, |
| 51103 | }, | 64360 | }, |
| 51104 | .dst_temps = .{.{ .rc = .sse }}, | 64361 | .dst_temps = .{.mem}, |
| | 64362 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51105 | .each = .{ .once = &.{ | 64363 | .each = .{ .once = &.{ |
| 51106 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 64364 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51107 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64365 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51108 | .{ ._, ._ss, .cvtsi2, .dst0x, .tmp0q, ._, ._ }, | 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 }, | 64373 | .required_features = .{ .x87, null, null, null }, |
| 51112 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 64374 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51113 | .dst_constraints = .{.{ .float = .dword }}, | 64375 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51114 | .patterns = &.{ | 64376 | .patterns = &.{ |
| 51115 | .{ .src = .{ .mem, .none, .none } }, | 64377 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51116 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51117 | }, | 64378 | }, |
| 51118 | .dst_temps = .{.{ .rc = .sse }}, | 64379 | .call_frame = .{ .alignment = .@"16" }, |
| 51119 | .each = .{ .once = &.{ | 64380 | .extra_temps = .{ |
| 51120 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51121 | .{ ._, .v_ss, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, | 64382 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51122 | } }, | 64383 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsixf" } } }, |
| 51123 | }, .{ | 64384 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51124 | .required_features = .{ .@"64bit", .sse, null, null }, | 64385 | .unused, |
| 51125 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 64386 | .unused, |
| 51126 | .dst_constraints = .{.{ .float = .dword }}, | 64387 | .unused, |
| 51127 | .patterns = &.{ | 64388 | .unused, |
| 51128 | .{ .src = .{ .mem, .none, .none } }, | 64389 | .unused, |
| 51129 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51130 | }, | 64390 | }, |
| 51131 | .dst_temps = .{.{ .rc = .sse }}, | 64391 | .dst_temps = .{.mem}, |
| | 64392 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51132 | .each = .{ .once = &.{ | 64393 | .each = .{ .once = &.{ |
| 51133 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64394 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51134 | .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, | 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 }, | 64403 | .required_features = .{ .x87, null, null, null }, |
| 51138 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 64404 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 51139 | .dst_constraints = .{.{ .float = .dword }}, | 64405 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51140 | .patterns = &.{ | 64406 | .patterns = &.{ |
| 51141 | .{ .src = .{ .to_mut_gpr, .none, .none } }, | 64407 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51142 | }, | 64408 | }, |
| 51143 | .extra_temps = .{ | 64409 | .extra_temps = .{ |
| 51144 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, | 64410 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51145 | .unused, | 64411 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51146 | .unused, | 64412 | .unused, |
| 51147 | .unused, | 64413 | .unused, |
| 51148 | .unused, | 64414 | .unused, |
| ... | @@ -51151,165 +64417,215 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51151,165 +64417,215 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51151 | .unused, | 64417 | .unused, |
| 51152 | .unused, | 64418 | .unused, |
| 51153 | }, | 64419 | }, |
| 51154 | .dst_temps = .{.{ .rc = .sse }}, | 64420 | .dst_temps = .{.mem}, |
| 51155 | .clobbers = .{ .eflags = true }, | 64421 | .clobbers = .{ .eflags = true }, |
| 51156 | .each = .{ .once = &.{ | 64422 | .each = .{ .once = &.{ |
| 51157 | .{ ._, .v_ps, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64423 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51158 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, | 64424 | .{ .@"0:", .fi_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 51159 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 64425 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 51160 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 64426 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 51161 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, | 64427 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._ }, | | |
| 51168 | } }, | 64428 | } }, |
| 51169 | }, .{ | 64429 | }, .{ |
| 51170 | .required_features = .{ .@"64bit", .sse, null, null }, | 64430 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51171 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 64431 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 51172 | .dst_constraints = .{.{ .float = .dword }}, | 64432 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51173 | .patterns = &.{ | 64433 | .patterns = &.{ |
| 51174 | .{ .src = .{ .to_mut_gpr, .none, .none } }, | 64434 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51175 | }, | 64435 | }, |
| | 64436 | .call_frame = .{ .alignment = .@"16" }, |
| 51176 | .extra_temps = .{ | 64437 | .extra_temps = .{ |
| 51177 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, | 64438 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51178 | .unused, | 64439 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 51179 | .unused, | 64440 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatdixf" } } }, |
| 51180 | .unused, | 64441 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51181 | .unused, | 64442 | .unused, |
| 51182 | .unused, | 64443 | .unused, |
| 51183 | .unused, | 64444 | .unused, |
| 51184 | .unused, | 64445 | .unused, |
| 51185 | .unused, | 64446 | .unused, |
| 51186 | }, | 64447 | }, |
| 51187 | .dst_temps = .{.{ .rc = .sse }}, | 64448 | .dst_temps = .{.mem}, |
| 51188 | .clobbers = .{ .eflags = true }, | 64449 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51189 | .each = .{ .once = &.{ | 64450 | .each = .{ .once = &.{ |
| 51190 | .{ ._, ._ps, .xor, .dst0x, .dst0x, ._, ._ }, | 64451 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51191 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, | 64452 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51192 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 64453 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51193 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 64454 | .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ }, |
| 51194 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, | 64455 | .{ ._, .f_p, .st, .memsia(.dst0t, .@"2", .tmp0, .add_unaligned_size), ._, ._, ._ }, |
| 51195 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, | 64456 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 51196 | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, | 64457 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51197 | .{ ._, ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, | | |
| 51198 | .{ ._, ._ss, .add, .dst0x, .dst0d, ._, ._ }, | | |
| 51199 | .{ ._, ._mp, .j, .@"0f", ._, ._, ._ }, | | |
| 51200 | .{ .@"1:", ._ss, .cvtsi2, .dst0x, .src0q, ._, ._ }, | | |
| 51201 | } }, | 64458 | } }, |
| 51202 | }, .{ | 64459 | }, .{ |
| 51203 | .required_features = .{ .@"64bit", .sse, null, null }, | 64460 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51204 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, | 64461 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 51205 | .dst_constraints = .{.{ .float = .dword }}, | 64462 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51206 | .patterns = &.{ | 64463 | .patterns = &.{ |
| 51207 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 64464 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51208 | }, | 64465 | }, |
| 51209 | .call_frame = .{ .alignment = .@"16" }, | 64466 | .call_frame = .{ .alignment = .@"16" }, |
| 51210 | .extra_temps = .{ | 64467 | .extra_temps = .{ |
| 51211 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattisf" } } }, | 64468 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51212 | .unused, | 64469 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 51213 | .unused, | 64470 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatundixf" } } }, |
| 51214 | .unused, | 64471 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51215 | .unused, | 64472 | .unused, |
| 51216 | .unused, | 64473 | .unused, |
| 51217 | .unused, | 64474 | .unused, |
| 51218 | .unused, | 64475 | .unused, |
| 51219 | .unused, | 64476 | .unused, |
| 51220 | }, | 64477 | }, |
| 51221 | .dst_temps = .{.{ .reg = .xmm0 }}, | 64478 | .dst_temps = .{.mem}, |
| 51222 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 64479 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51223 | .each = .{ .once = &.{ | 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 }, | 64490 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51228 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, | 64491 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 51229 | .dst_constraints = .{.{ .float = .dword }}, | 64492 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51230 | .patterns = &.{ | 64493 | .patterns = &.{ |
| 51231 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 64494 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51232 | }, | 64495 | }, |
| 51233 | .call_frame = .{ .alignment = .@"16" }, | 64496 | .call_frame = .{ .alignment = .@"16" }, |
| 51234 | .extra_temps = .{ | 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 | .unused, | 64503 | .unused, |
| 51237 | .unused, | 64504 | .unused, |
| 51238 | .unused, | 64505 | .unused, |
| 51239 | .unused, | 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 | .unused, | 64534 | .unused, |
| 51241 | .unused, | 64535 | .unused, |
| 51242 | .unused, | 64536 | .unused, |
| 51243 | .unused, | 64537 | .unused, |
| 51244 | }, | 64538 | }, |
| 51245 | .dst_temps = .{.{ .reg = .xmm0 }}, | 64539 | .dst_temps = .{.mem}, |
| 51246 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 64540 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51247 | .each = .{ .once = &.{ | 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 }, | 64552 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51252 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 64553 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51253 | .dst_constraints = .{.{ .float = .dword }}, | 64554 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51254 | .patterns = &.{ | 64555 | .patterns = &.{ |
| 51255 | .{ .src = .{ .to_mem, .none, .none } }, | 64556 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51256 | }, | 64557 | }, |
| 51257 | .call_frame = .{ .alignment = .@"16" }, | 64558 | .call_frame = .{ .alignment = .@"16" }, |
| 51258 | .extra_temps = .{ | 64559 | .extra_temps = .{ |
| | 64560 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 64561 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51259 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 64562 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51260 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 64563 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51261 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateisf" } } }, | 64564 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } }, |
| 51262 | .unused, | 64565 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51263 | .unused, | | |
| 51264 | .unused, | | |
| 51265 | .unused, | 64566 | .unused, |
| 51266 | .unused, | 64567 | .unused, |
| 51267 | .unused, | 64568 | .unused, |
| 51268 | }, | 64569 | }, |
| 51269 | .dst_temps = .{.{ .reg = .xmm0 }}, | 64570 | .dst_temps = .{.mem}, |
| 51270 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 64571 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51271 | .each = .{ .once = &.{ | 64572 | .each = .{ .once = &.{ |
| 51272 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 64573 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51273 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 64574 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51274 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 64585 | .required_features = .{ .@"64bit", .x87, null, null }, |
| 51278 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 64586 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51279 | .dst_constraints = .{.{ .float = .dword }}, | 64587 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } }}, |
| 51280 | .patterns = &.{ | 64588 | .patterns = &.{ |
| 51281 | .{ .src = .{ .to_mem, .none, .none } }, | 64589 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51282 | }, | 64590 | }, |
| 51283 | .call_frame = .{ .alignment = .@"16" }, | 64591 | .call_frame = .{ .alignment = .@"16" }, |
| 51284 | .extra_temps = .{ | 64592 | .extra_temps = .{ |
| | 64593 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 64594 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51285 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 64595 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51286 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 64596 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51287 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneisf" } } }, | 64597 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } }, |
| 51288 | .unused, | 64598 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, |
| 51289 | .unused, | | |
| 51290 | .unused, | | |
| 51291 | .unused, | 64599 | .unused, |
| 51292 | .unused, | 64600 | .unused, |
| 51293 | .unused, | 64601 | .unused, |
| 51294 | }, | 64602 | }, |
| 51295 | .dst_temps = .{.{ .reg = .xmm0 }}, | 64603 | .dst_temps = .{.mem}, |
| 51296 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 64604 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51297 | .each = .{ .once = &.{ | 64605 | .each = .{ .once = &.{ |
| 51298 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 64606 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51299 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 64607 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 51300 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 64619 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, |
| 51305 | .dst_constraints = .{.{ .float = .qword }}, | 64620 | .dst_constraints = .{.{ .float = .xword }}, |
| 51306 | .patterns = &.{ | 64621 | .patterns = &.{ |
| 51307 | .{ .src = .{ .mem, .none, .none } }, | 64622 | .{ .src = .{ .mem, .none, .none } }, |
| 51308 | .{ .src = .{ .to_gpr, .none, .none } }, | 64623 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51309 | }, | 64624 | }, |
| | 64625 | .call_frame = .{ .alignment = .@"16" }, |
| 51310 | .extra_temps = .{ | 64626 | .extra_temps = .{ |
| 51311 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64627 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51312 | .unused, | 64628 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51313 | .unused, | 64629 | .unused, |
| 51314 | .unused, | 64630 | .unused, |
| 51315 | .unused, | 64631 | .unused, |
| ... | @@ -51318,23 +64634,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51318,23 +64634,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51318 | .unused, | 64634 | .unused, |
| 51319 | .unused, | 64635 | .unused, |
| 51320 | }, | 64636 | }, |
| 51321 | .dst_temps = .{.{ .rc = .sse }}, | 64637 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64638 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51322 | .each = .{ .once = &.{ | 64639 | .each = .{ .once = &.{ |
| 51323 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 64640 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, |
| 51324 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64641 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51325 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | | |
| 51326 | } }, | 64642 | } }, |
| 51327 | }, .{ | 64643 | }, .{ |
| 51328 | .required_features = .{ .sse2, null, null, null }, | 64644 | .required_features = .{ .sse, null, null, null }, |
| 51329 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 64645 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, |
| 51330 | .dst_constraints = .{.{ .float = .qword }}, | 64646 | .dst_constraints = .{.{ .float = .xword }}, |
| 51331 | .patterns = &.{ | 64647 | .patterns = &.{ |
| 51332 | .{ .src = .{ .mem, .none, .none } }, | 64648 | .{ .src = .{ .mem, .none, .none } }, |
| 51333 | .{ .src = .{ .to_gpr, .none, .none } }, | 64649 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51334 | }, | 64650 | }, |
| | 64651 | .call_frame = .{ .alignment = .@"16" }, |
| 51335 | .extra_temps = .{ | 64652 | .extra_temps = .{ |
| 51336 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64653 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51337 | .unused, | 64654 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51338 | .unused, | 64655 | .unused, |
| 51339 | .unused, | 64656 | .unused, |
| 51340 | .unused, | 64657 | .unused, |
| ... | @@ -51343,23 +64660,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51343,23 +64660,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51343 | .unused, | 64660 | .unused, |
| 51344 | .unused, | 64661 | .unused, |
| 51345 | }, | 64662 | }, |
| 51346 | .dst_temps = .{.{ .rc = .sse }}, | 64663 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64664 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51347 | .each = .{ .once = &.{ | 64665 | .each = .{ .once = &.{ |
| 51348 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 64666 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, |
| 51349 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | 64667 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51350 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | | |
| 51351 | } }, | 64668 | } }, |
| 51352 | }, .{ | 64669 | }, .{ |
| 51353 | .required_features = .{ .avx, null, null, null }, | 64670 | .required_features = .{ .sse, null, null, null }, |
| 51354 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 64671 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, |
| 51355 | .dst_constraints = .{.{ .float = .qword }}, | 64672 | .dst_constraints = .{.{ .float = .xword }}, |
| 51356 | .patterns = &.{ | 64673 | .patterns = &.{ |
| 51357 | .{ .src = .{ .mem, .none, .none } }, | 64674 | .{ .src = .{ .mem, .none, .none } }, |
| 51358 | .{ .src = .{ .to_gpr, .none, .none } }, | 64675 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51359 | }, | 64676 | }, |
| | 64677 | .call_frame = .{ .alignment = .@"16" }, |
| 51360 | .extra_temps = .{ | 64678 | .extra_temps = .{ |
| 51361 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64679 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51362 | .unused, | 64680 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51363 | .unused, | 64681 | .unused, |
| 51364 | .unused, | 64682 | .unused, |
| 51365 | .unused, | 64683 | .unused, |
| ... | @@ -51368,23 +64686,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51368,23 +64686,24 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51368 | .unused, | 64686 | .unused, |
| 51369 | .unused, | 64687 | .unused, |
| 51370 | }, | 64688 | }, |
| 51371 | .dst_temps = .{.{ .rc = .sse }}, | 64689 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64690 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51372 | .each = .{ .once = &.{ | 64691 | .each = .{ .once = &.{ |
| 51373 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 64692 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, |
| 51374 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64693 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51375 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | | |
| 51376 | } }, | 64694 | } }, |
| 51377 | }, .{ | 64695 | }, .{ |
| 51378 | .required_features = .{ .sse2, null, null, null }, | 64696 | .required_features = .{ .sse, null, null, null }, |
| 51379 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 64697 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, |
| 51380 | .dst_constraints = .{.{ .float = .qword }}, | 64698 | .dst_constraints = .{.{ .float = .xword }}, |
| 51381 | .patterns = &.{ | 64699 | .patterns = &.{ |
| 51382 | .{ .src = .{ .mem, .none, .none } }, | 64700 | .{ .src = .{ .mem, .none, .none } }, |
| 51383 | .{ .src = .{ .to_gpr, .none, .none } }, | 64701 | .{ .src = .{ .to_gpr, .none, .none } }, |
| 51384 | }, | 64702 | }, |
| | 64703 | .call_frame = .{ .alignment = .@"16" }, |
| 51385 | .extra_temps = .{ | 64704 | .extra_temps = .{ |
| 51386 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64705 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51387 | .unused, | 64706 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51388 | .unused, | 64707 | .unused, |
| 51389 | .unused, | 64708 | .unused, |
| 51390 | .unused, | 64709 | .unused, |
| ... | @@ -51393,22 +64712,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51393,22 +64712,22 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51393 | .unused, | 64712 | .unused, |
| 51394 | .unused, | 64713 | .unused, |
| 51395 | }, | 64714 | }, |
| 51396 | .dst_temps = .{.{ .rc = .sse }}, | 64715 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64716 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51397 | .each = .{ .once = &.{ | 64717 | .each = .{ .once = &.{ |
| 51398 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 64718 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, |
| 51399 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | 64719 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, |
| 51400 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | | |
| 51401 | } }, | 64720 | } }, |
| 51402 | }, .{ | 64721 | }, .{ |
| 51403 | .required_features = .{ .avx, null, null, null }, | 64722 | .required_features = .{ .sse, null, null, null }, |
| 51404 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 64723 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, |
| 51405 | .dst_constraints = .{.{ .float = .qword }}, | 64724 | .dst_constraints = .{.{ .float = .xword }}, |
| 51406 | .patterns = &.{ | 64725 | .patterns = &.{ |
| 51407 | .{ .src = .{ .mem, .none, .none } }, | 64726 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 51408 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51409 | }, | 64727 | }, |
| | 64728 | .call_frame = .{ .alignment = .@"16" }, |
| 51410 | .extra_temps = .{ | 64729 | .extra_temps = .{ |
| 51411 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64730 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51412 | .unused, | 64731 | .unused, |
| 51413 | .unused, | 64732 | .unused, |
| 51414 | .unused, | 64733 | .unused, |
| ... | @@ -51418,22 +64737,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51418,22 +64737,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51418 | .unused, | 64737 | .unused, |
| 51419 | .unused, | 64738 | .unused, |
| 51420 | }, | 64739 | }, |
| 51421 | .dst_temps = .{.{ .rc = .sse }}, | 64740 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64741 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51422 | .each = .{ .once = &.{ | 64742 | .each = .{ .once = &.{ |
| 51423 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 64743 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51424 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | | |
| 51425 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | | |
| 51426 | } }, | 64744 | } }, |
| 51427 | }, .{ | 64745 | }, .{ |
| 51428 | .required_features = .{ .sse2, null, null, null }, | 64746 | .required_features = .{ .sse, null, null, null }, |
| 51429 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 64747 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, |
| 51430 | .dst_constraints = .{.{ .float = .qword }}, | 64748 | .dst_constraints = .{.{ .float = .xword }}, |
| 51431 | .patterns = &.{ | 64749 | .patterns = &.{ |
| 51432 | .{ .src = .{ .mem, .none, .none } }, | 64750 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, |
| 51433 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51434 | }, | 64751 | }, |
| | 64752 | .call_frame = .{ .alignment = .@"16" }, |
| 51435 | .extra_temps = .{ | 64753 | .extra_temps = .{ |
| 51436 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64754 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51437 | .unused, | 64755 | .unused, |
| 51438 | .unused, | 64756 | .unused, |
| 51439 | .unused, | 64757 | .unused, |
| ... | @@ -51443,22 +64761,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51443,22 +64761,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51443 | .unused, | 64761 | .unused, |
| 51444 | .unused, | 64762 | .unused, |
| 51445 | }, | 64763 | }, |
| 51446 | .dst_temps = .{.{ .rc = .sse }}, | 64764 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64765 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51447 | .each = .{ .once = &.{ | 64766 | .each = .{ .once = &.{ |
| 51448 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 64767 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51449 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | | |
| 51450 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | | |
| 51451 | } }, | 64768 | } }, |
| 51452 | }, .{ | 64769 | }, .{ |
| 51453 | .required_features = .{ .avx, null, null, null }, | 64770 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51454 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 64771 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, |
| 51455 | .dst_constraints = .{.{ .float = .qword }}, | 64772 | .dst_constraints = .{.{ .float = .xword }}, |
| 51456 | .patterns = &.{ | 64773 | .patterns = &.{ |
| 51457 | .{ .src = .{ .mem, .none, .none } }, | 64774 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 51458 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51459 | }, | 64775 | }, |
| | 64776 | .call_frame = .{ .alignment = .@"16" }, |
| 51460 | .extra_temps = .{ | 64777 | .extra_temps = .{ |
| 51461 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64778 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 51462 | .unused, | 64779 | .unused, |
| 51463 | .unused, | 64780 | .unused, |
| 51464 | .unused, | 64781 | .unused, |
| ... | @@ -51468,22 +64785,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51468,22 +64785,21 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51468 | .unused, | 64785 | .unused, |
| 51469 | .unused, | 64786 | .unused, |
| 51470 | }, | 64787 | }, |
| 51471 | .dst_temps = .{.{ .rc = .sse }}, | 64788 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64789 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51472 | .each = .{ .once = &.{ | 64790 | .each = .{ .once = &.{ |
| 51473 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 64791 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51474 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | | |
| 51475 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0d, ._ }, | | |
| 51476 | } }, | 64792 | } }, |
| 51477 | }, .{ | 64793 | }, .{ |
| 51478 | .required_features = .{ .sse2, null, null, null }, | 64794 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51479 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 64795 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, |
| 51480 | .dst_constraints = .{.{ .float = .qword }}, | 64796 | .dst_constraints = .{.{ .float = .xword }}, |
| 51481 | .patterns = &.{ | 64797 | .patterns = &.{ |
| 51482 | .{ .src = .{ .mem, .none, .none } }, | 64798 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, |
| 51483 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51484 | }, | 64799 | }, |
| | 64800 | .call_frame = .{ .alignment = .@"16" }, |
| 51485 | .extra_temps = .{ | 64801 | .extra_temps = .{ |
| 51486 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64802 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 51487 | .unused, | 64803 | .unused, |
| 51488 | .unused, | 64804 | .unused, |
| 51489 | .unused, | 64805 | .unused, |
| ... | @@ -51493,50 +64809,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51493,50 +64809,71 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51493 | .unused, | 64809 | .unused, |
| 51494 | .unused, | 64810 | .unused, |
| 51495 | }, | 64811 | }, |
| 51496 | .dst_temps = .{.{ .rc = .sse }}, | 64812 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64813 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51497 | .each = .{ .once = &.{ | 64814 | .each = .{ .once = &.{ |
| 51498 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 64815 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51499 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | | |
| 51500 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0d, ._, ._ }, | | |
| 51501 | } }, | 64816 | } }, |
| 51502 | }, .{ | 64817 | }, .{ |
| 51503 | .required_features = .{ .avx, null, null, null }, | 64818 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51504 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 64819 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, |
| 51505 | .dst_constraints = .{.{ .float = .qword }}, | 64820 | .dst_constraints = .{.{ .float = .xword }}, |
| 51506 | .patterns = &.{ | 64821 | .patterns = &.{ |
| 51507 | .{ .src = .{ .mem, .none, .none } }, | 64822 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 51508 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 64838 | .each = .{ .once = &.{ |
| 51512 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64839 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51513 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0d, ._ }, | | |
| 51514 | } }, | 64840 | } }, |
| 51515 | }, .{ | 64841 | }, .{ |
| 51516 | .required_features = .{ .sse2, null, null, null }, | 64842 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51517 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 64843 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, |
| 51518 | .dst_constraints = .{.{ .float = .qword }}, | 64844 | .dst_constraints = .{.{ .float = .xword }}, |
| 51519 | .patterns = &.{ | 64845 | .patterns = &.{ |
| 51520 | .{ .src = .{ .mem, .none, .none } }, | 64846 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, |
| 51521 | .{ .src = .{ .to_gpr, .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 | .each = .{ .once = &.{ | 64862 | .each = .{ .once = &.{ |
| 51525 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | 64863 | .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, |
| 51526 | .{ ._, ._sd, .cvtsi2, .dst0x, .src0d, ._, ._ }, | | |
| 51527 | } }, | 64864 | } }, |
| 51528 | }, .{ | 64865 | }, .{ |
| 51529 | .required_features = .{ .avx, null, null, null }, | 64866 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51530 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 64867 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51531 | .dst_constraints = .{.{ .float = .qword }}, | 64868 | .dst_constraints = .{.{ .float = .xword }}, |
| 51532 | .patterns = &.{ | 64869 | .patterns = &.{ |
| 51533 | .{ .src = .{ .mem, .none, .none } }, | 64870 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51534 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51535 | }, | 64871 | }, |
| | 64872 | .call_frame = .{ .alignment = .@"16" }, |
| 51536 | .extra_temps = .{ | 64873 | .extra_temps = .{ |
| 51537 | .{ .type = .u64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64874 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 51538 | .unused, | 64875 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 51539 | .unused, | 64876 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 51540 | .unused, | 64877 | .unused, |
| 51541 | .unused, | 64878 | .unused, |
| 51542 | .unused, | 64879 | .unused, |
| ... | @@ -51544,284 +64881,424 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51544,284 +64881,424 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51544 | .unused, | 64881 | .unused, |
| 51545 | .unused, | 64882 | .unused, |
| 51546 | }, | 64883 | }, |
| 51547 | .dst_temps = .{.{ .rc = .sse }}, | 64884 | .dst_temps = .{.{ .reg = .xmm0 }}, |
| | 64885 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51548 | .each = .{ .once = &.{ | 64886 | .each = .{ .once = &.{ |
| 51549 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 64887 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 51550 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 64888 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, |
| 51551 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .tmp0q, ._ }, | 64889 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51552 | } }, | 64890 | } }, |
| 51553 | }, .{ | 64891 | }, .{ |
| 51554 | .required_features = .{ .sse2, null, null, null }, | 64892 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 51555 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 64893 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51556 | .dst_constraints = .{.{ .float = .qword }}, | 64894 | .dst_constraints = .{.{ .float = .xword }}, |
| 51557 | .patterns = &.{ | 64895 | .patterns = &.{ |
| 51558 | .{ .src = .{ .mem, .none, .none } }, | 64896 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51559 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51560 | }, | 64897 | }, |
| | 64898 | .call_frame = .{ .alignment = .@"16" }, |
| 51561 | .extra_temps = .{ | 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 | .unused, | 64904 | .unused, |
| 51564 | .unused, | 64905 | .unused, |
| 51565 | .unused, | 64906 | .unused, |
| 51566 | .unused, | 64907 | .unused, |
| 51567 | .unused, | 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 | .unused, | 64932 | .unused, |
| 51569 | .unused, | 64933 | .unused, |
| 51570 | .unused, | 64934 | .unused, |
| 51571 | }, | 64935 | }, |
| 51572 | .dst_temps = .{.{ .rc = .sse }}, | 64936 | .dst_temps = .{.mem}, |
| | 64937 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51573 | .each = .{ .once = &.{ | 64938 | .each = .{ .once = &.{ |
| 51574 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 64939 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51575 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | 64940 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51576 | .{ ._, ._sd, .cvtsi2, .dst0x, .tmp0q, ._, ._ }, | 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 }, | 64949 | .required_features = .{ .avx, null, null, null }, |
| 51580 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 64950 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51581 | .dst_constraints = .{.{ .float = .qword }}, | 64951 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51582 | .patterns = &.{ | 64952 | .patterns = &.{ |
| 51583 | .{ .src = .{ .mem, .none, .none } }, | 64953 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51584 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51585 | }, | 64954 | }, |
| | 64955 | .call_frame = .{ .alignment = .@"16" }, |
| 51586 | .extra_temps = .{ | 64956 | .extra_temps = .{ |
| 51587 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 64957 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51588 | .{ .type = .i16, .kind = .mem }, | 64958 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51589 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 64959 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| | 64960 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| | 64961 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| | 64962 | .unused, |
| 51590 | .unused, | 64963 | .unused, |
| 51591 | .unused, | 64964 | .unused, |
| 51592 | .unused, | 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 | .unused, | 64994 | .unused, |
| 51594 | .unused, | 64995 | .unused, |
| 51595 | .unused, | 64996 | .unused, |
| 51596 | }, | 64997 | }, |
| 51597 | .dst_temps = .{.mem}, | 64998 | .dst_temps = .{.mem}, |
| | 64999 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51598 | .each = .{ .once = &.{ | 65000 | .each = .{ .once = &.{ |
| 51599 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 65001 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51600 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, | 65002 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51601 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, | 65003 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51602 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65011 | .required_features = .{ .sse2, null, null, null }, |
| 51606 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 65012 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51607 | .dst_constraints = .{.{ .float = .qword }}, | 65013 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51608 | .patterns = &.{ | 65014 | .patterns = &.{ |
| 51609 | .{ .src = .{ .mem, .none, .none } }, | 65015 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51610 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51611 | }, | 65016 | }, |
| | 65017 | .call_frame = .{ .alignment = .@"16" }, |
| 51612 | .extra_temps = .{ | 65018 | .extra_temps = .{ |
| 51613 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65019 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51614 | .{ .type = .i16, .kind = .mem }, | 65020 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51615 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65021 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| | 65022 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| | 65023 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| | 65024 | .unused, |
| | 65025 | .unused, |
| 51616 | .unused, | 65026 | .unused, |
| 51617 | .unused, | 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 | .unused, | 65055 | .unused, |
| 51619 | .unused, | 65056 | .unused, |
| 51620 | .unused, | 65057 | .unused, |
| 51621 | .unused, | 65058 | .unused, |
| 51622 | }, | 65059 | }, |
| 51623 | .dst_temps = .{.mem}, | 65060 | .dst_temps = .{.mem}, |
| | 65061 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51624 | .each = .{ .once = &.{ | 65062 | .each = .{ .once = &.{ |
| 51625 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 65063 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51626 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, | 65064 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51627 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, | 65065 | .{ .@"0:", ._, .movsx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51628 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65073 | .required_features = .{ .sse, null, null, null }, |
| 51632 | .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any }, | 65074 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51633 | .dst_constraints = .{.{ .float = .qword }}, | 65075 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51634 | .patterns = &.{ | 65076 | .patterns = &.{ |
| 51635 | .{ .src = .{ .to_mem, .none, .none } }, | 65077 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51636 | }, | 65078 | }, |
| | 65079 | .call_frame = .{ .alignment = .@"16" }, |
| 51637 | .extra_temps = .{ | 65080 | .extra_temps = .{ |
| 51638 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65081 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51639 | .unused, | 65082 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51640 | .unused, | 65083 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51641 | .unused, | 65084 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51642 | .unused, | 65085 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51643 | .unused, | 65086 | .unused, |
| 51644 | .unused, | 65087 | .unused, |
| 51645 | .unused, | 65088 | .unused, |
| 51646 | .unused, | 65089 | .unused, |
| 51647 | }, | 65090 | }, |
| 51648 | .dst_temps = .{.mem}, | 65091 | .dst_temps = .{.mem}, |
| | 65092 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51649 | .each = .{ .once = &.{ | 65093 | .each = .{ .once = &.{ |
| 51650 | .{ ._, .fi_, .ld, .src0w, ._, ._, ._ }, | 65094 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51651 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65104 | .required_features = .{ .avx, .slow_incdec, null, null }, |
| 51655 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any }, | 65105 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51656 | .dst_constraints = .{.{ .float = .qword }}, | 65106 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51657 | .patterns = &.{ | 65107 | .patterns = &.{ |
| 51658 | .{ .src = .{ .mem, .none, .none } }, | 65108 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51659 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51660 | }, | 65109 | }, |
| | 65110 | .call_frame = .{ .alignment = .@"16" }, |
| 51661 | .extra_temps = .{ | 65111 | .extra_temps = .{ |
| 51662 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65112 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51663 | .{ .type = .i32, .kind = .mem }, | 65113 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51664 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65114 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51665 | .unused, | 65115 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51666 | .unused, | 65116 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51667 | .unused, | 65117 | .unused, |
| 51668 | .unused, | 65118 | .unused, |
| 51669 | .unused, | 65119 | .unused, |
| 51670 | .unused, | 65120 | .unused, |
| 51671 | }, | 65121 | }, |
| 51672 | .dst_temps = .{.mem}, | 65122 | .dst_temps = .{.mem}, |
| | 65123 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51673 | .each = .{ .once = &.{ | 65124 | .each = .{ .once = &.{ |
| 51674 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 65125 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51675 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, | 65126 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51676 | .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ }, | 65127 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51677 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65135 | .required_features = .{ .avx, null, null, null }, |
| 51681 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 65136 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51682 | .dst_constraints = .{.{ .float = .qword }}, | 65137 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51683 | .patterns = &.{ | 65138 | .patterns = &.{ |
| 51684 | .{ .src = .{ .to_mem, .none, .none } }, | 65139 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51685 | }, | 65140 | }, |
| | 65141 | .call_frame = .{ .alignment = .@"16" }, |
| 51686 | .extra_temps = .{ | 65142 | .extra_temps = .{ |
| 51687 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65143 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51688 | .unused, | 65144 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51689 | .unused, | 65145 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51690 | .unused, | 65146 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51691 | .unused, | 65147 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51692 | .unused, | 65148 | .unused, |
| 51693 | .unused, | 65149 | .unused, |
| 51694 | .unused, | 65150 | .unused, |
| 51695 | .unused, | 65151 | .unused, |
| 51696 | }, | 65152 | }, |
| 51697 | .dst_temps = .{.mem}, | 65153 | .dst_temps = .{.mem}, |
| | 65154 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51698 | .each = .{ .once = &.{ | 65155 | .each = .{ .once = &.{ |
| 51699 | .{ ._, .fi_, .ld, .src0d, ._, ._, ._ }, | 65156 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51700 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65166 | .required_features = .{ .sse2, .slow_incdec, null, null }, |
| 51704 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 65167 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51705 | .dst_constraints = .{.{ .float = .qword }}, | 65168 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51706 | .patterns = &.{ | 65169 | .patterns = &.{ |
| 51707 | .{ .src = .{ .mem, .none, .none } }, | 65170 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51708 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51709 | }, | 65171 | }, |
| | 65172 | .call_frame = .{ .alignment = .@"16" }, |
| 51710 | .extra_temps = .{ | 65173 | .extra_temps = .{ |
| 51711 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65174 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51712 | .{ .type = .i64, .kind = .mem }, | 65175 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51713 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65176 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51714 | .unused, | 65177 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51715 | .unused, | 65178 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51716 | .unused, | 65179 | .unused, |
| 51717 | .unused, | 65180 | .unused, |
| 51718 | .unused, | 65181 | .unused, |
| 51719 | .unused, | 65182 | .unused, |
| 51720 | }, | 65183 | }, |
| 51721 | .dst_temps = .{.mem}, | 65184 | .dst_temps = .{.mem}, |
| | 65185 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51722 | .each = .{ .once = &.{ | 65186 | .each = .{ .once = &.{ |
| 51723 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 65187 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51724 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, | 65188 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51725 | .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ }, | 65189 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51726 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65197 | .required_features = .{ .sse2, null, null, null }, |
| 51730 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 65198 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51731 | .dst_constraints = .{.{ .float = .qword }}, | 65199 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51732 | .patterns = &.{ | 65200 | .patterns = &.{ |
| 51733 | .{ .src = .{ .mem, .none, .none } }, | 65201 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51734 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51735 | }, | 65202 | }, |
| 51736 | .dst_temps = .{.{ .rc = .sse }}, | 65203 | .call_frame = .{ .alignment = .@"16" }, |
| 51737 | .each = .{ .once = &.{ | 65204 | .extra_temps = .{ |
| 51738 | .{ ._, .v_pd, .xor, .dst0x, .dst0x, .dst0x, ._ }, | 65205 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51739 | .{ ._, .v_sd, .cvtsi2, .dst0x, .dst0x, .src0q, ._ }, | 65206 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51740 | } }, | 65207 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51741 | }, .{ | 65208 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51742 | .required_features = .{ .@"64bit", .sse2, null, null }, | 65209 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51743 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 65210 | .unused, |
| 51744 | .dst_constraints = .{.{ .float = .qword }}, | 65211 | .unused, |
| 51745 | .patterns = &.{ | 65212 | .unused, |
| 51746 | .{ .src = .{ .mem, .none, .none } }, | 65213 | .unused, |
| 51747 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51748 | }, | 65214 | }, |
| 51749 | .dst_temps = .{.{ .rc = .sse }}, | 65215 | .dst_temps = .{.mem}, |
| | 65216 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51750 | .each = .{ .once = &.{ | 65217 | .each = .{ .once = &.{ |
| 51751 | .{ ._, ._pd, .xor, .dst0x, .dst0x, ._, ._ }, | 65218 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51752 | .{ ._, ._sd, .cvtsi2, .dst0x, .src0q, ._, ._ }, | 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 }, | 65228 | .required_features = .{ .sse, .slow_incdec, null, null }, |
| 51756 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 65229 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51757 | .dst_constraints = .{.{ .float = .qword }}, | 65230 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51758 | .patterns = &.{ | 65231 | .patterns = &.{ |
| 51759 | .{ .src = .{ .mem, .none, .none } }, | 65232 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51760 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51761 | }, | 65233 | }, |
| | 65234 | .call_frame = .{ .alignment = .@"16" }, |
| 51762 | .extra_temps = .{ | 65235 | .extra_temps = .{ |
| 51763 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, | 65236 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51764 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 65237 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51765 | .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem }, | 65238 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51766 | .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem }, | 65239 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51767 | .unused, | 65240 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51768 | .unused, | 65241 | .unused, |
| 51769 | .unused, | 65242 | .unused, |
| 51770 | .unused, | 65243 | .unused, |
| 51771 | .unused, | 65244 | .unused, |
| 51772 | }, | 65245 | }, |
| 51773 | .dst_temps = .{.{ .rc = .sse }}, | 65246 | .dst_temps = .{.mem}, |
| | 65247 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51774 | .each = .{ .once = &.{ | 65248 | .each = .{ .once = &.{ |
| 51775 | .{ ._, .v_q, .mov, .tmp0x, .src0q, ._, ._ }, | 65249 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51776 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, | 65250 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51777 | .{ ._, .vp_, .unpckldq, .tmp0x, .tmp0x, .lea(.tmp1x), ._ }, | 65251 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51778 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, | 65252 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 51779 | .{ ._, .v_pd, .sub, .tmp0x, .tmp0x, .lea(.tmp1x), ._ }, | 65253 | .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 51780 | .{ ._, .v_pd, .unpckh, .dst0x, .tmp0x, .tmp0x, ._ }, | 65254 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 51781 | .{ ._, .v_sd, .add, .dst0x, .dst0x, .tmp0x, ._ }, | 65255 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 65256 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 51782 | } }, | 65257 | } }, |
| 51783 | }, .{ | 65258 | }, .{ |
| 51784 | .required_features = .{ .@"64bit", .sse2, null, null }, | 65259 | .required_features = .{ .sse, null, null, null }, |
| 51785 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 65260 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, .any, .any }, |
| 51786 | .dst_constraints = .{.{ .float = .qword }}, | 65261 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51787 | .patterns = &.{ | 65262 | .patterns = &.{ |
| 51788 | .{ .src = .{ .mem, .none, .none } }, | 65263 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51789 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51790 | }, | 65264 | }, |
| | 65265 | .call_frame = .{ .alignment = .@"16" }, |
| 51791 | .extra_temps = .{ | 65266 | .extra_temps = .{ |
| 51792 | .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, | 65267 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51793 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 65268 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 51794 | .{ .type = .vector_4_u32, .kind = .u32_0x1p52_hi_0x1p84_hi_0_0_mem }, | 65269 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51795 | .{ .type = .vector_2_f64, .kind = .f64_0x1p52_0x1p84_mem }, | 65270 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51796 | .unused, | 65271 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51797 | .unused, | 65272 | .unused, |
| 51798 | .unused, | 65273 | .unused, |
| 51799 | .unused, | 65274 | .unused, |
| 51800 | .unused, | 65275 | .unused, |
| 51801 | }, | 65276 | }, |
| 51802 | .dst_temps = .{.{ .rc = .sse }}, | 65277 | .dst_temps = .{.mem}, |
| | 65278 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51803 | .each = .{ .once = &.{ | 65279 | .each = .{ .once = &.{ |
| 51804 | .{ ._, ._q, .mov, .tmp0x, .src0q, ._, ._ }, | 65280 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51805 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp2), ._, ._ }, | 65281 | .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, |
| 51806 | .{ ._, .p_, .unpckldq, .tmp0x, .lea(.tmp1x), ._, ._ }, | 65282 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51807 | .{ ._, ._, .lea, .tmp1p, .mem(.tmp3), ._, ._ }, | 65283 | .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, |
| 51808 | .{ ._, ._pd, .sub, .tmp0x, .lea(.tmp1x), ._, ._ }, | 65284 | .{ ._, ._ps, .mova, .lea(.tmp1x), .tmp4x, ._, ._ }, |
| 51809 | .{ ._, ._pd, .mova, .dst0x, .tmp0x, ._, ._ }, | 65285 | .{ ._, ._, .lea, .tmp1p, .lead(.tmp1, 16), ._, ._ }, |
| 51810 | .{ ._, ._pd, .unpckh, .dst0x, .dst0x, ._, ._ }, | 65286 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 51811 | .{ ._, ._sd, .add, .dst0x, .tmp0x, ._, ._ }, | 65287 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 51812 | } }, | 65288 | } }, |
| 51813 | }, .{ | 65289 | }, .{ |
| 51814 | .required_features = .{ .x87, null, null, null }, | 65290 | .required_features = .{ .avx, null, null, null }, |
| 51815 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 65291 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51816 | .dst_constraints = .{.{ .float = .qword }}, | 65292 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51817 | .patterns = &.{ | 65293 | .patterns = &.{ |
| 51818 | .{ .src = .{ .to_mem, .none, .none } }, | 65294 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51819 | }, | 65295 | }, |
| | 65296 | .call_frame = .{ .alignment = .@"16" }, |
| 51820 | .extra_temps = .{ | 65297 | .extra_temps = .{ |
| 51821 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65298 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51822 | .unused, | 65299 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51823 | .unused, | 65300 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51824 | .unused, | 65301 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51825 | .unused, | 65302 | .unused, |
| 51826 | .unused, | 65303 | .unused, |
| 51827 | .unused, | 65304 | .unused, |
| ... | @@ -51829,22 +65306,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51829,22 +65306,28 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51829 | .unused, | 65306 | .unused, |
| 51830 | }, | 65307 | }, |
| 51831 | .dst_temps = .{.mem}, | 65308 | .dst_temps = .{.mem}, |
| | 65309 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51832 | .each = .{ .once = &.{ | 65310 | .each = .{ .once = &.{ |
| 51833 | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, | 65311 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51834 | .{ ._, .f_p, .st, .dst0q, ._, ._, ._ }, | 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 }, | 65319 | .required_features = .{ .sse2, null, null, null }, |
| 51838 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 65320 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51839 | .dst_constraints = .{.{ .float = .qword }}, | 65321 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51840 | .patterns = &.{ | 65322 | .patterns = &.{ |
| 51841 | .{ .src = .{ .to_mut_gpr, .none, .none } }, | 65323 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51842 | }, | 65324 | }, |
| | 65325 | .call_frame = .{ .alignment = .@"16" }, |
| 51843 | .extra_temps = .{ | 65326 | .extra_temps = .{ |
| 51844 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, | 65327 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51845 | .{ .type = .f64, .kind = .{ .reg = .st7 } }, | 65328 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51846 | .unused, | 65329 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51847 | .unused, | 65330 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51848 | .unused, | 65331 | .unused, |
| 51849 | .unused, | 65332 | .unused, |
| 51850 | .unused, | 65333 | .unused, |
| ... | @@ -51852,723 +65335,850 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -51852,723 +65335,850 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 51852 | .unused, | 65335 | .unused, |
| 51853 | }, | 65336 | }, |
| 51854 | .dst_temps = .{.mem}, | 65337 | .dst_temps = .{.mem}, |
| 51855 | .clobbers = .{ .eflags = true }, | 65338 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51856 | .each = .{ .once = &.{ | 65339 | .each = .{ .once = &.{ |
| 51857 | .{ ._, ._, .@"test", .src0q, .src0q, ._, ._ }, | 65340 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51858 | .{ ._, ._ns, .j, .@"1f", ._, ._, ._ }, | 65341 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51859 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 65342 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51860 | .{ ._, ._r, .sh, .src0q, .ui(1), ._, ._ }, | 65343 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"8", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 51861 | .{ ._, ._, .@"and", .tmp0d, .si(1), ._, ._ }, | 65344 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| 51862 | .{ ._, ._, .@"or", .src0q, .tmp0q, ._, ._ }, | 65345 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 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, ._, ._, ._ }, | | |
| 51871 | } }, | 65346 | } }, |
| 51872 | }, .{ | 65347 | }, .{ |
| 51873 | .required_features = .{ .@"64bit", .sse, null, null }, | 65348 | .required_features = .{ .sse, null, null, null }, |
| 51874 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, | 65349 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51875 | .dst_constraints = .{.{ .float = .qword }}, | 65350 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51876 | .patterns = &.{ | 65351 | .patterns = &.{ |
| 51877 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 65352 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51878 | }, | 65353 | }, |
| 51879 | .call_frame = .{ .alignment = .@"16" }, | 65354 | .call_frame = .{ .alignment = .@"16" }, |
| 51880 | .extra_temps = .{ | 65355 | .extra_temps = .{ |
| 51881 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattidf" } } }, | 65356 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51882 | .unused, | 65357 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51883 | .unused, | 65358 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51884 | .unused, | 65359 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51885 | .unused, | 65360 | .unused, |
| 51886 | .unused, | 65361 | .unused, |
| 51887 | .unused, | 65362 | .unused, |
| 51888 | .unused, | 65363 | .unused, |
| 51889 | .unused, | 65364 | .unused, |
| 51890 | }, | 65365 | }, |
| 51891 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65366 | .dst_temps = .{.mem}, |
| 51892 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65367 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51893 | .each = .{ .once = &.{ | 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 }, | 65377 | .required_features = .{ .avx, null, null, null }, |
| 51898 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, | 65378 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51899 | .dst_constraints = .{.{ .float = .qword }}, | 65379 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51900 | .patterns = &.{ | 65380 | .patterns = &.{ |
| 51901 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 65381 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51902 | }, | 65382 | }, |
| 51903 | .call_frame = .{ .alignment = .@"16" }, | 65383 | .call_frame = .{ .alignment = .@"16" }, |
| 51904 | .extra_temps = .{ | 65384 | .extra_temps = .{ |
| 51905 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntidf" } } }, | 65385 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51906 | .unused, | 65386 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51907 | .unused, | 65387 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51908 | .unused, | 65388 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51909 | .unused, | 65389 | .unused, |
| 51910 | .unused, | 65390 | .unused, |
| 51911 | .unused, | 65391 | .unused, |
| 51912 | .unused, | 65392 | .unused, |
| 51913 | .unused, | 65393 | .unused, |
| 51914 | }, | 65394 | }, |
| 51915 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65395 | .dst_temps = .{.mem}, |
| 51916 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65396 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51917 | .each = .{ .once = &.{ | 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 }, | 65406 | .required_features = .{ .sse2, null, null, null }, |
| 51922 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 65407 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51923 | .dst_constraints = .{.{ .float = .qword }}, | 65408 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51924 | .patterns = &.{ | 65409 | .patterns = &.{ |
| 51925 | .{ .src = .{ .to_mem, .none, .none } }, | 65410 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51926 | }, | 65411 | }, |
| 51927 | .call_frame = .{ .alignment = .@"16" }, | 65412 | .call_frame = .{ .alignment = .@"16" }, |
| 51928 | .extra_temps = .{ | 65413 | .extra_temps = .{ |
| 51929 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 65414 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51930 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 65415 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51931 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateidf" } } }, | 65416 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51932 | .unused, | 65417 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51933 | .unused, | 65418 | .unused, |
| 51934 | .unused, | 65419 | .unused, |
| 51935 | .unused, | 65420 | .unused, |
| 51936 | .unused, | 65421 | .unused, |
| 51937 | .unused, | 65422 | .unused, |
| 51938 | }, | 65423 | }, |
| 51939 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65424 | .dst_temps = .{.mem}, |
| 51940 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65425 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51941 | .each = .{ .once = &.{ | 65426 | .each = .{ .once = &.{ |
| 51942 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 65427 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51943 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 65428 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51944 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 65435 | .required_features = .{ .sse, null, null, null }, |
| 51948 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 65436 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, .any, .any }, |
| 51949 | .dst_constraints = .{.{ .float = .qword }}, | 65437 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51950 | .patterns = &.{ | 65438 | .patterns = &.{ |
| 51951 | .{ .src = .{ .to_mem, .none, .none } }, | 65439 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51952 | }, | 65440 | }, |
| 51953 | .call_frame = .{ .alignment = .@"16" }, | 65441 | .call_frame = .{ .alignment = .@"16" }, |
| 51954 | .extra_temps = .{ | 65442 | .extra_temps = .{ |
| 51955 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 65443 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51956 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 65444 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 51957 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneidf" } } }, | 65445 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 51958 | .unused, | 65446 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51959 | .unused, | 65447 | .unused, |
| 51960 | .unused, | 65448 | .unused, |
| 51961 | .unused, | 65449 | .unused, |
| 51962 | .unused, | 65450 | .unused, |
| 51963 | .unused, | 65451 | .unused, |
| 51964 | }, | 65452 | }, |
| 51965 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65453 | .dst_temps = .{.mem}, |
| 51966 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65454 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51967 | .each = .{ .once = &.{ | 65455 | .each = .{ .once = &.{ |
| 51968 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 65456 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51969 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 65457 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51970 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 65464 | .required_features = .{ .avx, null, null, null }, |
| 51974 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 65465 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 51975 | .dst_constraints = .{.{ .float = .tbyte }}, | 65466 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 51976 | .patterns = &.{ | 65467 | .patterns = &.{ |
| 51977 | .{ .src = .{ .mem, .none, .none } }, | 65468 | .{ .src = .{ .to_mem, .none, .none } }, |
| 51978 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 51979 | }, | 65469 | }, |
| | 65470 | .call_frame = .{ .alignment = .@"16" }, |
| 51980 | .extra_temps = .{ | 65471 | .extra_temps = .{ |
| 51981 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65472 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 51982 | .{ .type = .i16, .kind = .mem }, | 65473 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 51983 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65474 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 51984 | .unused, | 65475 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 51985 | .unused, | 65476 | .unused, |
| 51986 | .unused, | 65477 | .unused, |
| 51987 | .unused, | 65478 | .unused, |
| 51988 | .unused, | 65479 | .unused, |
| 51989 | .unused, | 65480 | .unused, |
| 51990 | }, | 65481 | }, |
| 51991 | .dst_temps = .{.{ .rc = .x87 }}, | 65482 | .dst_temps = .{.mem}, |
| | 65483 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 51992 | .each = .{ .once = &.{ | 65484 | .each = .{ .once = &.{ |
| 51993 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 65485 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 51994 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, | 65486 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 51995 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, | 65487 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 51996 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65493 | .required_features = .{ .sse2, null, null, null }, |
| 52000 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 65494 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52001 | .dst_constraints = .{.{ .float = .tbyte }}, | 65495 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52002 | .patterns = &.{ | 65496 | .patterns = &.{ |
| 52003 | .{ .src = .{ .mem, .none, .none } }, | 65497 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52004 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52005 | }, | 65498 | }, |
| | 65499 | .call_frame = .{ .alignment = .@"16" }, |
| 52006 | .extra_temps = .{ | 65500 | .extra_temps = .{ |
| 52007 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65501 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52008 | .{ .type = .i16, .kind = .mem }, | 65502 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 52009 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65503 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 52010 | .unused, | 65504 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52011 | .unused, | 65505 | .unused, |
| 52012 | .unused, | 65506 | .unused, |
| 52013 | .unused, | 65507 | .unused, |
| 52014 | .unused, | 65508 | .unused, |
| 52015 | .unused, | 65509 | .unused, |
| 52016 | }, | 65510 | }, |
| 52017 | .dst_temps = .{.{ .rc = .x87 }}, | 65511 | .dst_temps = .{.mem}, |
| | 65512 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52018 | .each = .{ .once = &.{ | 65513 | .each = .{ .once = &.{ |
| 52019 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 65514 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52020 | .{ ._, ._, .mov, .tmp1w, .tmp0w, ._, ._ }, | 65515 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52021 | .{ ._, .fi_, .ld, .tmp1w, ._, ._, ._ }, | 65516 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52022 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65522 | .required_features = .{ .sse, null, null, null }, |
| 52026 | .src_constraints = .{ .{ .signed_or_exclusive_int = .word }, .any, .any }, | 65523 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52027 | .dst_constraints = .{.{ .float = .tbyte }}, | 65524 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52028 | .patterns = &.{ | 65525 | .patterns = &.{ |
| 52029 | .{ .src = .{ .to_mem, .none, .none } }, | 65526 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52030 | }, | 65527 | }, |
| | 65528 | .call_frame = .{ .alignment = .@"16" }, |
| 52031 | .extra_temps = .{ | 65529 | .extra_temps = .{ |
| 52032 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65530 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52033 | .unused, | 65531 | .{ .type = .i32, .kind = .{ .reg = .edi } }, |
| 52034 | .unused, | 65532 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, |
| 52035 | .unused, | 65533 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52036 | .unused, | 65534 | .unused, |
| 52037 | .unused, | 65535 | .unused, |
| 52038 | .unused, | 65536 | .unused, |
| 52039 | .unused, | 65537 | .unused, |
| 52040 | .unused, | 65538 | .unused, |
| 52041 | }, | 65539 | }, |
| 52042 | .dst_temps = .{.{ .rc = .x87 }}, | 65540 | .dst_temps = .{.mem}, |
| | 65541 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52043 | .each = .{ .once = &.{ | 65542 | .each = .{ .once = &.{ |
| 52044 | .{ ._, .fi_, .ld, .src0w, ._, ._, ._ }, | 65543 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52045 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65551 | .required_features = .{ .avx, null, null, null }, |
| 52049 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .any, .any }, | 65552 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52050 | .dst_constraints = .{.{ .float = .tbyte }}, | 65553 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52051 | .patterns = &.{ | 65554 | .patterns = &.{ |
| 52052 | .{ .src = .{ .mem, .none, .none } }, | 65555 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52053 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52054 | }, | 65556 | }, |
| | 65557 | .call_frame = .{ .alignment = .@"16" }, |
| 52055 | .extra_temps = .{ | 65558 | .extra_temps = .{ |
| 52056 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52057 | .{ .type = .i32, .kind = .mem }, | 65560 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 52058 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65561 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 52059 | .unused, | 65562 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52060 | .unused, | 65563 | .unused, |
| 52061 | .unused, | 65564 | .unused, |
| 52062 | .unused, | 65565 | .unused, |
| 52063 | .unused, | 65566 | .unused, |
| 52064 | .unused, | 65567 | .unused, |
| 52065 | }, | 65568 | }, |
| 52066 | .dst_temps = .{.{ .rc = .x87 }}, | 65569 | .dst_temps = .{.mem}, |
| | 65570 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52067 | .each = .{ .once = &.{ | 65571 | .each = .{ .once = &.{ |
| 52068 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 65572 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52069 | .{ ._, ._, .mov, .tmp1d, .tmp0d, ._, ._ }, | 65573 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52070 | .{ ._, .fi_, .ld, .tmp1d, ._, ._, ._ }, | 65574 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52071 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65580 | .required_features = .{ .sse2, null, null, null }, |
| 52075 | .src_constraints = .{ .{ .signed_or_exclusive_int = .dword }, .any, .any }, | 65581 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52076 | .dst_constraints = .{.{ .float = .tbyte }}, | 65582 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52077 | .patterns = &.{ | 65583 | .patterns = &.{ |
| 52078 | .{ .src = .{ .to_mem, .none, .none } }, | 65584 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52079 | }, | 65585 | }, |
| | 65586 | .call_frame = .{ .alignment = .@"16" }, |
| 52080 | .extra_temps = .{ | 65587 | .extra_temps = .{ |
| 52081 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65588 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52082 | .unused, | 65589 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 52083 | .unused, | 65590 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 52084 | .unused, | 65591 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52085 | .unused, | 65592 | .unused, |
| 52086 | .unused, | 65593 | .unused, |
| 52087 | .unused, | 65594 | .unused, |
| 52088 | .unused, | 65595 | .unused, |
| 52089 | .unused, | 65596 | .unused, |
| 52090 | }, | 65597 | }, |
| 52091 | .dst_temps = .{.{ .rc = .x87 }}, | 65598 | .dst_temps = .{.mem}, |
| | 65599 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52092 | .each = .{ .once = &.{ | 65600 | .each = .{ .once = &.{ |
| 52093 | .{ ._, .fi_, .ld, .src0d, ._, ._, ._ }, | 65601 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52094 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65609 | .required_features = .{ .sse, null, null, null }, |
| 52098 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .any, .any }, | 65610 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52099 | .dst_constraints = .{.{ .float = .tbyte }}, | 65611 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52100 | .patterns = &.{ | 65612 | .patterns = &.{ |
| 52101 | .{ .src = .{ .mem, .none, .none } }, | 65613 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52102 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52103 | }, | 65614 | }, |
| | 65615 | .call_frame = .{ .alignment = .@"16" }, |
| 52104 | .extra_temps = .{ | 65616 | .extra_temps = .{ |
| 52105 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } } }, | 65617 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52106 | .{ .type = .i64, .kind = .mem }, | 65618 | .{ .type = .u32, .kind = .{ .reg = .edi } }, |
| 52107 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65619 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, |
| 52108 | .unused, | 65620 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52109 | .unused, | 65621 | .unused, |
| 52110 | .unused, | 65622 | .unused, |
| 52111 | .unused, | 65623 | .unused, |
| 52112 | .unused, | 65624 | .unused, |
| 52113 | .unused, | 65625 | .unused, |
| 52114 | }, | 65626 | }, |
| 52115 | .dst_temps = .{.{ .rc = .x87 }}, | 65627 | .dst_temps = .{.mem}, |
| | 65628 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52116 | .each = .{ .once = &.{ | 65629 | .each = .{ .once = &.{ |
| 52117 | .{ ._, ._, .mov, .tmp0d, .src0d, ._, ._ }, | 65630 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52118 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, | 65631 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52119 | .{ ._, .fi_, .ld, .tmp1q, ._, ._, ._ }, | 65632 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52120 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65638 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52124 | .src_constraints = .{ .{ .signed_or_exclusive_int = .qword }, .any, .any }, | 65639 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52125 | .dst_constraints = .{.{ .float = .tbyte }}, | 65640 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52126 | .patterns = &.{ | 65641 | .patterns = &.{ |
| 52127 | .{ .src = .{ .to_mem, .none, .none } }, | 65642 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52128 | }, | 65643 | }, |
| | 65644 | .call_frame = .{ .alignment = .@"16" }, |
| 52129 | .extra_temps = .{ | 65645 | .extra_temps = .{ |
| 52130 | .{ .type = .f80, .kind = .{ .reg = .st7 } }, | 65646 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52131 | .unused, | 65647 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 52132 | .unused, | 65648 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 52133 | .unused, | 65649 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52134 | .unused, | 65650 | .unused, |
| 52135 | .unused, | 65651 | .unused, |
| 52136 | .unused, | 65652 | .unused, |
| 52137 | .unused, | 65653 | .unused, |
| 52138 | .unused, | 65654 | .unused, |
| 52139 | }, | 65655 | }, |
| 52140 | .dst_temps = .{.{ .rc = .x87 }}, | 65656 | .dst_temps = .{.mem}, |
| | 65657 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52141 | .each = .{ .once = &.{ | 65658 | .each = .{ .once = &.{ |
| 52142 | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, | 65659 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52143 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 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 }, | 65667 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52147 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .any, .any }, | 65668 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52148 | .dst_constraints = .{.{ .float = .tbyte }}, | 65669 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52149 | .patterns = &.{ | 65670 | .patterns = &.{ |
| 52150 | .{ .src = .{ .to_mem, .none, .none } }, | 65671 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52151 | }, | 65672 | }, |
| | 65673 | .call_frame = .{ .alignment = .@"16" }, |
| 52152 | .extra_temps = .{ | 65674 | .extra_temps = .{ |
| 52153 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 65675 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52154 | .{ .type = .u1, .kind = .{ .rc = .general_purpose } }, | 65676 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 52155 | .{ .type = .vector_2_f32, .kind = .f32_0_0x1p64_mem }, | 65677 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 52156 | .unused, | 65678 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52157 | .unused, | 65679 | .unused, |
| 52158 | .unused, | 65680 | .unused, |
| 52159 | .unused, | 65681 | .unused, |
| 52160 | .unused, | 65682 | .unused, |
| 52161 | .unused, | 65683 | .unused, |
| 52162 | }, | 65684 | }, |
| 52163 | .dst_temps = .{.{ .rc = .x87 }}, | 65685 | .dst_temps = .{.mem}, |
| 52164 | .clobbers = .{ .eflags = true }, | 65686 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52165 | .each = .{ .once = &.{ | 65687 | .each = .{ .once = &.{ |
| 52166 | .{ ._, .fi_, .ld, .src0q, ._, ._, ._ }, | 65688 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52167 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, | 65689 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52168 | .{ ._, ._, .mov, .tmp1d, .memd(.src0d, 4), ._, ._ }, | 65690 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, |
| 52169 | .{ ._, ._r, .sh, .tmp1d, .ui(31), ._, ._ }, | 65691 | .{ ._, ._dqa, .mov, .memsia(.dst0x, .@"2", .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| 52170 | .{ ._, .f_, .add, .leasi(.tmp0d, .@"4", .tmp1), ._, ._, ._ }, | 65692 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| 52171 | .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, | 65693 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| 52172 | } }, | 65694 | } }, |
| 52173 | }, .{ | 65695 | }, .{ |
| 52174 | .required_features = .{ .@"64bit", .sse, null, null }, | 65696 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52175 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, | 65697 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52176 | .dst_constraints = .{.{ .float = .tbyte }}, | 65698 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52177 | .patterns = &.{ | 65699 | .patterns = &.{ |
| 52178 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 65700 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52179 | }, | 65701 | }, |
| 52180 | .call_frame = .{ .alignment = .@"16" }, | 65702 | .call_frame = .{ .alignment = .@"16" }, |
| 52181 | .extra_temps = .{ | 65703 | .extra_temps = .{ |
| 52182 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattixf" } } }, | 65704 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52183 | .unused, | 65705 | .{ .type = .i64, .kind = .{ .reg = .rdi } }, |
| 52184 | .unused, | 65706 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, |
| 52185 | .unused, | 65707 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52186 | .unused, | 65708 | .unused, |
| 52187 | .unused, | 65709 | .unused, |
| 52188 | .unused, | 65710 | .unused, |
| 52189 | .unused, | 65711 | .unused, |
| 52190 | .unused, | 65712 | .unused, |
| 52191 | }, | 65713 | }, |
| 52192 | .dst_temps = .{.{ .reg = .st0 }}, | 65714 | .dst_temps = .{.mem}, |
| 52193 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65715 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52194 | .each = .{ .once = &.{ | 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 }, | 65725 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52199 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, | 65726 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52200 | .dst_constraints = .{.{ .float = .tbyte }}, | 65727 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52201 | .patterns = &.{ | 65728 | .patterns = &.{ |
| 52202 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 65729 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52203 | }, | 65730 | }, |
| 52204 | .call_frame = .{ .alignment = .@"16" }, | 65731 | .call_frame = .{ .alignment = .@"16" }, |
| 52205 | .extra_temps = .{ | 65732 | .extra_temps = .{ |
| 52206 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntixf" } } }, | 65733 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52207 | .unused, | 65734 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52208 | .unused, | 65735 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 52209 | .unused, | 65736 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52210 | .unused, | 65737 | .unused, |
| 52211 | .unused, | 65738 | .unused, |
| 52212 | .unused, | 65739 | .unused, |
| 52213 | .unused, | 65740 | .unused, |
| 52214 | .unused, | 65741 | .unused, |
| 52215 | }, | 65742 | }, |
| 52216 | .dst_temps = .{.{ .reg = .st0 }}, | 65743 | .dst_temps = .{.mem}, |
| 52217 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65744 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52218 | .each = .{ .once = &.{ | 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 }, | 65754 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52223 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 65755 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52224 | .dst_constraints = .{.{ .float = .tbyte }}, | 65756 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52225 | .patterns = &.{ | 65757 | .patterns = &.{ |
| 52226 | .{ .src = .{ .to_mem, .none, .none } }, | 65758 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52227 | }, | 65759 | }, |
| 52228 | .call_frame = .{ .alignment = .@"16" }, | 65760 | .call_frame = .{ .alignment = .@"16" }, |
| 52229 | .extra_temps = .{ | 65761 | .extra_temps = .{ |
| 52230 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 65762 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52231 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 65763 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52232 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateixf" } } }, | 65764 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 52233 | .unused, | 65765 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52234 | .unused, | 65766 | .unused, |
| 52235 | .unused, | 65767 | .unused, |
| 52236 | .unused, | 65768 | .unused, |
| 52237 | .unused, | 65769 | .unused, |
| 52238 | .unused, | 65770 | .unused, |
| 52239 | }, | 65771 | }, |
| 52240 | .dst_temps = .{.{ .reg = .st0 }}, | 65772 | .dst_temps = .{.mem}, |
| 52241 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65773 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52242 | .each = .{ .once = &.{ | 65774 | .each = .{ .once = &.{ |
| 52243 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 65775 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52244 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 65776 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52245 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 65783 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52249 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 65784 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, .any, .any }, |
| 52250 | .dst_constraints = .{.{ .float = .tbyte }}, | 65785 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52251 | .patterns = &.{ | 65786 | .patterns = &.{ |
| 52252 | .{ .src = .{ .to_mem, .none, .none } }, | 65787 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52253 | }, | 65788 | }, |
| 52254 | .call_frame = .{ .alignment = .@"16" }, | 65789 | .call_frame = .{ .alignment = .@"16" }, |
| 52255 | .extra_temps = .{ | 65790 | .extra_temps = .{ |
| 52256 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 65791 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52257 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 65792 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52258 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneixf" } } }, | 65793 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, |
| 52259 | .unused, | 65794 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52260 | .unused, | 65795 | .unused, |
| 52261 | .unused, | 65796 | .unused, |
| 52262 | .unused, | 65797 | .unused, |
| 52263 | .unused, | 65798 | .unused, |
| 52264 | .unused, | 65799 | .unused, |
| 52265 | }, | 65800 | }, |
| 52266 | .dst_temps = .{.{ .reg = .st0 }}, | 65801 | .dst_temps = .{.mem}, |
| 52267 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65802 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52268 | .each = .{ .once = &.{ | 65803 | .each = .{ .once = &.{ |
| 52269 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 65804 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52270 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 65805 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| 52271 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 }, | 65812 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52275 | .src_constraints = .{ .{ .signed_int = .byte }, .any, .any }, | 65813 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 52276 | .dst_constraints = .{.{ .float = .xword }}, | 65814 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52277 | .patterns = &.{ | 65815 | .patterns = &.{ |
| 52278 | .{ .src = .{ .mem, .none, .none } }, | 65816 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52279 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52280 | }, | 65817 | }, |
| 52281 | .call_frame = .{ .alignment = .@"16" }, | 65818 | .call_frame = .{ .alignment = .@"16" }, |
| 52282 | .extra_temps = .{ | 65819 | .extra_temps = .{ |
| 52283 | .{ .type = .i32, .kind = .{ .reg = .edi } }, | 65820 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52284 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, | 65821 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52285 | .unused, | 65822 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 52286 | .unused, | 65823 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 52287 | .unused, | 65824 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52288 | .unused, | 65825 | .unused, |
| 52289 | .unused, | 65826 | .unused, |
| 52290 | .unused, | 65827 | .unused, |
| 52291 | .unused, | 65828 | .unused, |
| 52292 | }, | 65829 | }, |
| 52293 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65830 | .dst_temps = .{.mem}, |
| 52294 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65831 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52295 | .each = .{ .once = &.{ | 65832 | .each = .{ .once = &.{ |
| 52296 | .{ ._, ._, .movsx, .tmp0d, .src0b, ._, ._ }, | 65833 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52297 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 }, | 65842 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52301 | .src_constraints = .{ .{ .unsigned_int = .byte }, .any, .any }, | 65843 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 52302 | .dst_constraints = .{.{ .float = .xword }}, | 65844 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52303 | .patterns = &.{ | 65845 | .patterns = &.{ |
| 52304 | .{ .src = .{ .mem, .none, .none } }, | 65846 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52305 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52306 | }, | 65847 | }, |
| 52307 | .call_frame = .{ .alignment = .@"16" }, | 65848 | .call_frame = .{ .alignment = .@"16" }, |
| 52308 | .extra_temps = .{ | 65849 | .extra_temps = .{ |
| 52309 | .{ .type = .u32, .kind = .{ .reg = .edi } }, | 65850 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52310 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, | 65851 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52311 | .unused, | 65852 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 52312 | .unused, | 65853 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 52313 | .unused, | 65854 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52314 | .unused, | 65855 | .unused, |
| 52315 | .unused, | 65856 | .unused, |
| 52316 | .unused, | 65857 | .unused, |
| 52317 | .unused, | 65858 | .unused, |
| 52318 | }, | 65859 | }, |
| 52319 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65860 | .dst_temps = .{.mem}, |
| 52320 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65861 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52321 | .each = .{ .once = &.{ | 65862 | .each = .{ .once = &.{ |
| 52322 | .{ ._, ._, .movzx, .tmp0d, .src0b, ._, ._ }, | 65863 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52323 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 }, | 65872 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52327 | .src_constraints = .{ .{ .signed_int = .word }, .any, .any }, | 65873 | .src_constraints = .{ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 52328 | .dst_constraints = .{.{ .float = .xword }}, | 65874 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52329 | .patterns = &.{ | 65875 | .patterns = &.{ |
| 52330 | .{ .src = .{ .mem, .none, .none } }, | 65876 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52331 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52332 | }, | 65877 | }, |
| 52333 | .call_frame = .{ .alignment = .@"16" }, | 65878 | .call_frame = .{ .alignment = .@"16" }, |
| 52334 | .extra_temps = .{ | 65879 | .extra_temps = .{ |
| 52335 | .{ .type = .i32, .kind = .{ .reg = .edi } }, | 65880 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52336 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, | 65881 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52337 | .unused, | 65882 | .{ .type = .i64, .kind = .{ .reg = .rsi } }, |
| 52338 | .unused, | 65883 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, |
| 52339 | .unused, | 65884 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52340 | .unused, | 65885 | .unused, |
| 52341 | .unused, | 65886 | .unused, |
| 52342 | .unused, | 65887 | .unused, |
| 52343 | .unused, | 65888 | .unused, |
| 52344 | }, | 65889 | }, |
| 52345 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65890 | .dst_temps = .{.mem}, |
| 52346 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65891 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52347 | .each = .{ .once = &.{ | 65892 | .each = .{ .once = &.{ |
| 52348 | .{ ._, ._, .movsx, .tmp0d, .src0w, ._, ._ }, | 65893 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52349 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 }, | 65902 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52353 | .src_constraints = .{ .{ .unsigned_int = .word }, .any, .any }, | 65903 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 52354 | .dst_constraints = .{.{ .float = .xword }}, | 65904 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52355 | .patterns = &.{ | 65905 | .patterns = &.{ |
| 52356 | .{ .src = .{ .mem, .none, .none } }, | 65906 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52357 | .{ .src = .{ .to_gpr, .none, .none } }, | | |
| 52358 | }, | 65907 | }, |
| 52359 | .call_frame = .{ .alignment = .@"16" }, | 65908 | .call_frame = .{ .alignment = .@"16" }, |
| 52360 | .extra_temps = .{ | 65909 | .extra_temps = .{ |
| 52361 | .{ .type = .u32, .kind = .{ .reg = .edi } }, | 65910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52362 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, | 65911 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52363 | .unused, | 65912 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 52364 | .unused, | 65913 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 52365 | .unused, | 65914 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52366 | .unused, | 65915 | .unused, |
| 52367 | .unused, | 65916 | .unused, |
| 52368 | .unused, | 65917 | .unused, |
| 52369 | .unused, | 65918 | .unused, |
| 52370 | }, | 65919 | }, |
| 52371 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65920 | .dst_temps = .{.mem}, |
| 52372 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65921 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52373 | .each = .{ .once = &.{ | 65922 | .each = .{ .once = &.{ |
| 52374 | .{ ._, ._, .movzx, .tmp0d, .src0w, ._, ._ }, | 65923 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| 52375 | .{ ._, ._, .call, .tmp1d, ._, ._, ._ }, | 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 }, | 65932 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52379 | .src_constraints = .{ .{ .signed_int = .dword }, .any, .any }, | 65933 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 52380 | .dst_constraints = .{.{ .float = .xword }}, | 65934 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52381 | .patterns = &.{ | 65935 | .patterns = &.{ |
| 52382 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, | 65936 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52383 | }, | 65937 | }, |
| 52384 | .call_frame = .{ .alignment = .@"16" }, | 65938 | .call_frame = .{ .alignment = .@"16" }, |
| 52385 | .extra_temps = .{ | 65939 | .extra_temps = .{ |
| 52386 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatsitf" } } }, | 65940 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52387 | .unused, | 65941 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52388 | .unused, | 65942 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 52389 | .unused, | 65943 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 52390 | .unused, | 65944 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52391 | .unused, | 65945 | .unused, |
| 52392 | .unused, | 65946 | .unused, |
| 52393 | .unused, | 65947 | .unused, |
| 52394 | .unused, | 65948 | .unused, |
| 52395 | }, | 65949 | }, |
| 52396 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65950 | .dst_temps = .{.mem}, |
| 52397 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65951 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52398 | .each = .{ .once = &.{ | 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 }, | 65962 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52403 | .src_constraints = .{ .{ .unsigned_int = .dword }, .any, .any }, | 65963 | .src_constraints = .{ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } }, .any, .any }, |
| 52404 | .dst_constraints = .{.{ .float = .xword }}, | 65964 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52405 | .patterns = &.{ | 65965 | .patterns = &.{ |
| 52406 | .{ .src = .{ .{ .to_reg = .edi }, .none, .none } }, | 65966 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52407 | }, | 65967 | }, |
| 52408 | .call_frame = .{ .alignment = .@"16" }, | 65968 | .call_frame = .{ .alignment = .@"16" }, |
| 52409 | .extra_temps = .{ | 65969 | .extra_temps = .{ |
| 52410 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunsitf" } } }, | 65970 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52411 | .unused, | 65971 | .{ .type = .u64, .kind = .{ .reg = .rdi } }, |
| 52412 | .unused, | 65972 | .{ .type = .u64, .kind = .{ .reg = .rsi } }, |
| 52413 | .unused, | 65973 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, |
| 52414 | .unused, | 65974 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52415 | .unused, | 65975 | .unused, |
| 52416 | .unused, | 65976 | .unused, |
| 52417 | .unused, | 65977 | .unused, |
| 52418 | .unused, | 65978 | .unused, |
| 52419 | }, | 65979 | }, |
| 52420 | .dst_temps = .{.{ .reg = .xmm0 }}, | 65980 | .dst_temps = .{.mem}, |
| 52421 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 65981 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52422 | .each = .{ .once = &.{ | 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 }, | 65992 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52427 | .src_constraints = .{ .{ .signed_int = .qword }, .any, .any }, | 65993 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52428 | .dst_constraints = .{.{ .float = .xword }}, | 65994 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52429 | .patterns = &.{ | 65995 | .patterns = &.{ |
| 52430 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, | 65996 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52431 | }, | 65997 | }, |
| 52432 | .call_frame = .{ .alignment = .@"16" }, | 65998 | .call_frame = .{ .alignment = .@"16" }, |
| 52433 | .extra_temps = .{ | 65999 | .extra_temps = .{ |
| 52434 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatditf" } } }, | 66000 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52435 | .unused, | 66001 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52436 | .unused, | 66002 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52437 | .unused, | 66003 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52438 | .unused, | 66004 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 52439 | .unused, | 66005 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52440 | .unused, | 66006 | .unused, |
| 52441 | .unused, | 66007 | .unused, |
| 52442 | .unused, | 66008 | .unused, |
| 52443 | }, | 66009 | }, |
| 52444 | .dst_temps = .{.{ .reg = .xmm0 }}, | 66010 | .dst_temps = .{.mem}, |
| 52445 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 66011 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52446 | .each = .{ .once = &.{ | 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 }, | 66024 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52451 | .src_constraints = .{ .{ .unsigned_int = .qword }, .any, .any }, | 66025 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52452 | .dst_constraints = .{.{ .float = .xword }}, | 66026 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52453 | .patterns = &.{ | 66027 | .patterns = &.{ |
| 52454 | .{ .src = .{ .{ .to_reg = .rdi }, .none, .none } }, | 66028 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52455 | }, | 66029 | }, |
| 52456 | .call_frame = .{ .alignment = .@"16" }, | 66030 | .call_frame = .{ .alignment = .@"16" }, |
| 52457 | .extra_temps = .{ | 66031 | .extra_temps = .{ |
| 52458 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatunditf" } } }, | 66032 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52459 | .unused, | 66033 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52460 | .unused, | 66034 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52461 | .unused, | 66035 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52462 | .unused, | 66036 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 52463 | .unused, | 66037 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52464 | .unused, | 66038 | .unused, |
| 52465 | .unused, | 66039 | .unused, |
| 52466 | .unused, | 66040 | .unused, |
| 52467 | }, | 66041 | }, |
| 52468 | .dst_temps = .{.{ .reg = .xmm0 }}, | 66042 | .dst_temps = .{.mem}, |
| 52469 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 66043 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52470 | .each = .{ .once = &.{ | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 66056 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52475 | .src_constraints = .{ .{ .signed_int = .xword }, .any, .any }, | 66057 | .src_constraints = .{ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52476 | .dst_constraints = .{.{ .float = .xword }}, | 66058 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52477 | .patterns = &.{ | 66059 | .patterns = &.{ |
| 52478 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 66060 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52479 | }, | 66061 | }, |
| 52480 | .call_frame = .{ .alignment = .@"16" }, | 66062 | .call_frame = .{ .alignment = .@"16" }, |
| 52481 | .extra_temps = .{ | 66063 | .extra_temps = .{ |
| 52482 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floattitf" } } }, | 66064 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52483 | .unused, | 66065 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52484 | .unused, | 66066 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52485 | .unused, | 66067 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52486 | .unused, | 66068 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, |
| 52487 | .unused, | 66069 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52488 | .unused, | 66070 | .unused, |
| 52489 | .unused, | 66071 | .unused, |
| 52490 | .unused, | 66072 | .unused, |
| 52491 | }, | 66073 | }, |
| 52492 | .dst_temps = .{.{ .reg = .xmm0 }}, | 66074 | .dst_temps = .{.mem}, |
| 52493 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 66075 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52494 | .each = .{ .once = &.{ | 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 }, | 66088 | .required_features = .{ .@"64bit", .avx, null, null }, |
| 52499 | .src_constraints = .{ .{ .unsigned_int = .xword }, .any, .any }, | 66089 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52500 | .dst_constraints = .{.{ .float = .xword }}, | 66090 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52501 | .patterns = &.{ | 66091 | .patterns = &.{ |
| 52502 | .{ .src = .{ .{ .to_reg_pair = .{ .rdi, .rsi } }, .none, .none } }, | 66092 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52503 | }, | 66093 | }, |
| 52504 | .call_frame = .{ .alignment = .@"16" }, | 66094 | .call_frame = .{ .alignment = .@"16" }, |
| 52505 | .extra_temps = .{ | 66095 | .extra_temps = .{ |
| 52506 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuntitf" } } }, | 66096 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 52507 | .unused, | 66097 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52508 | .unused, | 66098 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52509 | .unused, | 66099 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52510 | .unused, | 66100 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 52511 | .unused, | 66101 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52512 | .unused, | 66102 | .unused, |
| 52513 | .unused, | 66103 | .unused, |
| 52514 | .unused, | 66104 | .unused, |
| 52515 | }, | 66105 | }, |
| 52516 | .dst_temps = .{.{ .reg = .xmm0 }}, | 66106 | .dst_temps = .{.mem}, |
| 52517 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 66107 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52518 | .each = .{ .once = &.{ | 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 }, | 66120 | .required_features = .{ .@"64bit", .sse2, null, null }, |
| 52523 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 66121 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52524 | .dst_constraints = .{.{ .float = .xword }}, | 66122 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52525 | .patterns = &.{ | 66123 | .patterns = &.{ |
| 52526 | .{ .src = .{ .to_mem, .none, .none } }, | 66124 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52527 | }, | 66125 | }, |
| 52528 | .call_frame = .{ .alignment = .@"16" }, | 66126 | .call_frame = .{ .alignment = .@"16" }, |
| 52529 | .extra_temps = .{ | 66127 | .extra_temps = .{ |
| | 66128 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 66129 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52530 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 66130 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52531 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 66131 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52532 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floateitf" } } }, | 66132 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 52533 | .unused, | 66133 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52534 | .unused, | | |
| 52535 | .unused, | | |
| 52536 | .unused, | 66134 | .unused, |
| 52537 | .unused, | 66135 | .unused, |
| 52538 | .unused, | 66136 | .unused, |
| 52539 | }, | 66137 | }, |
| 52540 | .dst_temps = .{.{ .reg = .xmm0 }}, | 66138 | .dst_temps = .{.mem}, |
| 52541 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 66139 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52542 | .each = .{ .once = &.{ | 66140 | .each = .{ .once = &.{ |
| 52543 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 66141 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 52544 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 66142 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52545 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | .required_features = .{ .@"64bit", .sse, null, null }, | 66152 | .required_features = .{ .@"64bit", .sse, null, null }, |
| 52549 | .src_constraints = .{ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, | 66153 | .src_constraints = .{ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } }, .any, .any }, |
| 52550 | .dst_constraints = .{.{ .float = .xword }}, | 66154 | .dst_constraints = .{.{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } }}, |
| 52551 | .patterns = &.{ | 66155 | .patterns = &.{ |
| 52552 | .{ .src = .{ .to_mem, .none, .none } }, | 66156 | .{ .src = .{ .to_mem, .none, .none } }, |
| 52553 | }, | 66157 | }, |
| 52554 | .call_frame = .{ .alignment = .@"16" }, | 66158 | .call_frame = .{ .alignment = .@"16" }, |
| 52555 | .extra_temps = .{ | 66159 | .extra_temps = .{ |
| | 66160 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 66161 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| 52556 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, | 66162 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 52557 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, | 66163 | .{ .type = .usize, .kind = .{ .reg = .rsi } }, |
| 52558 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, | 66164 | .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floatuneitf" } } }, |
| 52559 | .unused, | 66165 | .{ .type = .f128, .kind = .{ .reg = .xmm0 } }, |
| 52560 | .unused, | | |
| 52561 | .unused, | | |
| 52562 | .unused, | 66166 | .unused, |
| 52563 | .unused, | 66167 | .unused, |
| 52564 | .unused, | 66168 | .unused, |
| 52565 | }, | 66169 | }, |
| 52566 | .dst_temps = .{.{ .reg = .xmm0 }}, | 66170 | .dst_temps = .{.mem}, |
| 52567 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, | 66171 | .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, |
| 52568 | .each = .{ .once = &.{ | 66172 | .each = .{ .once = &.{ |
| 52569 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, | 66173 | .{ ._, ._, .lea, .tmp0p, .mem(.src0), ._, ._ }, |
| 52570 | .{ ._, ._, .mov, .tmp1d, .sa(.src0, .add_8_size), ._, ._ }, | 66174 | .{ ._, ._, .mov, .tmp1p, .sa(.dst0, .sub_unaligned_size), ._, ._ }, |
| 52571 | .{ ._, ._, .call, .tmp2d, ._, ._, ._ }, | 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 | } }) catch |err| switch (err) { | 66183 | } }) catch |err| switch (err) { |
| 52574 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 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,14 +80037,18 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 66427 | .insert = .{ .p_w, .insr }, | 80037 | .insert = .{ .p_w, .insr }, |
| 66428 | .extract = .{ .p_w, .extr }, | 80038 | .extract = .{ .p_w, .extr }, |
| 66429 | } }, | 80039 | } }, |
| 66430 | 3...4 => return .{ .move = if (self.hasFeature(.avx)) | 80040 | 3...4 => return .{ .move = .{ if (self.hasFeature(.avx)) |
| 66431 | .{ .v_d, .mov } | 80041 | .v_d |
| | 80042 | else if (self.hasFeature(.sse2)) |
| | 80043 | ._d |
| 66432 | else | 80044 | else |
| 66433 | .{ ._d, .mov } }, | 80045 | ._ss, .mov } }, |
| 66434 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) | 80046 | 5...8 => return .{ .move = if (self.hasFeature(.avx)) |
| 66435 | .{ .v_q, .mov } | 80047 | .{ .v_q, .mov } |
| | 80048 | else if (self.hasFeature(.sse2)) |
| | 80049 | .{ ._q, .mov } |
| 66436 | else | 80050 | else |
| 66437 | .{ ._q, .mov } }, | 80051 | .{ ._ps, .movl } }, |
| 66438 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) | 80052 | 9...16 => return .{ .move = if (self.hasFeature(.avx)) |
| 66439 | .{ if (aligned) .v_dqa else .v_dqu, .mov } | 80053 | .{ if (aligned) .v_dqa else .v_dqu, .mov } |
| 66440 | else if (self.hasFeature(.sse2)) | 80054 | else if (self.hasFeature(.sse2)) |
| ... | @@ -66494,10 +80108,40 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) | ... | @@ -66494,10 +80108,40 @@ fn moveStrategy(self: *CodeGen, ty: Type, class: Register.Class, aligned: bool) |
| 66494 | }, | 80108 | }, |
| 66495 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { | 80109 | .vector => switch (ty.childType(zcu).zigTypeTag(zcu)) { |
| 66496 | .bool => switch (ty.vectorLen(zcu)) { | 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 | 33...64 => return .{ .move = if (self.hasFeature(.avx)) | 80131 | 33...64 => return .{ .move = if (self.hasFeature(.avx)) |
| 66498 | .{ .v_q, .mov } | 80132 | .{ .v_q, .mov } |
| | 80133 | else if (self.hasFeature(.sse2)) |
| | 80134 | .{ ._q, .mov } |
| 66499 | else | 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 | else => {}, | 80145 | else => {}, |
| 66502 | }, | 80146 | }, |
| 66503 | .int => switch (ty.childType(zcu).intInfo(zcu).bits) { | 80147 | .int => switch (ty.childType(zcu).intInfo(zcu).bits) { |
| ... | @@ -70347,6 +83991,11 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -70347,6 +83991,11 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 70347 | if (mask_len % 64 <= 32) acc_reg.to32() else acc_reg.to64(), | 83991 | if (mask_len % 64 <= 32) acc_reg.to32() else acc_reg.to64(), |
| 70348 | .u((@as(u64, std.math.maxInt(u64)) >> @truncate(-%mask_len))), | 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 | var first = true; | 83999 | var first = true; |
| 70351 | while (true) : (limb_offset -= 8) { | 84000 | while (true) : (limb_offset -= 8) { |
| 70352 | try self.asmRegisterMemory( | 84001 | try self.asmRegisterMemory( |
| ... | @@ -70356,7 +84005,7 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -70356,7 +84005,7 @@ fn airReduce(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 70356 | else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), | 84005 | else => return self.fail("TODO implement airReduce for {}", .{operand_ty.fmt(pt)}), |
| 70357 | } }, | 84006 | } }, |
| 70358 | acc_reg.to64(), | 84007 | acc_reg.to64(), |
| 70359 | try operand_mcv.mem(self, .{ | 84008 | try operand_mem_mcv.mem(self, .{ |
| 70360 | .size = .qword, | 84009 | .size = .qword, |
| 70361 | .disp = limb_offset, | 84010 | .disp = limb_offset, |
| 70362 | }), | 84011 | }), |
| ... | @@ -74704,6 +88353,7 @@ const Select = struct { | ... | @@ -74704,6 +88353,7 @@ const Select = struct { |
| 74704 | f64_0x1p52_0x1p84_mem, | 88353 | f64_0x1p52_0x1p84_mem, |
| 74705 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, | 88354 | u32_0x1p52_hi_0x1p84_hi_0_0_mem, |
| 74706 | f32_0_0x1p64_mem, | 88355 | f32_0_0x1p64_mem, |
| | 88356 | pshufb_cm_mem: struct { from: Memory.Size, to: Memory.Size }, |
| 74707 | frame: FrameIndex, | 88357 | frame: FrameIndex, |
| 74708 | symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 }, | 88358 | symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 }, |
| 74709 | | 88359 | |
| ... | @@ -74875,6 +88525,23 @@ const Select = struct { | ... | @@ -74875,6 +88525,23 @@ const Select = struct { |
| 74875 | (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(), | 88525 | (try pt.floatValue(.f32, @as(f32, 0x1p64))).toIntern(), |
| 74876 | } }, | 88526 | } }, |
| 74877 | } }))), true }, | 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 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, | 88545 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, |
| 74879 | .symbol => |symbol| .{ try cg.tempInit(spec.type, .{ .lea_symbol = .{ | 88546 | .symbol => |symbol| .{ try cg.tempInit(spec.type, .{ .lea_symbol = .{ |
| 74880 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| | 88547 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| |
| ... | @@ -74938,6 +88605,7 @@ const Select = struct { | ... | @@ -74938,6 +88605,7 @@ const Select = struct { |
| 74938 | elem_limbs, | 88605 | elem_limbs, |
| 74939 | elem_size, | 88606 | elem_size, |
| 74940 | src0_elem_size, | 88607 | src0_elem_size, |
| | 88608 | dst0_elem_size, |
| 74941 | src0_elem_size_times_src1, | 88609 | src0_elem_size_times_src1, |
| 74942 | log2_src0_elem_size, | 88610 | log2_src0_elem_size, |
| 74943 | smin, | 88611 | smin, |
| ... | @@ -74977,6 +88645,7 @@ const Select = struct { | ... | @@ -74977,6 +88645,7 @@ const Select = struct { |
| 74977 | const add_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"1" }; | 88645 | const add_len: Adjust = .{ .sign = .pos, .lhs = .len, .op = .mul, .rhs = .@"1" }; |
| 74978 | const sub_len: Adjust = .{ .sign = .neg, .lhs = .len, .op = .mul, .rhs = .@"1" }; | 88646 | const sub_len: Adjust = .{ .sign = .neg, .lhs = .len, .op = .mul, .rhs = .@"1" }; |
| 74979 | const add_elem_size_div_8: Adjust = .{ .sign = .pos, .lhs = .elem_size, .op = .div, .rhs = .@"8" }; | 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 | const add_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" }; | 88649 | const add_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"1" }; |
| 74981 | const add_2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"2" }; | 88650 | const add_2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"2" }; |
| 74982 | const add_4_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size, .op = .mul, .rhs = .@"4" }; | 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,6 +88655,7 @@ const Select = struct { |
| 74986 | const add_src0_elem_size_times_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" }; | 88655 | const add_src0_elem_size_times_src1: Adjust = .{ .sign = .pos, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" }; |
| 74987 | const sub_src0_elem_size_times_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" }; | 88656 | const sub_src0_elem_size_times_src1: Adjust = .{ .sign = .neg, .lhs = .src0_elem_size_times_src1, .op = .mul, .rhs = .@"1" }; |
| 74988 | const add_log2_src0_elem_size: Adjust = .{ .sign = .pos, .lhs = .log2_src0_elem_size, .op = .mul, .rhs = .@"1" }; | 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 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; | 88659 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; |
| 74990 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; | 88660 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| 74991 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; | 88661 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| ... | @@ -75391,6 +89061,13 @@ const Select = struct { | ... | @@ -75391,6 +89061,13 @@ const Select = struct { |
| 75391 | .index = .{ .ref = index, .scale = scale }, | 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 | fn leasid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { | 89071 | fn leasid(base: Ref.Sized, scale: Memory.Scale, index: Ref, disp: i32) Select.Operand { |
| 75395 | return .{ | 89072 | return .{ |
| 75396 | .flags = .{ .tag = .lea }, | 89073 | .flags = .{ .tag = .lea }, |
| ... | @@ -75522,6 +89199,7 @@ const Select = struct { | ... | @@ -75522,6 +89199,7 @@ const Select = struct { |
| 75522 | )), | 89199 | )), |
| 75523 | .elem_size => @intCast(op.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), | 89200 | .elem_size => @intCast(op.base.ref.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), |
| 75524 | .src0_elem_size => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu)), | 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 | .src0_elem_size_times_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * | 89203 | .src0_elem_size_times_src1 => @intCast(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu) * |
| 75526 | Select.Operand.Ref.src1.valueOf(s).immediate), | 89204 | Select.Operand.Ref.src1.valueOf(s).immediate), |
| 75527 | .log2_src0_elem_size => @intCast(std.math.log2(Select.Operand.Ref.src0.typeOf(s).elemType2(s.cg.pt.zcu).abiSize(s.cg.pt.zcu))), | 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