authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-07-28 13:03:16-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-28 22:23:19-07:00
log3fbdd58a874c6b4dae84bed2ed31c945ff4adb54
treecff600f1e759d5f47fec41948eb77afba88ac959
parentecd3ea9bd2f543f44813da21fd6b77d53dd72d7c

aarch64: implement scalar `@mod`

3 files changed, 5048 insertions(+), 1309 deletions(-)

src/codegen/aarch64/Select.zig+246-28
...@@ -1919,8 +1919,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,...@@ -1919,8 +1919,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
1919 switch (bits) {1919 switch (bits) {
1920 else => unreachable,1920 else => unreachable,
1921 1...32 => {1921 1...32 => {
1922 try isel.emit(.sub(res_ra.w(), div_ra.w(), .{ .register = rem_ra.w() }));1922 try isel.emit(.csel(res_ra.w(), div_ra.w(), rem_ra.w(), .pl));
1923 try isel.emit(.csinc(rem_ra.w(), .wzr, .wzr, .ge));1923 try isel.emit(.sub(rem_ra.w(), div_ra.w(), .{ .immediate = 1 }));
1924 try isel.emit(.ccmp(1924 try isel.emit(.ccmp(
1925 rem_ra.w(),1925 rem_ra.w(),
1926 .{ .immediate = 0 },1926 .{ .immediate = 0 },
...@@ -1932,8 +1932,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,...@@ -1932,8 +1932,8 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
1932 try isel.emit(.msub(rem_ra.w(), div_ra.w(), rhs_mat.ra.w(), lhs_mat.ra.w()));1932 try isel.emit(.msub(rem_ra.w(), div_ra.w(), rhs_mat.ra.w(), lhs_mat.ra.w()));
1933 },1933 },
1934 33...64 => {1934 33...64 => {
1935 try isel.emit(.sub(res_ra.x(), div_ra.x(), .{ .register = rem_ra.x() }));1935 try isel.emit(.csel(res_ra.x(), div_ra.x(), rem_ra.x(), .pl));
1936 try isel.emit(.csinc(rem_ra.x(), .xzr, .xzr, .ge));1936 try isel.emit(.sub(rem_ra.x(), div_ra.x(), .{ .immediate = 1 }));
1937 try isel.emit(.ccmp(1937 try isel.emit(.ccmp(
1938 rem_ra.x(),1938 rem_ra.x(),
1939 .{ .immediate = 0 },1939 .{ .immediate = 0 },
...@@ -2162,7 +2162,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,...@@ -2162,7 +2162,7 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2162 }2162 }
2163 if (air.next()) |next_air_tag| continue :air_tag next_air_tag;2163 if (air.next()) |next_air_tag| continue :air_tag next_air_tag;
2164 },2164 },
2165 .rem => |air_tag| {2165 .rem, .rem_optimized, .mod, .mod_optimized => |air_tag| {
2166 if (isel.live_values.fetchRemove(air.inst_index)) |res_vi| unused: {2166 if (isel.live_values.fetchRemove(air.inst_index)) |res_vi| unused: {
2167 defer res_vi.value.deref(isel);2167 defer res_vi.value.deref(isel);
21682168
...@@ -2180,17 +2180,57 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,...@@ -2180,17 +2180,57 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2180 const rhs_mat = try rhs_vi.matReg(isel);2180 const rhs_mat = try rhs_vi.matReg(isel);
2181 const div_ra = try isel.allocIntReg();2181 const div_ra = try isel.allocIntReg();
2182 defer isel.freeReg(div_ra);2182 defer isel.freeReg(div_ra);
2183 const rem_ra = rem_ra: switch (air_tag) {
2184 else => unreachable,
2185 .rem => res_ra,
2186 .mod => switch (int_info.signedness) {
2187 .signed => {
2188 const rem_ra = try isel.allocIntReg();
2189 errdefer isel.freeReg(rem_ra);
2190 switch (int_info.bits) {
2191 else => unreachable,
2192 1...32 => {
2193 try isel.emit(.csel(res_ra.w(), rem_ra.w(), div_ra.w(), .pl));
2194 try isel.emit(.add(div_ra.w(), rem_ra.w(), .{ .register = rhs_mat.ra.w() }));
2195 try isel.emit(.ccmp(
2196 div_ra.w(),
2197 .{ .immediate = 0 },
2198 .{ .n = false, .z = false, .c = false, .v = false },
2199 .ne,
2200 ));
2201 try isel.emit(.eor(div_ra.w(), rem_ra.w(), .{ .register = rhs_mat.ra.w() }));
2202 try isel.emit(.subs(.wzr, rem_ra.w(), .{ .immediate = 0 }));
2203 },
2204 33...64 => {
2205 try isel.emit(.csel(res_ra.x(), rem_ra.x(), div_ra.x(), .pl));
2206 try isel.emit(.add(div_ra.x(), rem_ra.x(), .{ .register = rhs_mat.ra.x() }));
2207 try isel.emit(.ccmp(
2208 div_ra.x(),
2209 .{ .immediate = 0 },
2210 .{ .n = false, .z = false, .c = false, .v = false },
2211 .ne,
2212 ));
2213 try isel.emit(.eor(div_ra.x(), rem_ra.x(), .{ .register = rhs_mat.ra.x() }));
2214 try isel.emit(.subs(.xzr, rem_ra.x(), .{ .immediate = 0 }));
2215 },
2216 }
2217 break :rem_ra rem_ra;
2218 },
2219 .unsigned => res_ra,
2220 },
2221 };
2222 defer if (rem_ra != res_ra) isel.freeReg(rem_ra);
2183 switch (int_info.bits) {2223 switch (int_info.bits) {
2184 else => unreachable,2224 else => unreachable,
2185 1...32 => {2225 1...32 => {
2186 try isel.emit(.msub(res_ra.w(), div_ra.w(), rhs_mat.ra.w(), lhs_mat.ra.w()));2226 try isel.emit(.msub(rem_ra.w(), div_ra.w(), rhs_mat.ra.w(), lhs_mat.ra.w()));
2187 try isel.emit(switch (int_info.signedness) {2227 try isel.emit(switch (int_info.signedness) {
2188 .signed => .sdiv(div_ra.w(), lhs_mat.ra.w(), rhs_mat.ra.w()),2228 .signed => .sdiv(div_ra.w(), lhs_mat.ra.w(), rhs_mat.ra.w()),
2189 .unsigned => .udiv(div_ra.w(), lhs_mat.ra.w(), rhs_mat.ra.w()),2229 .unsigned => .udiv(div_ra.w(), lhs_mat.ra.w(), rhs_mat.ra.w()),
2190 });2230 });
2191 },2231 },
2192 33...64 => {2232 33...64 => {
2193 try isel.emit(.msub(res_ra.x(), div_ra.x(), rhs_mat.ra.x(), lhs_mat.ra.x()));2233 try isel.emit(.msub(rem_ra.x(), div_ra.x(), rhs_mat.ra.x(), lhs_mat.ra.x()));
2194 try isel.emit(switch (int_info.signedness) {2234 try isel.emit(switch (int_info.signedness) {
2195 .signed => .sdiv(div_ra.x(), lhs_mat.ra.x(), rhs_mat.ra.x()),2235 .signed => .sdiv(div_ra.x(), lhs_mat.ra.x(), rhs_mat.ra.x()),
2196 .unsigned => .udiv(div_ra.x(), lhs_mat.ra.x(), rhs_mat.ra.x()),2236 .unsigned => .udiv(div_ra.x(), lhs_mat.ra.x(), rhs_mat.ra.x()),
...@@ -2201,21 +2241,184 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,...@@ -2201,21 +2241,184 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory,
2201 try lhs_mat.finish(isel);2241 try lhs_mat.finish(isel);
2202 } else {2242 } else {
2203 const bits = ty.floatBits(isel.target);2243 const bits = ty.floatBits(isel.target);
22042244 switch (air_tag) {
2205 try call.prepareReturn(isel);
2206 switch (bits) {
2207 else => unreachable,2245 else => unreachable,
2208 16, 32, 64, 128 => try call.returnLiveIn(isel, res_vi.value, .v0),2246 .rem, .rem_optimized => {
2209 80 => {2247 if (!res_vi.value.isUsed(isel)) break :unused;
2210 var res_hi16_it = res_vi.value.field(ty, 8, 8);2248 try call.prepareReturn(isel);
2211 const res_hi16_vi = try res_hi16_it.only(isel);2249 switch (bits) {
2212 try call.returnLiveIn(isel, res_hi16_vi.?, .r1);2250 else => unreachable,
2213 var res_lo64_it = res_vi.value.field(ty, 0, 8);2251 16, 32, 64, 128 => try call.returnLiveIn(isel, res_vi.value, .v0),
2214 const res_lo64_vi = try res_lo64_it.only(isel);2252 80 => {
2215 try call.returnLiveIn(isel, res_lo64_vi.?, .r0);2253 var res_hi16_it = res_vi.value.field(ty, 8, 8);
2254 const res_hi16_vi = try res_hi16_it.only(isel);
2255 try call.returnLiveIn(isel, res_hi16_vi.?, .r1);
2256 var res_lo64_it = res_vi.value.field(ty, 0, 8);
2257 const res_lo64_vi = try res_lo64_it.only(isel);
2258 try call.returnLiveIn(isel, res_lo64_vi.?, .r0);
2259 },
2260 }
2261 try call.finishReturn(isel);
2262 },
2263 .mod, .mod_optimized => switch (bits) {
2264 else => unreachable,
2265 16, 32, 64 => {
2266 const res_ra = try res_vi.value.defReg(isel) orelse break :unused;
2267 try call.prepareReturn(isel);
2268 const rem_ra: Register.Alias = .v0;
2269 const temp1_ra: Register.Alias = .v1;
2270 const temp2_ra: Register.Alias = switch (res_ra) {
2271 rem_ra, temp1_ra => .v2,
2272 else => res_ra,
2273 };
2274 const need_fcvt = switch (bits) {
2275 else => unreachable,
2276 16 => !isel.target.cpu.has(.aarch64, .fullfp16),
2277 32, 64 => false,
2278 };
2279 if (need_fcvt) try isel.emit(.fcvt(res_ra.h(), res_ra.s()));
2280 try isel.emit(switch (res_ra) {
2281 rem_ra => .bif(res_ra.@"8b"(), temp2_ra.@"8b"(), temp1_ra.@"8b"()),
2282 temp1_ra => .bsl(res_ra.@"8b"(), rem_ra.@"8b"(), temp2_ra.@"8b"()),
2283 else => .bit(res_ra.@"8b"(), rem_ra.@"8b"(), temp1_ra.@"8b"()),
2284 });
2285 const rhs_vi = try isel.use(bin_op.rhs);
2286 const rhs_mat = try rhs_vi.matReg(isel);
2287 try isel.emit(bits: switch (bits) {
2288 else => unreachable,
2289 16 => if (need_fcvt)
2290 continue :bits 32
2291 else
2292 .fadd(temp2_ra.h(), rem_ra.h(), rhs_mat.ra.h()),
2293 32 => .fadd(temp2_ra.s(), rem_ra.s(), rhs_mat.ra.s()),
2294 64 => .fadd(temp2_ra.d(), rem_ra.d(), rhs_mat.ra.d()),
2295 });
2296 if (need_fcvt) {
2297 try isel.emit(.fcvt(rhs_mat.ra.s(), rhs_mat.ra.h()));
2298 try isel.emit(.fcvt(rem_ra.s(), rem_ra.h()));
2299 }
2300 try isel.emit(.orr(temp1_ra.@"8b"(), temp1_ra.@"8b"(), .{
2301 .register = temp2_ra.@"8b"(),
2302 }));
2303 try isel.emit(switch (bits) {
2304 else => unreachable,
2305 16 => .cmge(temp1_ra.@"4h"(), temp1_ra.@"4h"(), .zero),
2306 32 => .cmge(temp1_ra.@"2s"(), temp1_ra.@"2s"(), .zero),
2307 64 => .cmge(temp1_ra.d(), temp1_ra.d(), .zero),
2308 });
2309 try isel.emit(switch (bits) {
2310 else => unreachable,
2311 16 => .fcmeq(temp2_ra.h(), rem_ra.h(), .zero),
2312 32 => .fcmeq(temp2_ra.s(), rem_ra.s(), .zero),
2313 64 => .fcmeq(temp2_ra.d(), rem_ra.d(), .zero),
2314 });
2315 try isel.emit(.eor(temp1_ra.@"8b"(), rem_ra.@"8b"(), .{
2316 .register = rhs_mat.ra.@"8b"(),
2317 }));
2318 try rhs_mat.finish(isel);
2319 try call.finishReturn(isel);
2320 },
2321 80, 128 => {
2322 if (!res_vi.value.isUsed(isel)) break :unused;
2323 try call.prepareReturn(isel);
2324 switch (bits) {
2325 else => unreachable,
2326 16, 32, 64, 128 => try call.returnLiveIn(isel, res_vi.value, .v0),
2327 80 => {
2328 var res_hi16_it = res_vi.value.field(ty, 8, 8);
2329 const res_hi16_vi = try res_hi16_it.only(isel);
2330 try call.returnLiveIn(isel, res_hi16_vi.?, .r1);
2331 var res_lo64_it = res_vi.value.field(ty, 0, 8);
2332 const res_lo64_vi = try res_lo64_it.only(isel);
2333 try call.returnLiveIn(isel, res_lo64_vi.?, .r0);
2334 },
2335 }
2336 const skip_label = isel.instructions.items.len;
2337 try isel.global_relocs.append(gpa, .{
2338 .name = switch (bits) {
2339 else => unreachable,
2340 16 => "__addhf3",
2341 32 => "__addsf3",
2342 64 => "__adddf3",
2343 80 => "__addxf3",
2344 128 => "__addtf3",
2345 },
2346 .reloc = .{ .label = @intCast(isel.instructions.items.len) },
2347 });
2348 try isel.emit(.bl(0));
2349 const rhs_vi = try isel.use(bin_op.rhs);
2350 switch (bits) {
2351 else => unreachable,
2352 80 => {
2353 const lhs_lo64_ra: Register.Alias = .r0;
2354 const lhs_hi16_ra: Register.Alias = .r1;
2355 const rhs_lo64_ra: Register.Alias = .r2;
2356 const rhs_hi16_ra: Register.Alias = .r3;
2357 const temp_ra: Register.Alias = .r4;
2358 var rhs_hi16_it = rhs_vi.field(ty, 8, 8);
2359 const rhs_hi16_vi = try rhs_hi16_it.only(isel);
2360 try call.paramLiveOut(isel, rhs_hi16_vi.?, rhs_hi16_ra);
2361 var rhs_lo64_it = rhs_vi.field(ty, 0, 8);
2362 const rhs_lo64_vi = try rhs_lo64_it.only(isel);
2363 try call.paramLiveOut(isel, rhs_lo64_vi.?, rhs_lo64_ra);
2364 try isel.emit(.cbz(
2365 temp_ra.x(),
2366 @intCast((isel.instructions.items.len + 1 - skip_label) << 2),
2367 ));
2368 try isel.emit(.orr(temp_ra.x(), lhs_lo64_ra.x(), .{ .shifted_register = .{
2369 .register = lhs_hi16_ra.x(),
2370 .shift = .{ .lsl = 64 - 15 },
2371 } }));
2372 try isel.emit(.tbz(
2373 temp_ra.w(),
2374 15,
2375 @intCast((isel.instructions.items.len + 1 - skip_label) << 2),
2376 ));
2377 try isel.emit(.eor(temp_ra.w(), lhs_hi16_ra.w(), .{
2378 .register = rhs_hi16_ra.w(),
2379 }));
2380 },
2381 128 => {
2382 const lhs_ra: Register.Alias = .v0;
2383 const rhs_ra: Register.Alias = .v1;
2384 const temp1_ra: Register.Alias = .r0;
2385 const temp2_ra: Register.Alias = .r1;
2386 try call.paramLiveOut(isel, rhs_vi, rhs_ra);
2387 try isel.emit(.@"b."(
2388 .pl,
2389 @intCast((isel.instructions.items.len + 1 - skip_label) << 2),
2390 ));
2391 try isel.emit(.cbz(
2392 temp1_ra.x(),
2393 @intCast((isel.instructions.items.len + 1 - skip_label) << 2),
2394 ));
2395 try isel.emit(.orr(temp1_ra.x(), temp1_ra.x(), .{ .shifted_register = .{
2396 .register = temp2_ra.x(),
2397 .shift = .{ .lsl = 1 },
2398 } }));
2399 try isel.emit(.fmov(temp1_ra.x(), .{
2400 .register = rhs_ra.d(),
2401 }));
2402 try isel.emit(.tbz(
2403 temp1_ra.x(),
2404 63,
2405 @intCast((isel.instructions.items.len + 1 - skip_label) << 2),
2406 ));
2407 try isel.emit(.eor(temp1_ra.x(), temp1_ra.x(), .{
2408 .register = temp2_ra.x(),
2409 }));
2410 try isel.emit(.fmov(temp2_ra.x(), .{
2411 .register = rhs_ra.@"d[]"(1),
2412 }));
2413 try isel.emit(.fmov(temp1_ra.x(), .{
2414 .register = lhs_ra.@"d[]"(1),
2415 }));
2416 },
2417 }
2418 try call.finishReturn(isel);
2419 },
2216 },2420 },
2217 }2421 }
2218 try call.finishReturn(isel);
22192422
2220 try call.prepareCallee(isel);2423 try call.prepareCallee(isel);
2221 try isel.global_relocs.append(gpa, .{2424 try isel.global_relocs.append(gpa, .{
...@@ -9517,12 +9720,12 @@ pub const Value = struct {...@@ -9517,12 +9720,12 @@ pub const Value = struct {
9517 const part_mat = try part_vi.matReg(isel);9720 const part_mat = try part_vi.matReg(isel);
9518 try isel.emit(if (part_vi.isVector(isel)) emit: {9721 try isel.emit(if (part_vi.isVector(isel)) emit: {
9519 assert(part_offset == 0 and part_size == vi_size);9722 assert(part_offset == 0 and part_size == vi_size);
9520 break :emit size: switch (vi_size) {9723 break :emit switch (vi_size) {
9521 else => unreachable,9724 else => unreachable,
9522 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))9725 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))
9523 .fmov(ra.h(), .{ .register = part_mat.ra.h() })9726 .fmov(ra.h(), .{ .register = part_mat.ra.h() })
9524 else9727 else
9525 continue :size 4,9728 .dup(ra.h(), part_mat.ra.@"h[]"(0)),
9526 4 => .fmov(ra.s(), .{ .register = part_mat.ra.s() }),9729 4 => .fmov(ra.s(), .{ .register = part_mat.ra.s() }),
9527 8 => .fmov(ra.d(), .{ .register = part_mat.ra.d() }),9730 8 => .fmov(ra.d(), .{ .register = part_mat.ra.d() }),
9528 16 => .orr(ra.@"16b"(), part_mat.ra.@"16b"(), .{ .register = part_mat.ra.@"16b"() }),9731 16 => .orr(ra.@"16b"(), part_mat.ra.@"16b"(), .{ .register = part_mat.ra.@"16b"() }),
...@@ -9642,21 +9845,30 @@ pub const Value = struct {...@@ -9642,21 +9845,30 @@ pub const Value = struct {
9642 },9845 },
9643 true => switch (vi.size(isel)) {9846 true => switch (vi.size(isel)) {
9644 else => unreachable,9847 else => unreachable,
9645 2 => .fmov(dst_ra.w(), .{ .register = src_ra.h() }),9848 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))
9849 .fmov(dst_ra.w(), .{ .register = src_ra.h() })
9850 else
9851 .umov(dst_ra.w(), src_ra.@"h[]"(0)),
9646 4 => .fmov(dst_ra.w(), .{ .register = src_ra.s() }),9852 4 => .fmov(dst_ra.w(), .{ .register = src_ra.s() }),
9647 8 => .fmov(dst_ra.x(), .{ .register = src_ra.d() }),9853 8 => .fmov(dst_ra.x(), .{ .register = src_ra.d() }),
9648 },9854 },
9649 },9855 },
9650 true => switch (src_ra.isVector()) {9856 true => switch (src_ra.isVector()) {
9651 false => switch (vi.size(isel)) {9857 false => size: switch (vi.size(isel)) {
9652 else => unreachable,9858 else => unreachable,
9653 2 => .fmov(dst_ra.h(), .{ .register = src_ra.w() }),9859 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))
9860 .fmov(dst_ra.h(), .{ .register = src_ra.w() })
9861 else
9862 continue :size 4,
9654 4 => .fmov(dst_ra.s(), .{ .register = src_ra.w() }),9863 4 => .fmov(dst_ra.s(), .{ .register = src_ra.w() }),
9655 8 => .fmov(dst_ra.d(), .{ .register = src_ra.x() }),9864 8 => .fmov(dst_ra.d(), .{ .register = src_ra.x() }),
9656 },9865 },
9657 true => switch (vi.size(isel)) {9866 true => switch (vi.size(isel)) {
9658 else => unreachable,9867 else => unreachable,
9659 2 => .fmov(dst_ra.h(), .{ .register = src_ra.h() }),9868 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))
9869 .fmov(dst_ra.h(), .{ .register = src_ra.h() })
9870 else
9871 .dup(dst_ra.h(), src_ra.@"h[]"(0)),
9660 4 => .fmov(dst_ra.s(), .{ .register = src_ra.s() }),9872 4 => .fmov(dst_ra.s(), .{ .register = src_ra.s() }),
9661 8 => .fmov(dst_ra.d(), .{ .register = src_ra.d() }),9873 8 => .fmov(dst_ra.d(), .{ .register = src_ra.d() }),
9662 16 => .orr(dst_ra.@"16b"(), src_ra.@"16b"(), .{ .register = src_ra.@"16b"() }),9874 16 => .orr(dst_ra.@"16b"(), src_ra.@"16b"(), .{ .register = src_ra.@"16b"() }),
...@@ -9713,9 +9925,12 @@ pub const Value = struct {...@@ -9713,9 +9925,12 @@ pub const Value = struct {
9713 const part_size = part_vi.size(isel);9925 const part_size = part_vi.size(isel);
9714 const part_ra = if (part_vi.isVector(isel)) try isel.allocIntReg() else dst_ra;9926 const part_ra = if (part_vi.isVector(isel)) try isel.allocIntReg() else dst_ra;
9715 defer if (part_ra != dst_ra) isel.freeReg(part_ra);9927 defer if (part_ra != dst_ra) isel.freeReg(part_ra);
9716 if (part_ra != dst_ra) try isel.emit(switch (part_size) {9928 if (part_ra != dst_ra) try isel.emit(part_size: switch (part_size) {
9717 else => unreachable,9929 else => unreachable,
9718 2 => .fmov(dst_ra.h(), .{ .register = part_ra.w() }),9930 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))
9931 .fmov(dst_ra.h(), .{ .register = part_ra.w() })
9932 else
9933 continue :part_size 4,
9719 4 => .fmov(dst_ra.s(), .{ .register = part_ra.w() }),9934 4 => .fmov(dst_ra.s(), .{ .register = part_ra.w() }),
9720 8 => .fmov(dst_ra.d(), .{ .register = part_ra.x() }),9935 8 => .fmov(dst_ra.d(), .{ .register = part_ra.x() }),
9721 });9936 });
...@@ -10360,7 +10575,10 @@ pub const Value = struct {...@@ -10360,7 +10575,10 @@ pub const Value = struct {
10360 if (vi.register(isel)) |ra| {10575 if (vi.register(isel)) |ra| {
10361 if (ra != mat.ra) break :free try isel.emit(if (vi == mat.vi) if (mat.ra.isVector()) switch (size) {10576 if (ra != mat.ra) break :free try isel.emit(if (vi == mat.vi) if (mat.ra.isVector()) switch (size) {
10362 else => unreachable,10577 else => unreachable,
10363 2 => .fmov(mat.ra.h(), .{ .register = ra.h() }),10578 2 => if (isel.target.cpu.has(.aarch64, .fullfp16))
10579 .fmov(mat.ra.h(), .{ .register = ra.h() })
10580 else
10581 .dup(mat.ra.h(), ra.@"h[]"(0)),
10364 4 => .fmov(mat.ra.s(), .{ .register = ra.s() }),10582 4 => .fmov(mat.ra.s(), .{ .register = ra.s() }),
10365 8 => .fmov(mat.ra.d(), .{ .register = ra.d() }),10583 8 => .fmov(mat.ra.d(), .{ .register = ra.d() }),
10366 16 => .orr(mat.ra.@"16b"(), ra.@"16b"(), .{ .register = ra.@"16b"() }),10584 16 => .orr(mat.ra.@"16b"(), ra.@"16b"(), .{ .register = ra.@"16b"() }),
src/codegen/aarch64/encoding.zig+4802-1278
...@@ -81,6 +81,14 @@ pub const Register = struct {...@@ -81,6 +81,14 @@ pub const Register = struct {
81 .@"16b", .@"8b" => .byte,81 .@"16b", .@"8b" => .byte,
82 };82 };
83 }83 }
84
85 pub fn elemSz(arrangement: Arrangement) Instruction.DataProcessingVector.Sz {
86 return switch (arrangement) {
87 else => unreachable,
88 .@"2d", .@"1d" => .double,
89 .@"4s", .@"2s" => .single,
90 };
91 }
84 };92 };
8593
86 pub const x0: Register = .{ .alias = .r0, .format = .{ .integer = .doubleword } };94 pub const x0: Register = .{ .alias = .r0, .format = .{ .integer = .doubleword } };
...@@ -6817,7 +6825,7 @@ pub const Instruction = packed union {...@@ -6817,7 +6825,7 @@ pub const Instruction = packed union {
6817 o0: AddSubtractOp = .add,6825 o0: AddSubtractOp = .add,
6818 Rm: Register.Encoded,6826 Rm: Register.Encoded,
6819 op21: u2 = 0b01,6827 op21: u2 = 0b01,
6820 U: bool = false,6828 U: std.builtin.Signedness = .signed,
6821 decoded24: u5 = 0b11011,6829 decoded24: u5 = 0b11011,
6822 op54: u2 = 0b00,6830 op54: u2 = 0b00,
6823 sf: Register.IntegerSize = .doubleword,6831 sf: Register.IntegerSize = .doubleword,
...@@ -6831,7 +6839,7 @@ pub const Instruction = packed union {...@@ -6831,7 +6839,7 @@ pub const Instruction = packed union {
6831 o0: AddSubtractOp = .sub,6839 o0: AddSubtractOp = .sub,
6832 Rm: Register.Encoded,6840 Rm: Register.Encoded,
6833 op21: u2 = 0b01,6841 op21: u2 = 0b01,
6834 U: bool = false,6842 U: std.builtin.Signedness = .signed,
6835 decoded24: u5 = 0b11011,6843 decoded24: u5 = 0b11011,
6836 op54: u2 = 0b00,6844 op54: u2 = 0b00,
6837 sf: Register.IntegerSize = .doubleword,6845 sf: Register.IntegerSize = .doubleword,
...@@ -6845,7 +6853,7 @@ pub const Instruction = packed union {...@@ -6845,7 +6853,7 @@ pub const Instruction = packed union {
6845 o0: AddSubtractOp = .add,6853 o0: AddSubtractOp = .add,
6846 Rm: Register.Encoded,6854 Rm: Register.Encoded,
6847 op21: u2 = 0b10,6855 op21: u2 = 0b10,
6848 U: bool = false,6856 U: std.builtin.Signedness = .signed,
6849 decoded24: u5 = 0b11011,6857 decoded24: u5 = 0b11011,
6850 op54: u2 = 0b00,6858 op54: u2 = 0b00,
6851 sf: Register.IntegerSize = .doubleword,6859 sf: Register.IntegerSize = .doubleword,
...@@ -6859,7 +6867,7 @@ pub const Instruction = packed union {...@@ -6859,7 +6867,7 @@ pub const Instruction = packed union {
6859 o0: AddSubtractOp = .add,6867 o0: AddSubtractOp = .add,
6860 Rm: Register.Encoded,6868 Rm: Register.Encoded,
6861 op21: u2 = 0b01,6869 op21: u2 = 0b01,
6862 U: bool = true,6870 U: std.builtin.Signedness = .unsigned,
6863 decoded24: u5 = 0b11011,6871 decoded24: u5 = 0b11011,
6864 op54: u2 = 0b00,6872 op54: u2 = 0b00,
6865 sf: Register.IntegerSize = .doubleword,6873 sf: Register.IntegerSize = .doubleword,
...@@ -6873,7 +6881,7 @@ pub const Instruction = packed union {...@@ -6873,7 +6881,7 @@ pub const Instruction = packed union {
6873 o0: AddSubtractOp = .sub,6881 o0: AddSubtractOp = .sub,
6874 Rm: Register.Encoded,6882 Rm: Register.Encoded,
6875 op21: u2 = 0b01,6883 op21: u2 = 0b01,
6876 U: bool = true,6884 U: std.builtin.Signedness = .unsigned,
6877 decoded24: u5 = 0b11011,6885 decoded24: u5 = 0b11011,
6878 op54: u2 = 0b00,6886 op54: u2 = 0b00,
6879 sf: Register.IntegerSize = .doubleword,6887 sf: Register.IntegerSize = .doubleword,
...@@ -6887,7 +6895,7 @@ pub const Instruction = packed union {...@@ -6887,7 +6895,7 @@ pub const Instruction = packed union {
6887 o0: AddSubtractOp = .add,6895 o0: AddSubtractOp = .add,
6888 Rm: Register.Encoded,6896 Rm: Register.Encoded,
6889 op21: u2 = 0b10,6897 op21: u2 = 0b10,
6890 U: bool = true,6898 U: std.builtin.Signedness = .unsigned,
6891 decoded24: u5 = 0b11011,6899 decoded24: u5 = 0b11011,
6892 op54: u2 = 0b00,6900 op54: u2 = 0b00,
6893 sf: Register.IntegerSize = .doubleword,6901 sf: Register.IntegerSize = .doubleword,
...@@ -7009,8 +7017,12 @@ pub const Instruction = packed union {...@@ -7009,8 +7017,12 @@ pub const Instruction = packed union {
7009 /// C4.1.90 Data Processing -- Scalar Floating-Point and Advanced SIMD7017 /// C4.1.90 Data Processing -- Scalar Floating-Point and Advanced SIMD
7010 pub const DataProcessingVector = packed union {7018 pub const DataProcessingVector = packed union {
7011 group: @This().Group,7019 group: @This().Group,
7020 simd_scalar_copy: SimdScalarCopy,
7021 simd_scalar_two_register_miscellaneous_fp16: SimdScalarTwoRegisterMiscellaneousFp16,
7022 simd_scalar_two_register_miscellaneous: SimdScalarTwoRegisterMiscellaneous,
7012 simd_scalar_pairwise: SimdScalarPairwise,7023 simd_scalar_pairwise: SimdScalarPairwise,
7013 simd_copy: SimdCopy,7024 simd_copy: SimdCopy,
7025 simd_two_register_miscellaneous_fp16: SimdTwoRegisterMiscellaneousFp16,
7014 simd_two_register_miscellaneous: SimdTwoRegisterMiscellaneous,7026 simd_two_register_miscellaneous: SimdTwoRegisterMiscellaneous,
7015 simd_across_lanes: SimdAcrossLanes,7027 simd_across_lanes: SimdAcrossLanes,
7016 simd_three_same: SimdThreeSame,7028 simd_three_same: SimdThreeSame,
...@@ -7020,6 +7032,7 @@ pub const Instruction = packed union {...@@ -7020,6 +7032,7 @@ pub const Instruction = packed union {
7020 float_compare: FloatCompare,7032 float_compare: FloatCompare,
7021 float_immediate: FloatImmediate,7033 float_immediate: FloatImmediate,
7022 float_data_processing_two_source: FloatDataProcessingTwoSource,7034 float_data_processing_two_source: FloatDataProcessingTwoSource,
7035 float_conditional_select: FloatConditionalSelect,
7023 float_data_processing_three_source: FloatDataProcessingThreeSource,7036 float_data_processing_three_source: FloatDataProcessingThreeSource,
70247037
7025 /// Table C4-91 Encoding table for the Data Processing -- Scalar Floating-Point and Advanced SIMD group7038 /// Table C4-91 Encoding table for the Data Processing -- Scalar Floating-Point and Advanced SIMD group
...@@ -7032,42 +7045,10 @@ pub const Instruction = packed union {...@@ -7032,42 +7045,10 @@ pub const Instruction = packed union {
7032 op0: u4,7045 op0: u4,
7033 };7046 };
70347047
7035 /// Advanced SIMD scalar pairwise7048 /// Advanced SIMD scalar copy
7036 pub const SimdScalarPairwise = packed union {7049 pub const SimdScalarCopy = packed union {
7037 group: @This().Group,
7038 addp: Addp,
7039
7040 pub const Group = packed struct {
7041 Rd: Register.Encoded,
7042 Rn: Register.Encoded,
7043 decoded10: u2 = 0b10,
7044 opcode: u5,
7045 decoded17: u5 = 0b11000,
7046 size: Size,
7047 decoded24: u5 = 0b11110,
7048 U: u1,
7049 decoded30: u2 = 0b01,
7050 };
7051
7052 /// C7.2.4 ADDP (scalar)
7053 pub const Addp = packed struct {
7054 Rd: Register.Encoded,
7055 Rn: Register.Encoded,
7056 decoded10: u2 = 0b10,
7057 opcode: u5 = 0b11011,
7058 decoded17: u5 = 0b11000,
7059 size: Size,
7060 decoded24: u5 = 0b11110,
7061 U: u1 = 0b0,
7062 decoded30: u2 = 0b01,
7063 };
7064 };
7065
7066 /// Advanced SIMD copy
7067 pub const SimdCopy = packed union {
7068 group: @This().Group,7050 group: @This().Group,
7069 smov: Smov,7051 dup: Dup,
7070 umov: Umov,
70717052
7072 pub const Group = packed struct {7053 pub const Group = packed struct {
7073 Rd: Register.Encoded,7054 Rd: Register.Encoded,
...@@ -7076,1127 +7057,3375 @@ pub const Instruction = packed union {...@@ -7076,1127 +7057,3375 @@ pub const Instruction = packed union {
7076 imm4: u4,7057 imm4: u4,
7077 decoded15: u1 = 0b0,7058 decoded15: u1 = 0b0,
7078 imm5: u5,7059 imm5: u5,
7079 decoded21: u8 = 0b01110000,7060 decoded21: u8 = 0b11110000,
7080 op: u1,7061 op: u1,
7081 Q: Register.IntegerSize,7062 decoded30: u2 = 0b01,
7082 decoded31: u1 = 0b0,
7083 };7063 };
70847064
7085 /// C7.2.279 SMOV7065 /// C7.2.39 DUP (element)
7086 pub const Smov = packed struct {7066 pub const Dup = packed struct {
7087 Rd: Register.Encoded,7067 Rd: Register.Encoded,
7088 Rn: Register.Encoded,7068 Rn: Register.Encoded,
7089 decoded10: u1 = 0b1,7069 decoded10: u1 = 0b1,
7090 decoded11: u1 = 0b1,7070 imm4: u4 = 0b0000,
7091 decoded12: u1 = 0b0,
7092 decoded13: u2 = 0b01,
7093 decoded15: u1 = 0b0,7071 decoded15: u1 = 0b0,
7094 imm5: u5,7072 imm5: u5,
7095 decoded21: u8 = 0b01110000,7073 decoded21: u8 = 0b11110000,
7096 decoded29: u1 = 0b0,7074 op: u1 = 0b0,
7097 Q: Register.IntegerSize,7075 decoded30: u2 = 0b01,
7098 decoded31: u1 = 0b0,
7099 };7076 };
71007077
7101 /// C7.2.371 UMOV7078 pub const Decoded = union(enum) {
7102 pub const Umov = packed struct {7079 unallocated,
7103 Rd: Register.Encoded,7080 dup: Dup,
7104 Rn: Register.Encoded,
7105 decoded10: u1 = 0b1,
7106 decoded11: u1 = 0b1,
7107 decoded12: u1 = 0b1,
7108 decoded13: u2 = 0b01,
7109 decoded15: u1 = 0b0,
7110 imm5: u5,
7111 decoded21: u8 = 0b01110000,
7112 decoded29: u1 = 0b0,
7113 Q: Register.IntegerSize,
7114 decoded31: u1 = 0b0,
7115 };7081 };
7082 pub fn decode(inst: @This()) @This().Decoded {
7083 return switch (inst.group.op) {
7084 0b0 => switch (inst.group.imm4) {
7085 else => .unallocated,
7086 0b0000 => .{ .dup = inst.dup },
7087 },
7088 0b1 => .unallocated,
7089 };
7090 }
7116 };7091 };
71177092
7118 /// Advanced SIMD two-register miscellaneous7093 /// Advanced SIMD scalar two-register miscellaneous FP16
7119 pub const SimdTwoRegisterMiscellaneous = packed union {7094 pub const SimdScalarTwoRegisterMiscellaneousFp16 = packed union {
7120 group: @This().Group,7095 group: @This().Group,
7121 cnt: Cnt,7096 fcvtns: Fcvtns,
7097 fcvtms: Fcvtms,
7098 fcvtas: Fcvtas,
7099 scvtf: Scvtf,
7100 fcmgt: Fcmgt,
7101 fcmeq: Fcmeq,
7102 fcmlt: Fcmlt,
7103 fcvtps: Fcvtps,
7104 fcvtzs: Fcvtzs,
7105 frecpe: Frecpe,
7106 frecpx: Frecpx,
7107 fcvtnu: Fcvtnu,
7108 fcvtmu: Fcvtmu,
7109 fcvtau: Fcvtau,
7110 ucvtf: Ucvtf,
7111 fcmge: Fcmge,
7112 fcmle: Fcmle,
7113 fcvtpu: Fcvtpu,
7114 fcvtzu: Fcvtzu,
7115 frsqrte: Frsqrte,
71227116
7123 pub const Group = packed struct {7117 pub const Group = packed struct {
7124 Rd: Register.Encoded,7118 Rd: Register.Encoded,
7125 Rn: Register.Encoded,7119 Rn: Register.Encoded,
7126 decoded10: u2 = 0b10,7120 decoded10: u2 = 0b10,
7127 opcode: u5,7121 opcode: u5,
7128 decoded17: u5 = 0b10000,7122 decoded17: u6 = 0b111100,
7129 size: Size,7123 a: u1,
7130 decoded24: u5 = 0b01110,7124 decoded24: u5 = 0b11110,
7131 U: u1,7125 U: std.builtin.Signedness,
7132 Q: Q,7126 decoded30: u2 = 0b01,
7133 decoded31: u1 = 0b0,
7134 };7127 };
71357128
7136 /// C7.2.38 CNT7129 /// C7.2.80 FCVTNS (vector)
7137 pub const Cnt = packed struct {7130 pub const Fcvtns = packed struct {
7138 Rd: Register.Encoded,7131 Rd: Register.Encoded,
7139 Rn: Register.Encoded,7132 Rn: Register.Encoded,
7140 decoded10: u2 = 0b10,7133 decoded10: u2 = 0b10,
7141 opcode: u5 = 0b00101,7134 opcode: u5 = 0b11010,
7142 decoded17: u5 = 0b10000,7135 decoded17: u6 = 0b111100,
7143 size: Size,7136 o2: u1 = 0b0,
7144 decoded24: u5 = 0b01110,7137 decoded24: u5 = 0b11110,
7145 U: u1 = 0b0,7138 U: std.builtin.Signedness = .signed,
7146 Q: Q,7139 decoded30: u2 = 0b01,
7147 decoded31: u1 = 0b0,
7148 };7140 };
7149 };
7150
7151 /// Advanced SIMD across lanes
7152 pub const SimdAcrossLanes = packed union {
7153 group: @This().Group,
7154 addv: Addv,
71557141
7156 pub const Group = packed struct {7142 /// C7.2.75 FCVTMS (vector)
7143 pub const Fcvtms = packed struct {
7157 Rd: Register.Encoded,7144 Rd: Register.Encoded,
7158 Rn: Register.Encoded,7145 Rn: Register.Encoded,
7159 decoded10: u2 = 0b10,7146 decoded10: u2 = 0b10,
7160 opcode: u5,7147 opcode: u5 = 0b11011,
7161 decoded17: u5 = 0b11000,7148 decoded17: u6 = 0b111100,
7162 size: Size,7149 o2: u1 = 0b0,
7163 decoded24: u5 = 0b01110,7150 decoded24: u5 = 0b11110,
7164 U: u1,7151 U: std.builtin.Signedness = .signed,
7165 Q: Q,7152 decoded30: u2 = 0b01,
7166 decoded31: u1 = 0b0,
7167 };7153 };
71687154
7169 /// C7.2.6 ADDV7155 /// C7.2.70 FCVTAS (vector)
7170 pub const Addv = packed struct {7156 pub const Fcvtas = packed struct {
7171 Rd: Register.Encoded,7157 Rd: Register.Encoded,
7172 Rn: Register.Encoded,7158 Rn: Register.Encoded,
7173 decoded10: u2 = 0b10,7159 decoded10: u2 = 0b10,
7174 opcode: u5 = 0b11011,7160 opcode: u5 = 0b11100,
7175 decoded17: u5 = 0b11000,7161 decoded17: u6 = 0b111100,
7176 size: Size,7162 o2: u1 = 0b0,
7177 decoded24: u5 = 0b01110,7163 decoded24: u5 = 0b11110,
7178 U: u1 = 0b0,7164 U: std.builtin.Signedness = .signed,
7179 Q: Q,7165 decoded30: u2 = 0b01,
7180 decoded31: u1 = 0b0,
7181 };7166 };
7182 };
71837167
7184 /// Advanced SIMD three same7168 /// C7.2.234 SCVTF (vector, integer)
7185 pub const SimdThreeSame = packed union {7169 pub const Scvtf = packed struct {
7186 group: @This().Group,7170 Rd: Register.Encoded,
7187 addp: Addp,7171 Rn: Register.Encoded,
7188 @"and": And,7172 decoded10: u2 = 0b10,
7189 bic: Bic,7173 opcode: u5 = 0b11101,
7190 orr: Orr,7174 decoded17: u6 = 0b111100,
7191 orn: Orn,7175 o2: u1 = 0b0,
7192 eor: Eor,7176 decoded24: u5 = 0b11110,
7177 U: std.builtin.Signedness = .signed,
7178 decoded30: u2 = 0b01,
7179 };
71937180
7194 pub const Group = packed struct {7181 /// C7.2.61 FCMGT (zero)
7182 pub const Fcmgt = packed struct {
7195 Rd: Register.Encoded,7183 Rd: Register.Encoded,
7196 Rn: Register.Encoded,7184 Rn: Register.Encoded,
7197 decoded10: u1 = 0b1,7185 decoded10: u2 = 0b10,
7198 opcode: u5,7186 opcode: u5 = 0b01100,
7199 Rm: Register.Encoded,7187 decoded17: u6 = 0b111100,
7200 decoded21: u1 = 0b1,7188 o2: u1 = 0b1,
7201 size: Size,7189 decoded24: u5 = 0b11110,
7202 decoded24: u5 = 0b01110,7190 U: std.builtin.Signedness = .signed,
7203 U: u1,7191 decoded30: u2 = 0b01,
7204 Q: Q,
7205 decoded31: u1 = 0b0,
7206 };7192 };
72077193
7208 /// C7.2.5 ADDP (vector)7194 /// C7.2.57 FCMEQ (zero)
7209 pub const Addp = packed struct {7195 pub const Fcmeq = packed struct {
7210 Rd: Register.Encoded,7196 Rd: Register.Encoded,
7211 Rn: Register.Encoded,7197 Rn: Register.Encoded,
7212 decoded10: u1 = 0b1,7198 decoded10: u2 = 0b10,
7213 opcode: u5 = 0b10111,7199 opcode: u5 = 0b01101,
7214 Rm: Register.Encoded,7200 decoded17: u6 = 0b111100,
7215 decoded21: u1 = 0b1,7201 o2: u1 = 0b1,
7216 size: Size,7202 decoded24: u5 = 0b11110,
7217 decoded24: u5 = 0b01110,7203 U: std.builtin.Signedness = .signed,
7218 U: u1 = 0b0,7204 decoded30: u2 = 0b01,
7219 Q: Q,
7220 decoded31: u1 = 0b0,
7221 };7205 };
72227206
7223 /// C7.2.11 AND (vector)7207 /// C7.2.65 FCMLT (zero)
7224 pub const And = packed struct {7208 pub const Fcmlt = packed struct {
7225 Rd: Register.Encoded,7209 Rd: Register.Encoded,
7226 Rn: Register.Encoded,7210 Rn: Register.Encoded,
7227 decoded10: u1 = 0b1,7211 decoded10: u2 = 0b10,
7228 opcode: u5 = 0b00011,7212 opcode: u5 = 0b01110,
7229 Rm: Register.Encoded,7213 decoded17: u6 = 0b111100,
7230 decoded21: u1 = 0b1,7214 o2: u1 = 0b1,
7231 size: Size = .byte,7215 decoded24: u5 = 0b11110,
7232 decoded24: u5 = 0b01110,7216 U: std.builtin.Signedness = .signed,
7233 U: u1 = 0b0,7217 decoded30: u2 = 0b01,
7234 Q: Q,
7235 decoded31: u1 = 0b0,
7236 };7218 };
72377219
7238 /// C7.2.21 BIC (vector, register)7220 /// C7.2.84 FCVTPS (vector)
7239 pub const Bic = packed struct {7221 pub const Fcvtps = packed struct {
7240 Rd: Register.Encoded,7222 Rd: Register.Encoded,
7241 Rn: Register.Encoded,7223 Rn: Register.Encoded,
7242 decoded10: u1 = 0b1,7224 decoded10: u2 = 0b10,
7243 opcode: u5 = 0b00011,7225 opcode: u5 = 0b11010,
7244 Rm: Register.Encoded,7226 decoded17: u6 = 0b111100,
7245 decoded21: u1 = 0b1,7227 o2: u1 = 0b1,
7246 size: Size = .half,7228 decoded24: u5 = 0b11110,
7247 decoded24: u5 = 0b01110,7229 U: std.builtin.Signedness = .signed,
7248 U: u1 = 0b0,7230 decoded30: u2 = 0b01,
7249 Q: Q,
7250 decoded31: u1 = 0b0,
7251 };7231 };
72527232
7253 /// C7.2.213 ORR (vector, register)7233 /// C7.2.90 FCVTZS (vector, integer)
7254 pub const Orr = packed struct {7234 pub const Fcvtzs = packed struct {
7255 Rd: Register.Encoded,7235 Rd: Register.Encoded,
7256 Rn: Register.Encoded,7236 Rn: Register.Encoded,
7257 decoded10: u1 = 0b1,7237 decoded10: u2 = 0b10,
7258 opcode: u5 = 0b00011,7238 opcode: u5 = 0b11011,
7259 Rm: Register.Encoded,7239 decoded17: u6 = 0b111100,
7260 decoded21: u1 = 0b1,7240 o2: u1 = 0b1,
7261 size: Size = .single,7241 decoded24: u5 = 0b11110,
7262 decoded24: u5 = 0b01110,7242 U: std.builtin.Signedness = .signed,
7263 U: u1 = 0b0,7243 decoded30: u2 = 0b01,
7264 Q: Q,
7265 decoded31: u1 = 0b0,
7266 };7244 };
72677245
7268 /// C7.2.211 ORN (vector)7246 /// C7.2.144 FRECPE
7269 pub const Orn = packed struct {7247 pub const Frecpe = packed struct {
7270 Rd: Register.Encoded,7248 Rd: Register.Encoded,
7271 Rn: Register.Encoded,7249 Rn: Register.Encoded,
7272 decoded10: u1 = 0b1,7250 decoded10: u2 = 0b10,
7273 opcode: u5 = 0b00011,7251 opcode: u5 = 0b11101,
7274 Rm: Register.Encoded,7252 decoded17: u6 = 0b111100,
7275 decoded21: u1 = 0b1,7253 o2: u1 = 0b1,
7276 size: Size = .double,7254 decoded24: u5 = 0b11110,
7277 decoded24: u5 = 0b01110,7255 U: std.builtin.Signedness = .signed,
7278 U: u1 = 0b0,7256 decoded30: u2 = 0b01,
7279 Q: Q,
7280 decoded31: u1 = 0b0,
7281 };7257 };
72827258
7283 /// C7.2.41 EOR (vector)7259 /// C7.2.146 FRECPX
7284 pub const Eor = packed struct {7260 pub const Frecpx = packed struct {
7285 Rd: Register.Encoded,7261 Rd: Register.Encoded,
7286 Rn: Register.Encoded,7262 Rn: Register.Encoded,
7287 decoded10: u1 = 0b1,7263 decoded10: u2 = 0b10,
7288 opcode: u5 = 0b00011,7264 opcode: u5 = 0b11111,
7289 Rm: Register.Encoded,7265 decoded17: u6 = 0b111100,
7290 decoded21: u1 = 0b1,7266 o2: u1 = 0b1,
7291 size: Size = .byte,7267 decoded24: u5 = 0b11110,
7292 decoded24: u5 = 0b01110,7268 U: std.builtin.Signedness = .signed,
7293 U: u1 = 0b1,7269 decoded30: u2 = 0b01,
7294 Q: Q,
7295 decoded31: u1 = 0b0,
7296 };7270 };
7297 };
72987271
7299 /// Advanced SIMD modified immediate7272 /// C7.2.82 FCVTNU (vector)
7300 pub const SimdModifiedImmediate = packed union {7273 pub const Fcvtnu = packed struct {
7301 group: @This().Group,7274 Rd: Register.Encoded,
7302 movi: Movi,7275 Rn: Register.Encoded,
7303 orr: Orr,7276 decoded10: u2 = 0b10,
7304 fmov: Fmov,7277 opcode: u5 = 0b11010,
7305 mvni: Mvni,7278 decoded17: u6 = 0b111100,
7306 bic: Bic,7279 o2: u1 = 0b0,
7280 decoded24: u5 = 0b11110,
7281 U: std.builtin.Signedness = .unsigned,
7282 decoded30: u2 = 0b01,
7283 };
73077284
7308 pub const Group = packed struct {7285 /// C7.2.77 FCVTMU (vector)
7286 pub const Fcvtmu = packed struct {
7309 Rd: Register.Encoded,7287 Rd: Register.Encoded,
7310 imm5: u5,7288 Rn: Register.Encoded,
7311 decoded10: u1 = 0b1,7289 decoded10: u2 = 0b10,
7312 o2: u1,7290 opcode: u5 = 0b11011,
7313 cmode: u4,7291 decoded17: u6 = 0b111100,
7314 imm3: u3,7292 o2: u1 = 0b0,
7315 decoded19: u10 = 0b0111100000,7293 decoded24: u5 = 0b11110,
7316 op: u1,7294 U: std.builtin.Signedness = .unsigned,
7317 Q: Q,7295 decoded30: u2 = 0b01,
7318 decoded31: u1 = 0b0,
7319 };7296 };
73207297
7321 /// C7.2.204 MOVI7298 /// C7.2.72 FCVTAU (vector)
7322 pub const Movi = packed struct {7299 pub const Fcvtau = packed struct {
7323 Rd: Register.Encoded,7300 Rd: Register.Encoded,
7324 imm5: u5,7301 Rn: Register.Encoded,
7325 decoded10: u1 = 0b1,7302 decoded10: u2 = 0b10,
7303 opcode: u5 = 0b11100,
7304 decoded17: u6 = 0b111100,
7326 o2: u1 = 0b0,7305 o2: u1 = 0b0,
7327 cmode: u4,7306 decoded24: u5 = 0b11110,
7328 imm3: u3,7307 U: std.builtin.Signedness = .unsigned,
7329 decoded19: u10 = 0b0111100000,7308 decoded30: u2 = 0b01,
7330 op: u1,
7331 Q: Q,
7332 decoded31: u1 = 0b0,
7333 };7309 };
73347310
7335 /// C7.2.212 ORR (vector, immediate)7311 /// C7.2.353 UCVTF (vector, integer)
7336 pub const Orr = packed struct {7312 pub const Ucvtf = packed struct {
7337 Rd: Register.Encoded,7313 Rd: Register.Encoded,
7338 imm5: u5,7314 Rn: Register.Encoded,
7339 decoded10: u1 = 0b1,7315 decoded10: u2 = 0b10,
7316 opcode: u5 = 0b11101,
7317 decoded17: u6 = 0b111100,
7340 o2: u1 = 0b0,7318 o2: u1 = 0b0,
7341 cmode0: u1 = 0b1,7319 decoded24: u5 = 0b11110,
7342 cmode: u3,7320 U: std.builtin.Signedness = .unsigned,
7343 imm3: u3,7321 decoded30: u2 = 0b01,
7344 decoded19: u10 = 0b0111100000,
7345 op: u1 = 0b0,
7346 Q: Q,
7347 decoded31: u1 = 0b0,
7348 };7322 };
73497323
7350 /// C7.2.129 FMOV (vector, immediate)7324 /// C7.2.59 FCMGE (zero)
7351 pub const Fmov = packed struct {7325 pub const Fcmge = packed struct {
7352 Rd: Register.Encoded,7326 Rd: Register.Encoded,
7353 imm5: u5,7327 Rn: Register.Encoded,
7354 decoded10: u1 = 0b1,7328 decoded10: u2 = 0b10,
7329 opcode: u5 = 0b01100,
7330 decoded17: u6 = 0b111100,
7355 o2: u1 = 0b1,7331 o2: u1 = 0b1,
7356 cmode: u4 = 0b1111,7332 decoded24: u5 = 0b11110,
7357 imm3: u3,7333 U: std.builtin.Signedness = .unsigned,
7358 decoded19: u10 = 0b0111100000,7334 decoded30: u2 = 0b01,
7359 op: u1 = 0b0,
7360 Q: Q,
7361 decoded31: u1 = 0b0,
7362 };7335 };
73637336
7364 /// C7.2.208 MVNI7337 /// C7.2.64 FCMLE (zero)
7365 pub const Mvni = packed struct {7338 pub const Fcmle = packed struct {
7366 Rd: Register.Encoded,7339 Rd: Register.Encoded,
7367 imm5: u5,7340 Rn: Register.Encoded,
7368 decoded10: u1 = 0b1,7341 decoded10: u2 = 0b10,
7369 o2: u1 = 0b0,7342 opcode: u5 = 0b01101,
7370 cmode: u4,7343 decoded17: u6 = 0b111100,
7371 imm3: u3,7344 o2: u1 = 0b1,
7372 decoded19: u10 = 0b0111100000,7345 decoded24: u5 = 0b11110,
7373 op: u1 = 0b1,7346 U: std.builtin.Signedness = .unsigned,
7374 Q: Q,7347 decoded30: u2 = 0b01,
7375 decoded31: u1 = 0b0,
7376 };7348 };
73777349
7378 /// C7.2.20 BIC (vector, immediate)7350 /// C7.2.86 FCVTPU (vector)
7379 pub const Bic = packed struct {7351 pub const Fcvtpu = packed struct {
7380 Rd: Register.Encoded,7352 Rd: Register.Encoded,
7381 imm5: u5,7353 Rn: Register.Encoded,
7382 decoded10: u1 = 0b1,7354 decoded10: u2 = 0b10,
7383 o2: u1 = 0b0,7355 opcode: u5 = 0b11010,
7384 cmode0: u1 = 0b1,7356 decoded17: u6 = 0b111100,
7385 cmode: u3,7357 o2: u1 = 0b1,
7386 imm3: u3,7358 decoded24: u5 = 0b11110,
7387 decoded19: u10 = 0b0111100000,7359 U: std.builtin.Signedness = .unsigned,
7388 op: u1 = 0b1,7360 decoded30: u2 = 0b01,
7389 Q: Q,7361 };
7390 decoded31: u1 = 0b0,7362
7363 /// C7.2.94 FCVTZU (vector, integer)
7364 pub const Fcvtzu = packed struct {
7365 Rd: Register.Encoded,
7366 Rn: Register.Encoded,
7367 decoded10: u2 = 0b10,
7368 opcode: u5 = 0b11011,
7369 decoded17: u6 = 0b111100,
7370 o2: u1 = 0b1,
7371 decoded24: u5 = 0b11110,
7372 U: std.builtin.Signedness = .unsigned,
7373 decoded30: u2 = 0b01,
7374 };
7375
7376 /// C7.2.169 FRSQRTE
7377 pub const Frsqrte = packed struct {
7378 Rd: Register.Encoded,
7379 Rn: Register.Encoded,
7380 decoded10: u2 = 0b10,
7381 opcode: u5 = 0b11101,
7382 decoded17: u6 = 0b111100,
7383 o2: u1 = 0b1,
7384 decoded24: u5 = 0b11110,
7385 U: std.builtin.Signedness = .unsigned,
7386 decoded30: u2 = 0b01,
7391 };7387 };
7392 };7388 };
73937389
7394 /// Conversion between floating-point and integer7390 /// Advanced SIMD scalar two-register miscellaneous
7395 pub const ConvertFloatInteger = packed union {7391 pub const SimdScalarTwoRegisterMiscellaneous = packed union {
7396 group: @This().Group,7392 group: @This().Group,
7393 suqadd: Suqadd,
7394 sqabs: Sqabs,
7395 cmgt: Cmgt,
7396 cmeq: Cmeq,
7397 cmlt: Cmlt,
7398 abs: Abs,
7399 sqxtn: Sqxtn,
7397 fcvtns: Fcvtns,7400 fcvtns: Fcvtns,
7398 fcvtnu: Fcvtnu,7401 fcvtms: Fcvtms,
7399 scvtf: Scvtf,
7400 ucvtf: Ucvtf,
7401 fcvtas: Fcvtas,7402 fcvtas: Fcvtas,
7402 fcvtau: Fcvtau,7403 scvtf: Scvtf,
7403 fmov: Fmov,7404 fcmgt: Fcmgt,
7405 fcmeq: Fcmeq,
7406 fcmlt: Fcmlt,
7404 fcvtps: Fcvtps,7407 fcvtps: Fcvtps,
7405 fcvtpu: Fcvtpu,
7406 fcvtms: Fcvtms,
7407 fcvtmu: Fcvtmu,
7408 fcvtzs: Fcvtzs,7408 fcvtzs: Fcvtzs,
7409 frecpe: Frecpe,
7410 frecpx: Frecpx,
7411 usqadd: Usqadd,
7412 sqneg: Sqneg,
7413 cmge: Cmge,
7414 cmle: Cmle,
7415 neg: Neg,
7416 sqxtun: Sqxtun,
7417 uqxtn: Uqxtn,
7418 fcvtxn: Fcvtxn,
7419 fcvtnu: Fcvtnu,
7420 fcvtmu: Fcvtmu,
7421 fcvtau: Fcvtau,
7422 ucvtf: Ucvtf,
7423 fcmge: Fcmge,
7424 fcmle: Fcmle,
7425 fcvtpu: Fcvtpu,
7409 fcvtzu: Fcvtzu,7426 fcvtzu: Fcvtzu,
7410 fjcvtzs: Fjcvtzs,7427 frsqrte: Frsqrte,
74117428
7412 pub const Group = packed struct {7429 pub const Group = packed struct {
7413 Rd: Register.Encoded,7430 Rd: Register.Encoded,
7414 Rn: Register.Encoded,7431 Rn: Register.Encoded,
7415 decoded10: u6 = 0b000000,7432 decoded10: u2 = 0b10,
7416 opcode: u3,7433 opcode: u5,
7417 rmode: u2,7434 decoded17: u5 = 0b10000,
7418 decoded21: u1 = 0b1,7435 size: Size,
7419 ptype: Ftype,
7420 decoded24: u5 = 0b11110,7436 decoded24: u5 = 0b11110,
7421 S: bool,7437 U: std.builtin.Signedness,
7422 decoded30: u1 = 0b0,7438 decoded30: u2 = 0b01,
7423 sf: Register.IntegerSize,
7424 };7439 };
74257440
7426 /// C7.2.81 FCVTNS (scalar)7441 /// C7.2.337 SUQADD
7427 pub const Fcvtns = packed struct {7442 pub const Suqadd = packed struct {
7428 Rd: Register.Encoded,7443 Rd: Register.Encoded,
7429 Rn: Register.Encoded,7444 Rn: Register.Encoded,
7430 decoded10: u6 = 0b000000,7445 decoded10: u2 = 0b10,
7431 opcode: u3 = 0b000,7446 opcode: u5 = 0b00011,
7432 rmode: Rmode = .n,7447 decoded17: u5 = 0b10000,
7433 decoded21: u1 = 0b1,7448 size: Size,
7434 ftype: Ftype,
7435 decoded24: u5 = 0b11110,7449 decoded24: u5 = 0b11110,
7436 S: bool = false,7450 U: std.builtin.Signedness = .signed,
7437 decoded30: u1 = 0b0,7451 decoded30: u2 = 0b01,
7438 sf: Register.IntegerSize,
7439 };7452 };
74407453
7441 /// C7.2.83 FCVTNU (scalar)7454 /// C7.2.282 SQABS
7442 pub const Fcvtnu = packed struct {7455 pub const Sqabs = packed struct {
7443 Rd: Register.Encoded,7456 Rd: Register.Encoded,
7444 Rn: Register.Encoded,7457 Rn: Register.Encoded,
7445 decoded10: u6 = 0b000000,7458 decoded10: u2 = 0b10,
7446 opcode: u3 = 0b001,7459 opcode: u5 = 0b00111,
7447 rmode: Rmode = .n,7460 decoded17: u5 = 0b10000,
7448 decoded21: u1 = 0b1,7461 size: Size,
7449 ftype: Ftype,
7450 decoded24: u5 = 0b11110,7462 decoded24: u5 = 0b11110,
7451 S: bool = false,7463 U: std.builtin.Signedness = .signed,
7452 decoded30: u1 = 0b0,7464 decoded30: u2 = 0b01,
7453 sf: Register.IntegerSize,
7454 };7465 };
74557466
7456 /// C7.2.236 SCVTF (scalar, integer)7467 /// C7.2.32 CMGT (zero)
7457 pub const Scvtf = packed struct {7468 pub const Cmgt = packed struct {
7458 Rd: Register.Encoded,7469 Rd: Register.Encoded,
7459 Rn: Register.Encoded,7470 Rn: Register.Encoded,
7460 decoded10: u6 = 0b000000,7471 decoded10: u2 = 0b10,
7461 opcode: u3 = 0b010,7472 opcode: u5 = 0b01000,
7462 rmode: Rmode = .n,7473 decoded17: u5 = 0b10000,
7463 decoded21: u1 = 0b1,7474 size: Size,
7464 ftype: Ftype,
7465 decoded24: u5 = 0b11110,7475 decoded24: u5 = 0b11110,
7466 S: bool = false,7476 U: std.builtin.Signedness = .signed,
7467 decoded30: u1 = 0b0,7477 decoded30: u2 = 0b01,
7468 sf: Register.IntegerSize,
7469 };7478 };
74707479
7471 /// C7.2.355 UCVTF (scalar, integer)7480 /// C7.2.28 CMEQ (zero)
7472 pub const Ucvtf = packed struct {7481 pub const Cmeq = packed struct {
7473 Rd: Register.Encoded,7482 Rd: Register.Encoded,
7474 Rn: Register.Encoded,7483 Rn: Register.Encoded,
7475 decoded10: u6 = 0b000000,7484 decoded10: u2 = 0b10,
7476 opcode: u3 = 0b011,7485 opcode: u5 = 0b01001,
7477 rmode: Rmode = .n,7486 decoded17: u5 = 0b10000,
7478 decoded21: u1 = 0b1,7487 size: Size,
7479 ftype: Ftype,
7480 decoded24: u5 = 0b11110,7488 decoded24: u5 = 0b11110,
7481 S: bool = false,7489 U: std.builtin.Signedness = .signed,
7482 decoded30: u1 = 0b0,7490 decoded30: u2 = 0b01,
7483 sf: Register.IntegerSize,
7484 };7491 };
74857492
7486 /// C7.2.71 FCVTAS (scalar)7493 /// C7.2.36 CMLT (zero)
7487 pub const Fcvtas = packed struct {7494 pub const Cmlt = packed struct {
7488 Rd: Register.Encoded,7495 Rd: Register.Encoded,
7489 Rn: Register.Encoded,7496 Rn: Register.Encoded,
7490 decoded10: u6 = 0b000000,7497 decoded10: u2 = 0b10,
7491 opcode: u3 = 0b100,7498 opcode: u5 = 0b01010,
7492 rmode: Rmode = .n,7499 decoded17: u5 = 0b10000,
7493 decoded21: u1 = 0b1,7500 size: Size,
7494 ftype: Ftype,
7495 decoded24: u5 = 0b11110,7501 decoded24: u5 = 0b11110,
7496 S: bool = false,7502 U: std.builtin.Signedness = .signed,
7497 decoded30: u1 = 0b0,7503 decoded30: u2 = 0b01,
7498 sf: Register.IntegerSize,
7499 };7504 };
75007505
7501 /// C7.2.73 FCVTAU (scalar)7506 /// C7.2.1 ABS
7502 pub const Fcvtau = packed struct {7507 pub const Abs = packed struct {
7503 Rd: Register.Encoded,7508 Rd: Register.Encoded,
7504 Rn: Register.Encoded,7509 Rn: Register.Encoded,
7505 decoded10: u6 = 0b000000,7510 decoded10: u2 = 0b10,
7506 opcode: u3 = 0b101,7511 opcode: u5 = 0b01011,
7507 rmode: Rmode = .n,7512 decoded17: u5 = 0b10000,
7508 decoded21: u1 = 0b1,7513 size: Size,
7509 ftype: Ftype,
7510 decoded24: u5 = 0b11110,7514 decoded24: u5 = 0b11110,
7511 S: bool = false,7515 U: std.builtin.Signedness = .signed,
7512 decoded30: u1 = 0b0,7516 decoded30: u2 = 0b01,
7513 sf: Register.IntegerSize,
7514 };7517 };
75157518
7516 /// C7.2.131 FMOV (general)7519 /// C7.2.308 SQXTN
7517 pub const Fmov = packed struct {7520 pub const Sqxtn = packed struct {
7518 Rd: Register.Encoded,7521 Rd: Register.Encoded,
7519 Rn: Register.Encoded,7522 Rn: Register.Encoded,
7520 decoded10: u6 = 0b000000,7523 decoded10: u2 = 0b10,
7521 opcode: Opcode,7524 opcode: u5 = 0b10100,
7522 rmode: Fmov.Rmode,7525 decoded17: u5 = 0b10000,
7523 decoded21: u1 = 0b1,7526 size: Size,
7524 ftype: Ftype,
7525 decoded24: u5 = 0b11110,7527 decoded24: u5 = 0b11110,
7526 S: bool = false,7528 U: std.builtin.Signedness = .signed,
7527 decoded30: u1 = 0b0,7529 decoded30: u2 = 0b01,
7528 sf: Register.IntegerSize,
7529
7530 pub const Opcode = enum(u3) {
7531 float_to_integer = 0b110,
7532 integer_to_float = 0b111,
7533 _,
7534 };
7535
7536 pub const Rmode = enum(u2) {
7537 @"0" = 0b00,
7538 @"1" = 0b01,
7539 _,
7540 };
7541 };7530 };
75427531
7543 /// C7.2.85 FCVTPS (scalar)7532 /// C7.2.80 FCVTNS (vector)
7544 pub const Fcvtps = packed struct {7533 pub const Fcvtns = packed struct {
7545 Rd: Register.Encoded,7534 Rd: Register.Encoded,
7546 Rn: Register.Encoded,7535 Rn: Register.Encoded,
7547 decoded10: u6 = 0b000000,7536 decoded10: u2 = 0b10,
7548 opcode: u3 = 0b000,7537 opcode: u5 = 0b11010,
7549 rmode: Rmode = .p,7538 decoded17: u5 = 0b10000,
7550 decoded21: u1 = 0b1,7539 sz: Sz,
7551 ftype: Ftype,7540 o2: u1 = 0b0,
7552 decoded24: u5 = 0b11110,7541 decoded24: u5 = 0b11110,
7553 S: bool = false,7542 U: std.builtin.Signedness = .signed,
7554 decoded30: u1 = 0b0,7543 decoded30: u2 = 0b01,
7555 sf: Register.IntegerSize,
7556 };7544 };
75577545
7558 /// C7.2.87 FCVTPU (scalar)7546 /// C7.2.75 FCVTMS (vector)
7559 pub const Fcvtpu = packed struct {7547 pub const Fcvtms = packed struct {
7560 Rd: Register.Encoded,7548 Rd: Register.Encoded,
7561 Rn: Register.Encoded,7549 Rn: Register.Encoded,
7562 decoded10: u6 = 0b000000,7550 decoded10: u2 = 0b10,
7563 opcode: u3 = 0b001,7551 opcode: u5 = 0b11011,
7564 rmode: Rmode = .p,7552 decoded17: u5 = 0b10000,
7565 decoded21: u1 = 0b1,7553 sz: Sz,
7566 ftype: Ftype,7554 o2: u1 = 0b0,
7567 decoded24: u5 = 0b11110,7555 decoded24: u5 = 0b11110,
7568 S: bool = false,7556 U: std.builtin.Signedness = .signed,
7569 decoded30: u1 = 0b0,7557 decoded30: u2 = 0b01,
7570 sf: Register.IntegerSize,
7571 };7558 };
75727559
7573 /// C7.2.76 FCVTMS (scalar)7560 /// C7.2.70 FCVTAS (vector)
7574 pub const Fcvtms = packed struct {7561 pub const Fcvtas = packed struct {
7575 Rd: Register.Encoded,7562 Rd: Register.Encoded,
7576 Rn: Register.Encoded,7563 Rn: Register.Encoded,
7577 decoded10: u6 = 0b000000,7564 decoded10: u2 = 0b10,
7578 opcode: u3 = 0b000,7565 opcode: u5 = 0b11100,
7579 rmode: Rmode = .m,7566 decoded17: u5 = 0b10000,
7580 decoded21: u1 = 0b1,7567 sz: Sz,
7581 ftype: Ftype,7568 o2: u1 = 0b0,
7582 decoded24: u5 = 0b11110,7569 decoded24: u5 = 0b11110,
7583 S: bool = false,7570 U: std.builtin.Signedness = .signed,
7584 decoded30: u1 = 0b0,7571 decoded30: u2 = 0b01,
7585 sf: Register.IntegerSize,
7586 };7572 };
75877573
7588 /// C7.2.78 FCVTMU (scalar)7574 /// C7.2.234 SCVTF (vector, integer)
7589 pub const Fcvtmu = packed struct {7575 pub const Scvtf = packed struct {
7590 Rd: Register.Encoded,7576 Rd: Register.Encoded,
7591 Rn: Register.Encoded,7577 Rn: Register.Encoded,
7592 decoded10: u6 = 0b000000,7578 decoded10: u2 = 0b10,
7593 opcode: u3 = 0b001,7579 opcode: u5 = 0b11101,
7594 rmode: Rmode = .m,7580 decoded17: u5 = 0b10000,
7595 decoded21: u1 = 0b1,7581 sz: Sz,
7596 ftype: Ftype,7582 o2: u1 = 0b0,
7597 decoded24: u5 = 0b11110,7583 decoded24: u5 = 0b11110,
7598 S: bool = false,7584 U: std.builtin.Signedness = .signed,
7599 decoded30: u1 = 0b0,7585 decoded30: u2 = 0b01,
7600 sf: Register.IntegerSize,
7601 };7586 };
76027587
7603 /// C7.2.92 FCVTZS (scalar, integer)7588 /// C7.2.61 FCMGT (zero)
7604 pub const Fcvtzs = packed struct {7589 pub const Fcmgt = packed struct {
7605 Rd: Register.Encoded,7590 Rd: Register.Encoded,
7606 Rn: Register.Encoded,7591 Rn: Register.Encoded,
7607 decoded10: u6 = 0b000000,7592 decoded10: u2 = 0b10,
7608 opcode: u3 = 0b000,7593 opcode: u5 = 0b01100,
7609 rmode: Rmode = .z,7594 decoded17: u5 = 0b10000,
7610 decoded21: u1 = 0b1,7595 sz: Sz,
7611 ftype: Ftype,7596 o2: u1 = 0b1,
7612 decoded24: u5 = 0b11110,7597 decoded24: u5 = 0b11110,
7613 S: bool = false,7598 U: std.builtin.Signedness = .signed,
7614 decoded30: u1 = 0b0,7599 decoded30: u2 = 0b01,
7615 sf: Register.IntegerSize,
7616 };7600 };
76177601
7618 /// C7.2.96 FCVTZU (scalar, integer)7602 /// C7.2.57 FCMEQ (zero)
7619 pub const Fcvtzu = packed struct {7603 pub const Fcmeq = packed struct {
7620 Rd: Register.Encoded,7604 Rd: Register.Encoded,
7621 Rn: Register.Encoded,7605 Rn: Register.Encoded,
7622 decoded10: u6 = 0b000000,7606 decoded10: u2 = 0b10,
7623 opcode: u3 = 0b001,7607 opcode: u5 = 0b01101,
7624 rmode: Rmode = .z,7608 decoded17: u5 = 0b10000,
7625 decoded21: u1 = 0b1,7609 sz: Sz,
7626 ftype: Ftype,7610 o2: u1 = 0b1,
7627 decoded24: u5 = 0b11110,7611 decoded24: u5 = 0b11110,
7628 S: bool = false,7612 U: std.builtin.Signedness = .signed,
7629 decoded30: u1 = 0b0,7613 decoded30: u2 = 0b01,
7630 sf: Register.IntegerSize,
7631 };7614 };
76327615
7633 /// C7.2.99 FJCVTZS7616 /// C7.2.65 FCMLT (zero)
7634 pub const Fjcvtzs = packed struct {7617 pub const Fcmlt = packed struct {
7635 Rd: Register.Encoded,7618 Rd: Register.Encoded,
7636 Rn: Register.Encoded,7619 Rn: Register.Encoded,
7637 decoded10: u6 = 0b000000,7620 decoded10: u2 = 0b10,
7638 opcode: u3 = 0b110,7621 opcode: u5 = 0b01110,
7639 rmode: Rmode = .z,7622 decoded17: u5 = 0b10000,
7640 decoded21: u1 = 0b1,7623 sz: Sz,
7641 ftype: Ftype = .double,7624 o2: u1 = 0b1,
7642 decoded24: u5 = 0b11110,7625 decoded24: u5 = 0b11110,
7643 S: bool = false,7626 U: std.builtin.Signedness = .signed,
7644 decoded30: u1 = 0b0,7627 decoded30: u2 = 0b01,
7645 sf: Register.IntegerSize = .word,
7646 };7628 };
76477629
7648 pub const Rmode = enum(u2) {7630 /// C7.2.84 FCVTPS (vector)
7649 /// to nearest7631 pub const Fcvtps = packed struct {
7650 n = 0b00,7632 Rd: Register.Encoded,
7651 /// toward plus infinity7633 Rn: Register.Encoded,
7652 p = 0b01,7634 decoded10: u2 = 0b10,
7653 /// toward minus infinity7635 opcode: u5 = 0b11010,
7654 m = 0b10,7636 decoded17: u5 = 0b10000,
7655 /// toward zero7637 sz: Sz,
7656 z = 0b11,7638 o2: u1 = 0b1,
7639 decoded24: u5 = 0b11110,
7640 U: std.builtin.Signedness = .signed,
7641 decoded30: u2 = 0b01,
7657 };7642 };
7658 };
7659
7660 /// Floating-point data-processing (1 source)
7661 pub const FloatDataProcessingOneSource = packed union {
7662 group: @This().Group,
7663 fmov: Fmov,
7664 fabs: Fabs,
7665 fneg: Fneg,
7666 fsqrt: Fsqrt,
7667 fcvt: Fcvt,
7668 frintn: Frintn,
7669 frintp: Frintp,
7670 frintm: Frintm,
7671 frintz: Frintz,
7672 frinta: Frinta,
7673 frintx: Frintx,
7674 frinti: Frinti,
76757643
7676 pub const Group = packed struct {7644 /// C7.2.90 FCVTZS (vector, integer)
7645 pub const Fcvtzs = packed struct {
7677 Rd: Register.Encoded,7646 Rd: Register.Encoded,
7678 Rn: Register.Encoded,7647 Rn: Register.Encoded,
7679 decoded10: u5 = 0b10000,7648 decoded10: u2 = 0b10,
7680 opcode: u6,7649 opcode: u5 = 0b11011,
7681 decoded21: u1 = 0b1,7650 decoded17: u5 = 0b10000,
7682 ptype: Ftype,7651 sz: Sz,
7652 o2: u1 = 0b1,
7683 decoded24: u5 = 0b11110,7653 decoded24: u5 = 0b11110,
7684 S: bool,7654 U: std.builtin.Signedness = .signed,
7685 decoded30: u1 = 0b0,7655 decoded30: u2 = 0b01,
7686 M: u1,
7687 };7656 };
76887657
7689 /// C7.2.130 FMOV (register)7658 /// C7.2.144 FRECPE
7690 pub const Fmov = packed struct {7659 pub const Frecpe = packed struct {
7691 Rd: Register.Encoded,7660 Rd: Register.Encoded,
7692 Rn: Register.Encoded,7661 Rn: Register.Encoded,
7693 decoded10: u5 = 0b10000,7662 decoded10: u2 = 0b10,
7694 opc: u2 = 0b00,7663 opcode: u5 = 0b11101,
7695 decoded17: u4 = 0b0000,7664 decoded17: u5 = 0b10000,
7696 decoded21: u1 = 0b1,7665 sz: Sz,
7697 ftype: Ftype,7666 o2: u1 = 0b1,
7698 decoded24: u5 = 0b11110,7667 decoded24: u5 = 0b11110,
7699 S: bool = false,7668 U: std.builtin.Signedness = .signed,
7700 decoded30: u1 = 0b0,7669 decoded30: u2 = 0b01,
7701 M: u1 = 0b0,
7702 };7670 };
77037671
7704 /// C7.2.46 FABS (scalar)7672 /// C7.2.146 FRECPX
7705 pub const Fabs = packed struct {7673 pub const Frecpx = packed struct {
7706 Rd: Register.Encoded,7674 Rd: Register.Encoded,
7707 Rn: Register.Encoded,7675 Rn: Register.Encoded,
7708 decoded10: u5 = 0b10000,7676 decoded10: u2 = 0b10,
7709 opc: u2 = 0b01,7677 opcode: u5 = 0b11111,
7710 decoded17: u4 = 0b0000,7678 decoded17: u5 = 0b10000,
7711 decoded21: u1 = 0b1,7679 sz: Sz,
7712 ftype: Ftype,7680 o2: u1 = 0b1,
7713 decoded24: u5 = 0b11110,7681 decoded24: u5 = 0b11110,
7714 S: bool = false,7682 U: std.builtin.Signedness = .signed,
7715 decoded30: u1 = 0b0,7683 decoded30: u2 = 0b01,
7716 M: u1 = 0b0,
7717 };7684 };
77187685
7719 /// C7.2.140 FNEG (scalar)7686 /// C7.2.394 USQADD
7720 pub const Fneg = packed struct {7687 pub const Usqadd = packed struct {
7721 Rd: Register.Encoded,7688 Rd: Register.Encoded,
7722 Rn: Register.Encoded,7689 Rn: Register.Encoded,
7723 decoded10: u5 = 0b10000,7690 decoded10: u2 = 0b10,
7724 opc: u2 = 0b10,7691 opcode: u5 = 0b00011,
7725 decoded17: u4 = 0b0000,7692 decoded17: u5 = 0b10000,
7726 decoded21: u1 = 0b1,7693 size: Size,
7727 ftype: Ftype,
7728 decoded24: u5 = 0b11110,7694 decoded24: u5 = 0b11110,
7729 S: bool = false,7695 U: std.builtin.Signedness = .unsigned,
7730 decoded30: u1 = 0b0,7696 decoded30: u2 = 0b01,
7731 M: u1 = 0b0,
7732 };7697 };
77337698
7734 /// C7.2.172 FSQRT (scalar)7699 /// C7.2.292 SQNEG
7735 pub const Fsqrt = packed struct {7700 pub const Sqneg = packed struct {
7736 Rd: Register.Encoded,7701 Rd: Register.Encoded,
7737 Rn: Register.Encoded,7702 Rn: Register.Encoded,
7738 decoded10: u5 = 0b10000,7703 decoded10: u2 = 0b10,
7739 opc: u2 = 0b11,7704 opcode: u5 = 0b00111,
7740 decoded17: u4 = 0b0000,7705 decoded17: u5 = 0b10000,
7741 decoded21: u1 = 0b1,7706 size: Size,
7742 ftype: Ftype,
7743 decoded24: u5 = 0b11110,7707 decoded24: u5 = 0b11110,
7744 S: bool = false,7708 U: std.builtin.Signedness = .unsigned,
7745 decoded30: u1 = 0b0,7709 decoded30: u2 = 0b01,
7746 M: u1 = 0b0,
7747 };7710 };
77487711
7749 /// C7.2.69 FCVT7712 /// C7.2.30 CMGE (zero)
7750 pub const Fcvt = packed struct {7713 pub const Cmge = packed struct {
7751 Rd: Register.Encoded,7714 Rd: Register.Encoded,
7752 Rn: Register.Encoded,7715 Rn: Register.Encoded,
7753 decoded10: u5 = 0b10000,7716 decoded10: u2 = 0b10,
7754 opc: Ftype,7717 opcode: u5 = 0b01000,
7755 decoded17: u4 = 0b0001,7718 decoded17: u5 = 0b10000,
7756 decoded21: u1 = 0b1,7719 size: Size,
7757 ftype: Ftype,
7758 decoded24: u5 = 0b11110,7720 decoded24: u5 = 0b11110,
7759 S: bool = false,7721 U: std.builtin.Signedness = .unsigned,
7760 decoded30: u1 = 0b0,7722 decoded30: u2 = 0b01,
7761 M: u1 = 0b0,
7762 };7723 };
77637724
7764 /// C7.2.162 FRINTN (scalar)7725 /// C7.2.35 CMLE (zero)
7765 pub const Frintn = packed struct {7726 pub const Cmle = packed struct {
7766 Rd: Register.Encoded,7727 Rd: Register.Encoded,
7767 Rn: Register.Encoded,7728 Rn: Register.Encoded,
7768 decoded10: u5 = 0b10000,7729 decoded10: u2 = 0b10,
7769 rmode: Rmode = .n,7730 opcode: u5 = 0b01001,
7770 decoded18: u3 = 0b001,7731 decoded17: u5 = 0b10000,
7771 decoded21: u1 = 0b1,7732 size: Size,
7772 ftype: Ftype,
7773 decoded24: u5 = 0b11110,7733 decoded24: u5 = 0b11110,
7774 S: bool = false,7734 U: std.builtin.Signedness = .unsigned,
7775 decoded30: u1 = 0b0,7735 decoded30: u2 = 0b01,
7776 M: u1 = 0b0,
7777 };7736 };
77787737
7779 /// C7.2.164 FRINTP (scalar)7738 /// C7.2.209 NEG (vector)
7780 pub const Frintp = packed struct {7739 pub const Neg = packed struct {
7781 Rd: Register.Encoded,7740 Rd: Register.Encoded,
7782 Rn: Register.Encoded,7741 Rn: Register.Encoded,
7783 decoded10: u5 = 0b10000,7742 decoded10: u2 = 0b10,
7784 rmode: Rmode = .p,7743 opcode: u5 = 0b01011,
7785 decoded18: u3 = 0b001,7744 decoded17: u5 = 0b10000,
7786 decoded21: u1 = 0b1,7745 size: Size,
7787 ftype: Ftype,
7788 decoded24: u5 = 0b11110,7746 decoded24: u5 = 0b11110,
7789 S: bool = false,7747 U: std.builtin.Signedness = .unsigned,
7790 decoded30: u1 = 0b0,7748 decoded30: u2 = 0b01,
7791 M: u1 = 0b0,
7792 };7749 };
77937750
7794 /// C7.2.160 FRINTM (scalar)7751 /// C7.2.309 SQXTUN
7795 pub const Frintm = packed struct {7752 pub const Sqxtun = packed struct {
7796 Rd: Register.Encoded,7753 Rd: Register.Encoded,
7797 Rn: Register.Encoded,7754 Rn: Register.Encoded,
7798 decoded10: u5 = 0b10000,7755 decoded10: u2 = 0b10,
7799 rmode: Rmode = .m,7756 opcode: u5 = 0b10010,
7800 decoded18: u3 = 0b001,7757 decoded17: u5 = 0b10000,
7801 decoded21: u1 = 0b1,7758 size: Size,
7802 ftype: Ftype,
7803 decoded24: u5 = 0b11110,7759 decoded24: u5 = 0b11110,
7804 S: bool = false,7760 U: std.builtin.Signedness = .unsigned,
7805 decoded30: u1 = 0b0,7761 decoded30: u2 = 0b01,
7806 M: u1 = 0b0,
7807 };7762 };
78087763
7809 /// C7.2.168 FRINTZ (scalar)7764 /// C7.2.381 UQXTN
7810 pub const Frintz = packed struct {7765 pub const Uqxtn = packed struct {
7811 Rd: Register.Encoded,7766 Rd: Register.Encoded,
7812 Rn: Register.Encoded,7767 Rn: Register.Encoded,
7813 decoded10: u5 = 0b10000,7768 decoded10: u2 = 0b10,
7814 rmode: Rmode = .z,7769 opcode: u5 = 0b10100,
7815 decoded18: u3 = 0b001,7770 decoded17: u5 = 0b10000,
7816 decoded21: u1 = 0b1,7771 size: Size,
7817 ftype: Ftype,
7818 decoded24: u5 = 0b11110,7772 decoded24: u5 = 0b11110,
7819 S: bool = false,7773 U: std.builtin.Signedness = .unsigned,
7820 decoded30: u1 = 0b0,7774 decoded30: u2 = 0b01,
7821 M: u1 = 0b0,
7822 };7775 };
78237776
7824 /// C7.2.156 FRINTA (scalar)7777 /// C7.2.88 FCVTXN
7825 pub const Frinta = packed struct {7778 pub const Fcvtxn = packed struct {
7826 Rd: Register.Encoded,7779 Rd: Register.Encoded,
7827 Rn: Register.Encoded,7780 Rn: Register.Encoded,
7828 decoded10: u5 = 0b10000,7781 decoded10: u2 = 0b10,
7829 rmode: Rmode = .a,7782 opcode: u5 = 0b10110,
7830 decoded18: u3 = 0b001,7783 decoded17: u5 = 0b10000,
7831 decoded21: u1 = 0b1,7784 sz: Sz,
7832 ftype: Ftype,7785 o2: u1 = 0b0,
7833 decoded24: u5 = 0b11110,7786 decoded24: u5 = 0b11110,
7834 S: bool = false,7787 U: std.builtin.Signedness = .unsigned,
7835 decoded30: u1 = 0b0,7788 decoded30: u2 = 0b01,
7836 M: u1 = 0b0,
7837 };7789 };
78387790
7839 /// C7.2.166 FRINTX (scalar)7791 /// C7.2.82 FCVTNU (vector)
7840 pub const Frintx = packed struct {7792 pub const Fcvtnu = packed struct {
7841 Rd: Register.Encoded,7793 Rd: Register.Encoded,
7842 Rn: Register.Encoded,7794 Rn: Register.Encoded,
7843 decoded10: u5 = 0b10000,7795 decoded10: u2 = 0b10,
7844 rmode: Rmode = .x,7796 opcode: u5 = 0b11010,
7845 decoded18: u3 = 0b001,7797 decoded17: u5 = 0b10000,
7846 decoded21: u1 = 0b1,7798 sz: Sz,
7847 ftype: Ftype,7799 o2: u1 = 0b0,
7848 decoded24: u5 = 0b11110,7800 decoded24: u5 = 0b11110,
7849 S: bool = false,7801 U: std.builtin.Signedness = .unsigned,
7850 decoded30: u1 = 0b0,7802 decoded30: u2 = 0b01,
7851 M: u1 = 0b0,
7852 };7803 };
78537804
7854 /// C7.2.158 FRINTI (scalar)7805 /// C7.2.77 FCVTMU (vector)
7855 pub const Frinti = packed struct {7806 pub const Fcvtmu = packed struct {
7856 Rd: Register.Encoded,7807 Rd: Register.Encoded,
7857 Rn: Register.Encoded,7808 Rn: Register.Encoded,
7858 decoded10: u5 = 0b10000,7809 decoded10: u2 = 0b10,
7859 rmode: Rmode = .i,7810 opcode: u5 = 0b11011,
7860 decoded18: u3 = 0b001,7811 decoded17: u5 = 0b10000,
7861 decoded21: u1 = 0b1,7812 sz: Sz,
7862 ftype: Ftype,7813 o2: u1 = 0b0,
7863 decoded24: u5 = 0b11110,7814 decoded24: u5 = 0b11110,
7864 S: bool = false,7815 U: std.builtin.Signedness = .unsigned,
7865 decoded30: u1 = 0b0,7816 decoded30: u2 = 0b01,
7866 M: u1 = 0b0,
7867 };7817 };
78687818
7869 pub const Rmode = enum(u3) {7819 /// C7.2.72 FCVTAU (vector)
7870 /// to nearest with ties to even7820 pub const Fcvtau = packed struct {
7871 n = 0b000,7821 Rd: Register.Encoded,
7872 /// toward plus infinity7822 Rn: Register.Encoded,
7873 p = 0b001,7823 decoded10: u2 = 0b10,
7874 /// toward minus infinity7824 opcode: u5 = 0b11100,
7875 m = 0b010,7825 decoded17: u5 = 0b10000,
7876 /// toward zero7826 sz: Sz,
7877 z = 0b011,7827 o2: u1 = 0b0,
7878 /// to nearest with ties to away7828 decoded24: u5 = 0b11110,
7879 a = 0b100,7829 U: std.builtin.Signedness = .unsigned,
7880 /// exact, using current rounding mode7830 decoded30: u2 = 0b01,
7881 x = 0b110,
7882 /// using current rounding mode
7883 i = 0b111,
7884 _,
7885 };7831 };
7886 };
7887
7888 /// Floating-point compare
7889 pub const FloatCompare = packed union {
7890 group: @This().Group,
7891 fcmp: Fcmp,
7892 fcmpe: Fcmpe,
78937832
7894 pub const Group = packed struct {7833 /// C7.2.353 UCVTF (vector, integer)
7895 opcode2: u5,7834 pub const Ucvtf = packed struct {
7835 Rd: Register.Encoded,
7896 Rn: Register.Encoded,7836 Rn: Register.Encoded,
7897 decoded10: u4 = 0b1000,7837 decoded10: u2 = 0b10,
7898 op: u2,7838 opcode: u5 = 0b11101,
7899 Rm: Register.Encoded,7839 decoded17: u5 = 0b10000,
7900 decoded21: u1 = 0b1,7840 sz: Sz,
7901 ptype: Ftype,7841 o2: u1 = 0b0,
7902 decoded24: u5 = 0b11110,7842 decoded24: u5 = 0b11110,
7903 S: bool,7843 U: std.builtin.Signedness = .unsigned,
7904 decoded30: u1 = 0b0,7844 decoded30: u2 = 0b01,
7905 M: u1,
7906 };7845 };
79077846
7908 /// C7.2.66 FCMP7847 /// C7.2.59 FCMGE (zero)
7909 pub const Fcmp = packed struct {7848 pub const Fcmge = packed struct {
7910 decoded0: u3 = 0b000,7849 Rd: Register.Encoded,
7911 opc0: Opc0,
7912 opc1: u1 = 0b0,
7913 Rn: Register.Encoded,7850 Rn: Register.Encoded,
7914 decoded10: u4 = 0b1000,7851 decoded10: u2 = 0b10,
7915 op: u2 = 0b00,7852 opcode: u5 = 0b01100,
7916 Rm: Register.Encoded,7853 decoded17: u5 = 0b10000,
7917 decoded21: u1 = 0b1,7854 sz: Sz,
7918 ftype: Ftype,7855 o2: u1 = 0b1,
7919 decoded24: u5 = 0b11110,7856 decoded24: u5 = 0b11110,
7920 S: bool = false,7857 U: std.builtin.Signedness = .unsigned,
7921 decoded30: u1 = 0b0,7858 decoded30: u2 = 0b01,
7922 M: u1 = 0b0,
7923 };7859 };
79247860
7925 /// C7.2.67 FCMPE7861 /// C7.2.64 FCMLE (zero)
7926 pub const Fcmpe = packed struct {7862 pub const Fcmle = packed struct {
7927 decoded0: u3 = 0b000,7863 Rd: Register.Encoded,
7928 opc0: Opc0,
7929 opc1: u1 = 0b1,
7930 Rn: Register.Encoded,7864 Rn: Register.Encoded,
7931 decoded10: u4 = 0b1000,7865 decoded10: u2 = 0b10,
7932 op: u2 = 0b00,7866 opcode: u5 = 0b01101,
7933 Rm: Register.Encoded,7867 decoded17: u5 = 0b10000,
7934 decoded21: u1 = 0b1,7868 sz: Sz,
7935 ftype: Ftype,7869 o2: u1 = 0b1,
7936 decoded24: u5 = 0b11110,7870 decoded24: u5 = 0b11110,
7937 S: bool = false,7871 U: std.builtin.Signedness = .unsigned,
7938 decoded30: u1 = 0b0,7872 decoded30: u2 = 0b01,
7939 M: u1 = 0b0,
7940 };7873 };
79417874
7942 pub const Opc0 = enum(u1) {7875 /// C7.2.86 FCVTPU (vector)
7943 register = 0b00,7876 pub const Fcvtpu = packed struct {
7944 zero = 0b01,7877 Rd: Register.Encoded,
7878 Rn: Register.Encoded,
7879 decoded10: u2 = 0b10,
7880 opcode: u5 = 0b11010,
7881 decoded17: u5 = 0b10000,
7882 sz: Sz,
7883 o2: u1 = 0b1,
7884 decoded24: u5 = 0b11110,
7885 U: std.builtin.Signedness = .unsigned,
7886 decoded30: u2 = 0b01,
7945 };7887 };
7946 };
7947
7948 /// Floating-point immediate
7949 pub const FloatImmediate = packed union {
7950 group: @This().Group,
7951 fmov: Fmov,
79527888
7953 pub const Group = packed struct {7889 /// C7.2.94 FCVTZU (vector, integer)
7890 pub const Fcvtzu = packed struct {
7954 Rd: Register.Encoded,7891 Rd: Register.Encoded,
7955 imm5: u5,7892 Rn: Register.Encoded,
7956 decoded10: u3 = 0b100,7893 decoded10: u2 = 0b10,
7957 imm8: u8,7894 opcode: u5 = 0b11011,
7958 decoded21: u1 = 0b1,7895 decoded17: u5 = 0b10000,
7959 ptype: Ftype,7896 sz: Sz,
7897 o2: u1 = 0b1,
7960 decoded24: u5 = 0b11110,7898 decoded24: u5 = 0b11110,
7961 S: bool,7899 U: std.builtin.Signedness = .unsigned,
7962 decoded30: u1 = 0b0,7900 decoded30: u2 = 0b01,
7963 M: u1,
7964 };7901 };
79657902
7966 /// C7.2.132 FMOV (scalar, immediate)7903 /// C7.2.169 FRSQRTE
7967 pub const Fmov = packed struct {7904 pub const Frsqrte = packed struct {
7968 Rd: Register.Encoded,7905 Rd: Register.Encoded,
7969 imm5: u5 = 0b00000,7906 Rn: Register.Encoded,
7970 decoded10: u3 = 0b100,7907 decoded10: u2 = 0b10,
7971 imm8: u8,7908 opcode: u5 = 0b11101,
7972 decoded21: u1 = 0b1,7909 decoded17: u5 = 0b10000,
7973 ftype: Ftype,7910 sz: Sz,
7911 o2: u1 = 0b1,
7974 decoded24: u5 = 0b11110,7912 decoded24: u5 = 0b11110,
7975 S: bool = false,7913 U: std.builtin.Signedness = .unsigned,
7976 decoded30: u1 = 0b0,7914 decoded30: u2 = 0b01,
7977 M: u1 = 0b0,
7978 };7915 };
7979 };7916 };
79807917
7981 /// Floating-point data-processing (2 source)7918 /// Advanced SIMD scalar pairwise
7982 pub const FloatDataProcessingTwoSource = packed union {7919 pub const SimdScalarPairwise = packed union {
7983 group: @This().Group,7920 group: @This().Group,
7984 fmul: Fmul,7921 addp: Addp,
7985 fdiv: Fdiv,
7986 fadd: Fadd,
7987 fsub: Fsub,
7988 fmax: Fmax,
7989 fmin: Fmin,
7990 fmaxnm: Fmaxnm,
7991 fminnm: Fminnm,
7992 fnmul: Fnmul,
79937922
7994 pub const Group = packed struct {7923 pub const Group = packed struct {
7995 Rd: Register.Encoded,7924 Rd: Register.Encoded,
7996 Rn: Register.Encoded,7925 Rn: Register.Encoded,
7997 decoded10: u2 = 0b10,7926 decoded10: u2 = 0b10,
7998 opcode: Opcode,7927 opcode: u5,
7999 Rm: Register.Encoded,7928 decoded17: u5 = 0b11000,
8000 decoded21: u1 = 0b1,7929 size: Size,
8001 ptype: Ftype,
8002 decoded24: u5 = 0b11110,7930 decoded24: u5 = 0b11110,
8003 S: bool,7931 U: std.builtin.Signedness,
8004 decoded30: u1 = 0b0,7932 decoded30: u2 = 0b01,
8005 M: u1,
8006 };7933 };
80077934
8008 /// C7.2.136 FMUL (scalar)7935 /// C7.2.4 ADDP (scalar)
8009 pub const Fmul = packed struct {7936 pub const Addp = packed struct {
8010 Rd: Register.Encoded,7937 Rd: Register.Encoded,
8011 Rn: Register.Encoded,7938 Rn: Register.Encoded,
8012 decoded10: u2 = 0b10,7939 decoded10: u2 = 0b10,
8013 opcode: Opcode = .fmul,7940 opcode: u5 = 0b11011,
8014 Rm: Register.Encoded,7941 decoded17: u5 = 0b11000,
8015 decoded21: u1 = 0b1,7942 size: Size,
8016 ftype: Ftype,
8017 decoded24: u5 = 0b11110,7943 decoded24: u5 = 0b11110,
8018 S: bool = false,7944 U: std.builtin.Signedness = .signed,
8019 decoded30: u1 = 0b0,7945 decoded30: u2 = 0b01,
8020 M: u1 = 0b0,
8021 };7946 };
7947 };
80227948
8023 /// C7.2.98 FDIV (scalar)7949 /// Advanced SIMD copy
8024 pub const Fdiv = packed struct {7950 pub const SimdCopy = packed union {
7951 group: @This().Group,
7952 dup: Dup,
7953 smov: Smov,
7954 umov: Umov,
7955 ins: Ins,
7956
7957 pub const Group = packed struct {
8025 Rd: Register.Encoded,7958 Rd: Register.Encoded,
8026 Rn: Register.Encoded,7959 Rn: Register.Encoded,
8027 decoded10: u2 = 0b10,7960 decoded10: u1 = 0b1,
8028 opcode: Opcode = .fdiv,7961 imm4: u4,
8029 Rm: Register.Encoded,7962 decoded15: u1 = 0b0,
8030 decoded21: u1 = 0b1,7963 imm5: u5,
8031 ftype: Ftype,7964 decoded21: u8 = 0b01110000,
8032 decoded24: u5 = 0b11110,7965 op: u1,
8033 S: bool = false,7966 Q: u1,
8034 decoded30: u1 = 0b0,7967 decoded31: u1 = 0b0,
8035 M: u1 = 0b0,
8036 };7968 };
80377969
8038 /// C7.2.50 FADD (scalar)7970 /// C7.2.39 DUP (element)
8039 pub const Fadd = packed struct {7971 /// C7.2.40 DUP (general)
7972 pub const Dup = packed struct {
8040 Rd: Register.Encoded,7973 Rd: Register.Encoded,
8041 Rn: Register.Encoded,7974 Rn: Register.Encoded,
8042 decoded10: u2 = 0b10,7975 decoded10: u1 = 0b1,
8043 opcode: Opcode = .fadd,7976 imm4: Imm4,
8044 Rm: Register.Encoded,7977 decoded15: u1 = 0b0,
8045 decoded21: u1 = 0b1,7978 imm5: u5,
8046 ftype: Ftype,7979 decoded21: u8 = 0b01110000,
8047 decoded24: u5 = 0b11110,7980 op: u1 = 0b0,
8048 S: bool = false,7981 Q: Q,
8049 decoded30: u1 = 0b0,7982 decoded31: u1 = 0b0,
8050 M: u1 = 0b0,7983
7984 pub const Imm4 = enum(u4) {
7985 element = 0b0000,
7986 general = 0b0001,
7987 _,
7988 };
8051 };7989 };
80527990
8053 /// C7.2.174 FSUB (scalar)7991 /// C7.2.279 SMOV
8054 pub const Fsub = packed struct {7992 pub const Smov = packed struct {
8055 Rd: Register.Encoded,7993 Rd: Register.Encoded,
8056 Rn: Register.Encoded,7994 Rn: Register.Encoded,
8057 decoded10: u2 = 0b10,7995 decoded10: u1 = 0b1,
8058 opcode: Opcode = .fsub,7996 imm4: u4 = 0b0101,
8059 Rm: Register.Encoded,7997 decoded15: u1 = 0b0,
8060 decoded21: u1 = 0b1,7998 imm5: u5,
8061 ftype: Ftype,7999 decoded21: u8 = 0b01110000,
8062 decoded24: u5 = 0b11110,8000 op: u1 = 0b0,
8063 S: bool = false,8001 Q: Register.IntegerSize,
8064 decoded30: u1 = 0b0,8002 decoded31: u1 = 0b0,
8065 M: u1 = 0b0,
8066 };8003 };
80678004
8068 /// C7.2.102 FMAX (scalar)8005 /// C7.2.371 UMOV
8069 pub const Fmax = packed struct {8006 pub const Umov = packed struct {
8070 Rd: Register.Encoded,8007 Rd: Register.Encoded,
8071 Rn: Register.Encoded,8008 Rn: Register.Encoded,
8072 decoded10: u2 = 0b10,8009 decoded10: u1 = 0b1,
8073 opcode: Opcode = .fmax,8010 imm4: u4 = 0b0111,
8074 Rm: Register.Encoded,8011 decoded15: u1 = 0b0,
8075 decoded21: u1 = 0b1,8012 imm5: u5,
8076 ftype: Ftype,8013 decoded21: u8 = 0b01110000,
8077 decoded24: u5 = 0b11110,8014 op: u1 = 0b0,
8078 S: bool = false,8015 Q: Register.IntegerSize,
8079 decoded30: u1 = 0b0,8016 decoded31: u1 = 0b0,
8080 M: u1 = 0b0,
8081 };8017 };
80828018
8083 /// C7.2.112 FMIN (scalar)8019 /// C7.2.175 INS (element)
8084 pub const Fmin = packed struct {8020 /// C7.2.176 INS (general)
8021 pub const Ins = packed struct {
8085 Rd: Register.Encoded,8022 Rd: Register.Encoded,
8086 Rn: Register.Encoded,8023 Rn: Register.Encoded,
8087 decoded10: u2 = 0b10,8024 decoded10: u1 = 0b1,
8088 opcode: Opcode = .fmin,8025 imm4: Imm4,
8089 Rm: Register.Encoded,8026 decoded15: u1 = 0b0,
8090 decoded21: u1 = 0b1,8027 imm5: u5,
8091 ftype: Ftype,8028 decoded21: u8 = 0b01110000,
8092 decoded24: u5 = 0b11110,8029 op: Op,
8093 S: bool = false,8030 Q: u1 = 0b1,
8094 decoded30: u1 = 0b0,8031 decoded31: u1 = 0b0,
8095 M: u1 = 0b0,8032
8033 pub const Imm4 = packed union {
8034 general: General,
8035 element: u4,
8036
8037 pub const General = enum(u4) {
8038 general = 0b0011,
8039 _,
8040 };
8041 };
8042
8043 pub const Op = enum(u1) {
8044 general = 0b0,
8045 element = 0b1,
8046 };
8096 };8047 };
80978048
8098 /// C7.2.104 FMAXNM (scalar)8049 pub const Decoded = union(enum) {
8099 pub const Fmaxnm = packed struct {8050 unallocated,
8051 dup: Dup,
8052 smov: Smov,
8053 umov: Umov,
8054 ins: Ins,
8055 };
8056 pub fn decode(inst: @This()) @This().Decoded {
8057 return switch (inst.group.op) {
8058 0b0 => switch (inst.group.imm4) {
8059 0b0000, 0b0001 => .{ .dup = inst.dup },
8060 else => .unallocated,
8061 0b0101 => switch (@ctz(inst.group.imm5)) {
8062 0, 1 => .{ .smov = inst.smov },
8063 2 => switch (inst.group.Q) {
8064 0b1 => .{ .smov = inst.smov },
8065 0b0 => .unallocated,
8066 },
8067 else => .unallocated,
8068 },
8069 0b0111 => switch (@ctz(inst.group.imm5)) {
8070 0, 1, 2 => switch (inst.group.Q) {
8071 0b0 => .{ .umov = inst.umov },
8072 0b1 => .unallocated,
8073 },
8074 3 => switch (inst.group.Q) {
8075 0b1 => .{ .umov = inst.umov },
8076 0b0 => .unallocated,
8077 },
8078 else => .unallocated,
8079 },
8080 },
8081 0b1 => switch (inst.group.Q) {
8082 0b0 => .unallocated,
8083 0b1 => .{ .ins = inst.ins },
8084 },
8085 };
8086 }
8087 };
8088
8089 /// Advanced SIMD two-register miscellaneous (FP16)
8090 pub const SimdTwoRegisterMiscellaneousFp16 = packed union {
8091 group: @This().Group,
8092 frintn: Frintn,
8093 frintm: Frintm,
8094 fcvtns: Fcvtns,
8095 fcvtms: Fcvtms,
8096 fcvtas: Fcvtas,
8097 scvtf: Scvtf,
8098 fcmgt: Fcmgt,
8099 fcmeq: Fcmeq,
8100 fcmlt: Fcmlt,
8101 fabs: Fabs,
8102 frintp: Frintp,
8103 frintz: Frintz,
8104 fcvtps: Fcvtps,
8105 fcvtzs: Fcvtzs,
8106 frecpe: Frecpe,
8107 frinta: Frinta,
8108 frintx: Frintx,
8109 fcvtnu: Fcvtnu,
8110 fcvtmu: Fcvtmu,
8111 fcvtau: Fcvtau,
8112 ucvtf: Ucvtf,
8113 fcmge: Fcmge,
8114 fcmle: Fcmle,
8115 fneg: Fneg,
8116 frinti: Frinti,
8117 fcvtpu: Fcvtpu,
8118 fcvtzu: Fcvtzu,
8119 frsqrte: Frsqrte,
8120 fsqrt: Fsqrt,
8121
8122 pub const Group = packed struct {
8100 Rd: Register.Encoded,8123 Rd: Register.Encoded,
8101 Rn: Register.Encoded,8124 Rn: Register.Encoded,
8102 decoded10: u2 = 0b10,8125 decoded10: u2 = 0b10,
8103 opcode: Opcode = .fmaxnm,8126 opcode: u5,
8104 Rm: Register.Encoded,8127 decoded17: u6 = 0b111100,
8105 decoded21: u1 = 0b1,8128 a: u1,
8106 ftype: Ftype,8129 decoded24: u5 = 0b01110,
8107 decoded24: u5 = 0b11110,8130 U: std.builtin.Signedness,
8108 S: bool = false,8131 Q: Q,
8109 decoded30: u1 = 0b0,8132 decoded31: u1 = 0b0,
8110 M: u1 = 0b0,
8111 };8133 };
81128134
8113 /// C7.2.114 FMINNM (scalar)8135 /// C7.2.161 FRINTN (vector)
8114 pub const Fminnm = packed struct {8136 pub const Frintn = packed struct {
8115 Rd: Register.Encoded,8137 Rd: Register.Encoded,
8116 Rn: Register.Encoded,8138 Rn: Register.Encoded,
8117 decoded10: u2 = 0b10,8139 decoded10: u2 = 0b10,
8118 opcode: Opcode = .fminnm,8140 opcode: u5 = 0b11000,
8119 Rm: Register.Encoded,8141 decoded17: u6 = 0b111100,
8120 decoded21: u1 = 0b1,8142 o2: u1 = 0b0,
8121 ftype: Ftype,8143 decoded24: u5 = 0b01110,
8122 decoded24: u5 = 0b11110,8144 U: std.builtin.Signedness = .signed,
8123 S: bool = false,8145 Q: Q,
8124 decoded30: u1 = 0b0,8146 decoded31: u1 = 0b0,
8125 M: u1 = 0b0,
8126 };8147 };
81278148
8128 /// C7.2.143 FNMUL (scalar)8149 /// C7.2.159 FRINTM (vector)
8129 pub const Fnmul = packed struct {8150 pub const Frintm = packed struct {
8130 Rd: Register.Encoded,8151 Rd: Register.Encoded,
8131 Rn: Register.Encoded,8152 Rn: Register.Encoded,
8132 decoded10: u2 = 0b10,8153 decoded10: u2 = 0b10,
8133 opcode: Opcode = .fnmul,8154 opcode: u5 = 0b11001,
8134 Rm: Register.Encoded,8155 decoded17: u6 = 0b111100,
8135 decoded21: u1 = 0b1,8156 o2: u1 = 0b0,
8136 ftype: Ftype,8157 decoded24: u5 = 0b01110,
8137 decoded24: u5 = 0b11110,8158 U: std.builtin.Signedness = .signed,
8138 S: bool = false,8159 Q: Q,
8139 decoded30: u1 = 0b0,8160 decoded31: u1 = 0b0,
8140 M: u1 = 0b0,
8141 };
8142
8143 pub const Opcode = enum(u4) {
8144 fmul = 0b0000,
8145 fdiv = 0b0001,
8146 fadd = 0b0010,
8147 fsub = 0b0011,
8148 fmax = 0b0100,
8149 fmin = 0b0101,
8150 fmaxnm = 0b0110,
8151 fminnm = 0b0111,
8152 fnmul = 0b1000,
8153 _,
8154 };8161 };
8155 };
8156
8157 /// Floating-point data-processing (3 source)
8158 pub const FloatDataProcessingThreeSource = packed union {
8159 group: @This().Group,
8160 fmadd: Fmadd,
8161 fmsub: Fmsub,
8162 fnmadd: Fnmadd,
8163 fnmsub: Fnmsub,
81648162
8165 pub const Group = packed struct {8163 /// C7.2.80 FCVTNS (vector)
8164 pub const Fcvtns = packed struct {
8166 Rd: Register.Encoded,8165 Rd: Register.Encoded,
8167 Rn: Register.Encoded,8166 Rn: Register.Encoded,
8168 Ra: Register.Encoded,8167 decoded10: u2 = 0b10,
8169 o0: AddSubtractOp,8168 opcode: u5 = 0b11010,
8170 Rm: Register.Encoded,8169 decoded17: u6 = 0b111100,
8171 o1: u1,8170 o2: u1 = 0b0,
8172 ptype: Ftype,8171 decoded24: u5 = 0b01110,
8173 decoded24: u5 = 0b11111,8172 U: std.builtin.Signedness = .signed,
8174 S: bool,8173 Q: Q,
8175 decoded30: u1 = 0b0,8174 decoded31: u1 = 0b0,
8176 M: u1,
8177 };8175 };
81788176
8179 /// C7.2.100 FMADD8177 /// C7.2.75 FCVTMS (vector)
8180 pub const Fmadd = packed struct {8178 pub const Fcvtms = packed struct {
8181 Rd: Register.Encoded,8179 Rd: Register.Encoded,
8182 Rn: Register.Encoded,8180 Rn: Register.Encoded,
8183 Ra: Register.Encoded,8181 decoded10: u2 = 0b10,
8184 o0: AddSubtractOp = .add,8182 opcode: u5 = 0b11011,
8185 Rm: Register.Encoded,8183 decoded17: u6 = 0b111100,
8186 o1: O1 = .fm,8184 o2: u1 = 0b0,
8187 ftype: Ftype,8185 decoded24: u5 = 0b01110,
8188 decoded24: u5 = 0b11111,8186 U: std.builtin.Signedness = .signed,
8189 S: bool = false,8187 Q: Q,
8190 decoded30: u1 = 0b0,8188 decoded31: u1 = 0b0,
8191 M: u1 = 0b0,
8192 };8189 };
81938190
8194 /// C7.2.133 FMSUB8191 /// C7.2.70 FCVTAS (vector)
8195 pub const Fmsub = packed struct {8192 pub const Fcvtas = packed struct {
8196 Rd: Register.Encoded,8193 Rd: Register.Encoded,
8197 Rn: Register.Encoded,8194 Rn: Register.Encoded,
8198 Ra: Register.Encoded,8195 decoded10: u2 = 0b10,
8199 o0: AddSubtractOp = .sub,8196 opcode: u5 = 0b11100,
8197 decoded17: u6 = 0b111100,
8198 o2: u1 = 0b0,
8199 decoded24: u5 = 0b01110,
8200 U: std.builtin.Signedness = .signed,
8201 Q: Q,
8202 decoded31: u1 = 0b0,
8203 };
8204
8205 /// C7.2.234 SCVTF (vector, integer)
8206 pub const Scvtf = packed struct {
8207 Rd: Register.Encoded,
8208 Rn: Register.Encoded,
8209 decoded10: u2 = 0b10,
8210 opcode: u5 = 0b11101,
8211 decoded17: u6 = 0b111100,
8212 o2: u1 = 0b0,
8213 decoded24: u5 = 0b01110,
8214 U: std.builtin.Signedness = .signed,
8215 Q: Q,
8216 decoded31: u1 = 0b0,
8217 };
8218
8219 /// C7.2.61 FCMGT (zero)
8220 pub const Fcmgt = packed struct {
8221 Rd: Register.Encoded,
8222 Rn: Register.Encoded,
8223 decoded10: u2 = 0b10,
8224 opcode: u5 = 0b01100,
8225 decoded17: u6 = 0b111100,
8226 o2: u1 = 0b1,
8227 decoded24: u5 = 0b01110,
8228 U: std.builtin.Signedness = .signed,
8229 Q: Q,
8230 decoded31: u1 = 0b0,
8231 };
8232
8233 /// C7.2.57 FCMEQ (zero)
8234 pub const Fcmeq = packed struct {
8235 Rd: Register.Encoded,
8236 Rn: Register.Encoded,
8237 decoded10: u2 = 0b10,
8238 opcode: u5 = 0b01101,
8239 decoded17: u6 = 0b111100,
8240 o2: u1 = 0b1,
8241 decoded24: u5 = 0b01110,
8242 U: std.builtin.Signedness = .signed,
8243 Q: Q,
8244 decoded31: u1 = 0b0,
8245 };
8246
8247 /// C7.2.65 FCMLT (zero)
8248 pub const Fcmlt = packed struct {
8249 Rd: Register.Encoded,
8250 Rn: Register.Encoded,
8251 decoded10: u2 = 0b10,
8252 opcode: u5 = 0b01110,
8253 decoded17: u6 = 0b111100,
8254 o2: u1 = 0b1,
8255 decoded24: u5 = 0b01110,
8256 U: std.builtin.Signedness = .signed,
8257 Q: Q,
8258 decoded31: u1 = 0b0,
8259 };
8260
8261 /// C7.2.45 FABS (vector)
8262 pub const Fabs = packed struct {
8263 Rd: Register.Encoded,
8264 Rn: Register.Encoded,
8265 decoded10: u2 = 0b10,
8266 opcode: u5 = 0b01111,
8267 decoded17: u6 = 0b111100,
8268 o2: u1 = 0b1,
8269 decoded24: u5 = 0b01110,
8270 U: std.builtin.Signedness = .signed,
8271 Q: Q,
8272 decoded31: u1 = 0b0,
8273 };
8274
8275 /// C7.2.163 FRINTP (vector)
8276 pub const Frintp = packed struct {
8277 Rd: Register.Encoded,
8278 Rn: Register.Encoded,
8279 decoded10: u2 = 0b10,
8280 opcode: u5 = 0b11000,
8281 decoded17: u6 = 0b111100,
8282 o2: u1 = 0b1,
8283 decoded24: u5 = 0b01110,
8284 U: std.builtin.Signedness = .signed,
8285 Q: Q,
8286 decoded31: u1 = 0b0,
8287 };
8288
8289 /// C7.2.167 FRINTZ (vector)
8290 pub const Frintz = packed struct {
8291 Rd: Register.Encoded,
8292 Rn: Register.Encoded,
8293 decoded10: u2 = 0b10,
8294 opcode: u5 = 0b11001,
8295 decoded17: u6 = 0b111100,
8296 o2: u1 = 0b1,
8297 decoded24: u5 = 0b01110,
8298 U: std.builtin.Signedness = .signed,
8299 Q: Q,
8300 decoded31: u1 = 0b0,
8301 };
8302
8303 /// C7.2.84 FCVTPS (vector)
8304 pub const Fcvtps = packed struct {
8305 Rd: Register.Encoded,
8306 Rn: Register.Encoded,
8307 decoded10: u2 = 0b10,
8308 opcode: u5 = 0b11010,
8309 decoded17: u6 = 0b111100,
8310 o2: u1 = 0b1,
8311 decoded24: u5 = 0b01110,
8312 U: std.builtin.Signedness = .signed,
8313 Q: Q,
8314 decoded31: u1 = 0b0,
8315 };
8316
8317 /// C7.2.90 FCVTZS (vector, integer)
8318 pub const Fcvtzs = packed struct {
8319 Rd: Register.Encoded,
8320 Rn: Register.Encoded,
8321 decoded10: u2 = 0b10,
8322 opcode: u5 = 0b11011,
8323 decoded17: u6 = 0b111100,
8324 o2: u1 = 0b1,
8325 decoded24: u5 = 0b01110,
8326 U: std.builtin.Signedness = .signed,
8327 Q: Q,
8328 decoded31: u1 = 0b0,
8329 };
8330
8331 /// C7.2.144 FRECPE
8332 pub const Frecpe = packed struct {
8333 Rd: Register.Encoded,
8334 Rn: Register.Encoded,
8335 decoded10: u2 = 0b10,
8336 opcode: u5 = 0b11101,
8337 decoded17: u6 = 0b111100,
8338 o2: u1 = 0b1,
8339 decoded24: u5 = 0b01110,
8340 U: std.builtin.Signedness = .signed,
8341 Q: Q,
8342 decoded31: u1 = 0b0,
8343 };
8344
8345 /// C7.2.155 FRINTA (vector)
8346 pub const Frinta = packed struct {
8347 Rd: Register.Encoded,
8348 Rn: Register.Encoded,
8349 decoded10: u2 = 0b10,
8350 opcode: u5 = 0b11000,
8351 decoded17: u6 = 0b111100,
8352 o2: u1 = 0b0,
8353 decoded24: u5 = 0b01110,
8354 U: std.builtin.Signedness = .unsigned,
8355 Q: Q,
8356 decoded31: u1 = 0b0,
8357 };
8358
8359 /// C7.2.159 FRINTX (vector)
8360 pub const Frintx = packed struct {
8361 Rd: Register.Encoded,
8362 Rn: Register.Encoded,
8363 decoded10: u2 = 0b10,
8364 opcode: u5 = 0b11001,
8365 decoded17: u6 = 0b111100,
8366 o2: u1 = 0b0,
8367 decoded24: u5 = 0b01110,
8368 U: std.builtin.Signedness = .unsigned,
8369 Q: Q,
8370 decoded31: u1 = 0b0,
8371 };
8372
8373 /// C7.2.82 FCVTNU (vector)
8374 pub const Fcvtnu = packed struct {
8375 Rd: Register.Encoded,
8376 Rn: Register.Encoded,
8377 decoded10: u2 = 0b10,
8378 opcode: u5 = 0b11010,
8379 decoded17: u6 = 0b111100,
8380 o2: u1 = 0b0,
8381 decoded24: u5 = 0b01110,
8382 U: std.builtin.Signedness = .unsigned,
8383 Q: Q,
8384 decoded31: u1 = 0b0,
8385 };
8386
8387 /// C7.2.77 FCVTMU (vector)
8388 pub const Fcvtmu = packed struct {
8389 Rd: Register.Encoded,
8390 Rn: Register.Encoded,
8391 decoded10: u2 = 0b10,
8392 opcode: u5 = 0b11011,
8393 decoded17: u6 = 0b111100,
8394 o2: u1 = 0b0,
8395 decoded24: u5 = 0b01110,
8396 U: std.builtin.Signedness = .unsigned,
8397 Q: Q,
8398 decoded31: u1 = 0b0,
8399 };
8400
8401 /// C7.2.72 FCVTAU (vector)
8402 pub const Fcvtau = packed struct {
8403 Rd: Register.Encoded,
8404 Rn: Register.Encoded,
8405 decoded10: u2 = 0b10,
8406 opcode: u5 = 0b11100,
8407 decoded17: u6 = 0b111100,
8408 o2: u1 = 0b0,
8409 decoded24: u5 = 0b01110,
8410 U: std.builtin.Signedness = .unsigned,
8411 Q: Q,
8412 decoded31: u1 = 0b0,
8413 };
8414
8415 /// C7.2.353 UCVTF (vector, integer)
8416 pub const Ucvtf = packed struct {
8417 Rd: Register.Encoded,
8418 Rn: Register.Encoded,
8419 decoded10: u2 = 0b10,
8420 opcode: u5 = 0b11101,
8421 decoded17: u6 = 0b111100,
8422 o2: u1 = 0b0,
8423 decoded24: u5 = 0b01110,
8424 U: std.builtin.Signedness = .unsigned,
8425 Q: Q,
8426 decoded31: u1 = 0b0,
8427 };
8428
8429 /// C7.2.59 FCMGE (zero)
8430 pub const Fcmge = packed struct {
8431 Rd: Register.Encoded,
8432 Rn: Register.Encoded,
8433 decoded10: u2 = 0b10,
8434 opcode: u5 = 0b01100,
8435 decoded17: u6 = 0b111100,
8436 o2: u1 = 0b1,
8437 decoded24: u5 = 0b01110,
8438 U: std.builtin.Signedness = .unsigned,
8439 Q: Q,
8440 decoded31: u1 = 0b0,
8441 };
8442
8443 /// C7.2.64 FCMLE (zero)
8444 pub const Fcmle = packed struct {
8445 Rd: Register.Encoded,
8446 Rn: Register.Encoded,
8447 decoded10: u2 = 0b10,
8448 opcode: u5 = 0b01101,
8449 decoded17: u6 = 0b111100,
8450 o2: u1 = 0b1,
8451 decoded24: u5 = 0b01110,
8452 U: std.builtin.Signedness = .unsigned,
8453 Q: Q,
8454 decoded31: u1 = 0b0,
8455 };
8456
8457 /// C7.2.139 FNEG (vector)
8458 pub const Fneg = packed struct {
8459 Rd: Register.Encoded,
8460 Rn: Register.Encoded,
8461 decoded10: u2 = 0b10,
8462 opcode: u5 = 0b01111,
8463 decoded17: u6 = 0b111100,
8464 o2: u1 = 0b1,
8465 decoded24: u5 = 0b01110,
8466 U: std.builtin.Signedness = .unsigned,
8467 Q: Q,
8468 decoded31: u1 = 0b0,
8469 };
8470
8471 /// C7.2.157 FRINTI (vector)
8472 pub const Frinti = packed struct {
8473 Rd: Register.Encoded,
8474 Rn: Register.Encoded,
8475 decoded10: u2 = 0b10,
8476 opcode: u5 = 0b11001,
8477 decoded17: u6 = 0b111100,
8478 o2: u1 = 0b1,
8479 decoded24: u5 = 0b01110,
8480 U: std.builtin.Signedness = .unsigned,
8481 Q: Q,
8482 decoded31: u1 = 0b0,
8483 };
8484
8485 /// C7.2.86 FCVTPU (vector)
8486 pub const Fcvtpu = packed struct {
8487 Rd: Register.Encoded,
8488 Rn: Register.Encoded,
8489 decoded10: u2 = 0b10,
8490 opcode: u5 = 0b11010,
8491 decoded17: u6 = 0b111100,
8492 o2: u1 = 0b1,
8493 decoded24: u5 = 0b01110,
8494 U: std.builtin.Signedness = .unsigned,
8495 Q: Q,
8496 decoded31: u1 = 0b0,
8497 };
8498
8499 /// C7.2.94 FCVTZU (vector, integer)
8500 pub const Fcvtzu = packed struct {
8501 Rd: Register.Encoded,
8502 Rn: Register.Encoded,
8503 decoded10: u2 = 0b10,
8504 opcode: u5 = 0b11011,
8505 decoded17: u6 = 0b111100,
8506 o2: u1 = 0b1,
8507 decoded24: u5 = 0b01110,
8508 U: std.builtin.Signedness = .unsigned,
8509 Q: Q,
8510 decoded31: u1 = 0b0,
8511 };
8512
8513 /// C7.2.169 FRSQRTE
8514 pub const Frsqrte = packed struct {
8515 Rd: Register.Encoded,
8516 Rn: Register.Encoded,
8517 decoded10: u2 = 0b10,
8518 opcode: u5 = 0b11101,
8519 decoded17: u6 = 0b111100,
8520 o2: u1 = 0b1,
8521 decoded24: u5 = 0b01110,
8522 U: std.builtin.Signedness = .unsigned,
8523 Q: Q,
8524 decoded31: u1 = 0b0,
8525 };
8526
8527 /// C7.2.171 FSQRT
8528 pub const Fsqrt = packed struct {
8529 Rd: Register.Encoded,
8530 Rn: Register.Encoded,
8531 decoded10: u2 = 0b10,
8532 opcode: u5 = 0b11111,
8533 decoded17: u6 = 0b111100,
8534 o2: u1 = 0b1,
8535 decoded24: u5 = 0b01110,
8536 U: std.builtin.Signedness = .unsigned,
8537 Q: Q,
8538 decoded31: u1 = 0b0,
8539 };
8540 };
8541
8542 /// Advanced SIMD two-register miscellaneous
8543 pub const SimdTwoRegisterMiscellaneous = packed union {
8544 group: @This().Group,
8545 suqadd: Suqadd,
8546 cnt: Cnt,
8547 sqabs: Sqabs,
8548 cmgt: Cmgt,
8549 cmeq: Cmeq,
8550 cmlt: Cmlt,
8551 abs: Abs,
8552 sqxtn: Sqxtn,
8553 frintn: Frintn,
8554 frintm: Frintm,
8555 fcvtns: Fcvtns,
8556 fcvtms: Fcvtms,
8557 fcvtas: Fcvtas,
8558 scvtf: Scvtf,
8559 fcmgt: Fcmgt,
8560 fcmeq: Fcmeq,
8561 fcmlt: Fcmlt,
8562 fabs: Fabs,
8563 frintp: Frintp,
8564 frintz: Frintz,
8565 fcvtps: Fcvtps,
8566 fcvtzs: Fcvtzs,
8567 frecpe: Frecpe,
8568 usqadd: Usqadd,
8569 sqneg: Sqneg,
8570 cmge: Cmge,
8571 cmle: Cmle,
8572 neg: Neg,
8573 sqxtun: Sqxtun,
8574 uqxtn: Uqxtn,
8575 fcvtxn: Fcvtxn,
8576 frinta: Frinta,
8577 frintx: Frintx,
8578 fcvtnu: Fcvtnu,
8579 fcvtmu: Fcvtmu,
8580 fcvtau: Fcvtau,
8581 ucvtf: Ucvtf,
8582 not: Not,
8583 fcmge: Fcmge,
8584 fcmle: Fcmle,
8585 fneg: Fneg,
8586 frinti: Frinti,
8587 fcvtpu: Fcvtpu,
8588 fcvtzu: Fcvtzu,
8589 frsqrte: Frsqrte,
8590 fsqrt: Fsqrt,
8591
8592 pub const Group = packed struct {
8593 Rd: Register.Encoded,
8594 Rn: Register.Encoded,
8595 decoded10: u2 = 0b10,
8596 opcode: u5,
8597 decoded17: u5 = 0b10000,
8598 size: Size,
8599 decoded24: u5 = 0b01110,
8600 U: std.builtin.Signedness,
8601 Q: Q,
8602 decoded31: u1 = 0b0,
8603 };
8604
8605 /// C7.2.337 SUQADD
8606 pub const Suqadd = packed struct {
8607 Rd: Register.Encoded,
8608 Rn: Register.Encoded,
8609 decoded10: u2 = 0b10,
8610 opcode: u5 = 0b00011,
8611 decoded17: u5 = 0b10000,
8612 size: Size,
8613 decoded24: u5 = 0b01110,
8614 U: std.builtin.Signedness = .signed,
8615 Q: Q,
8616 decoded31: u1 = 0b0,
8617 };
8618
8619 /// C7.2.38 CNT
8620 pub const Cnt = packed struct {
8621 Rd: Register.Encoded,
8622 Rn: Register.Encoded,
8623 decoded10: u2 = 0b10,
8624 opcode: u5 = 0b00101,
8625 decoded17: u5 = 0b10000,
8626 size: Size,
8627 decoded24: u5 = 0b01110,
8628 U: std.builtin.Signedness = .signed,
8629 Q: Q,
8630 decoded31: u1 = 0b0,
8631 };
8632
8633 /// C7.2.282 SQABS
8634 pub const Sqabs = packed struct {
8635 Rd: Register.Encoded,
8636 Rn: Register.Encoded,
8637 decoded10: u2 = 0b10,
8638 opcode: u5 = 0b00111,
8639 decoded17: u5 = 0b10000,
8640 size: Size,
8641 decoded24: u5 = 0b01110,
8642 U: std.builtin.Signedness = .signed,
8643 Q: Q,
8644 decoded31: u1 = 0b0,
8645 };
8646
8647 /// C7.2.32 CMGT (zero)
8648 pub const Cmgt = packed struct {
8649 Rd: Register.Encoded,
8650 Rn: Register.Encoded,
8651 decoded10: u2 = 0b10,
8652 opcode: u5 = 0b01000,
8653 decoded17: u5 = 0b10000,
8654 size: Size,
8655 decoded24: u5 = 0b01110,
8656 U: std.builtin.Signedness = .signed,
8657 Q: Q,
8658 decoded31: u1 = 0b0,
8659 };
8660
8661 /// C7.2.28 CMEQ (zero)
8662 pub const Cmeq = packed struct {
8663 Rd: Register.Encoded,
8664 Rn: Register.Encoded,
8665 decoded10: u2 = 0b10,
8666 opcode: u5 = 0b01001,
8667 decoded17: u5 = 0b10000,
8668 size: Size,
8669 decoded24: u5 = 0b01110,
8670 U: std.builtin.Signedness = .signed,
8671 Q: Q,
8672 decoded31: u1 = 0b0,
8673 };
8674
8675 /// C7.2.36 CMLT (zero)
8676 pub const Cmlt = packed struct {
8677 Rd: Register.Encoded,
8678 Rn: Register.Encoded,
8679 decoded10: u2 = 0b10,
8680 opcode: u5 = 0b01010,
8681 decoded17: u5 = 0b10000,
8682 size: Size,
8683 decoded24: u5 = 0b01110,
8684 U: std.builtin.Signedness = .signed,
8685 Q: Q,
8686 decoded31: u1 = 0b0,
8687 };
8688
8689 /// C7.2.1 ABS
8690 pub const Abs = packed struct {
8691 Rd: Register.Encoded,
8692 Rn: Register.Encoded,
8693 decoded10: u2 = 0b10,
8694 opcode: u5 = 0b01011,
8695 decoded17: u5 = 0b10000,
8696 size: Size,
8697 decoded24: u5 = 0b01110,
8698 U: std.builtin.Signedness = .signed,
8699 Q: Q,
8700 decoded31: u1 = 0b0,
8701 };
8702
8703 /// C7.2.308 SQXTN
8704 pub const Sqxtn = packed struct {
8705 Rd: Register.Encoded,
8706 Rn: Register.Encoded,
8707 decoded10: u2 = 0b10,
8708 opcode: u5 = 0b10100,
8709 decoded17: u5 = 0b10000,
8710 size: Size,
8711 decoded24: u5 = 0b01110,
8712 U: std.builtin.Signedness = .signed,
8713 Q: Q,
8714 decoded31: u1 = 0b0,
8715 };
8716
8717 /// C7.2.161 FRINTN (vector)
8718 pub const Frintn = packed struct {
8719 Rd: Register.Encoded,
8720 Rn: Register.Encoded,
8721 decoded10: u2 = 0b10,
8722 opcode: u5 = 0b11000,
8723 decoded17: u5 = 0b10000,
8724 sz: Sz,
8725 o2: u1 = 0b0,
8726 decoded24: u5 = 0b01110,
8727 U: std.builtin.Signedness = .signed,
8728 Q: Q,
8729 decoded31: u1 = 0b0,
8730 };
8731
8732 /// C7.2.159 FRINTM (vector)
8733 pub const Frintm = packed struct {
8734 Rd: Register.Encoded,
8735 Rn: Register.Encoded,
8736 decoded10: u2 = 0b10,
8737 opcode: u5 = 0b11001,
8738 decoded17: u5 = 0b10000,
8739 sz: Sz,
8740 o2: u1 = 0b0,
8741 decoded24: u5 = 0b01110,
8742 U: std.builtin.Signedness = .signed,
8743 Q: Q,
8744 decoded31: u1 = 0b0,
8745 };
8746
8747 /// C7.2.80 FCVTNS (vector)
8748 pub const Fcvtns = packed struct {
8749 Rd: Register.Encoded,
8750 Rn: Register.Encoded,
8751 decoded10: u2 = 0b10,
8752 opcode: u5 = 0b11010,
8753 decoded17: u5 = 0b10000,
8754 sz: Sz,
8755 o2: u1 = 0b0,
8756 decoded24: u5 = 0b01110,
8757 U: std.builtin.Signedness = .signed,
8758 Q: Q,
8759 decoded31: u1 = 0b0,
8760 };
8761
8762 /// C7.2.75 FCVTMS (vector)
8763 pub const Fcvtms = packed struct {
8764 Rd: Register.Encoded,
8765 Rn: Register.Encoded,
8766 decoded10: u2 = 0b10,
8767 opcode: u5 = 0b11011,
8768 decoded17: u5 = 0b10000,
8769 sz: Sz,
8770 o2: u1 = 0b0,
8771 decoded24: u5 = 0b01110,
8772 U: std.builtin.Signedness = .signed,
8773 Q: Q,
8774 decoded31: u1 = 0b0,
8775 };
8776
8777 /// C7.2.70 FCVTAS (vector)
8778 pub const Fcvtas = packed struct {
8779 Rd: Register.Encoded,
8780 Rn: Register.Encoded,
8781 decoded10: u2 = 0b10,
8782 opcode: u5 = 0b11100,
8783 decoded17: u5 = 0b10000,
8784 sz: Sz,
8785 o2: u1 = 0b0,
8786 decoded24: u5 = 0b01110,
8787 U: std.builtin.Signedness = .signed,
8788 Q: Q,
8789 decoded31: u1 = 0b0,
8790 };
8791
8792 /// C7.2.234 SCVTF (vector, integer)
8793 pub const Scvtf = packed struct {
8794 Rd: Register.Encoded,
8795 Rn: Register.Encoded,
8796 decoded10: u2 = 0b10,
8797 opcode: u5 = 0b11101,
8798 decoded17: u5 = 0b10000,
8799 sz: Sz,
8800 o2: u1 = 0b0,
8801 decoded24: u5 = 0b01110,
8802 U: std.builtin.Signedness = .signed,
8803 Q: Q,
8804 decoded31: u1 = 0b0,
8805 };
8806
8807 /// C7.2.61 FCMGT (zero)
8808 pub const Fcmgt = packed struct {
8809 Rd: Register.Encoded,
8810 Rn: Register.Encoded,
8811 decoded10: u2 = 0b10,
8812 opcode: u5 = 0b01100,
8813 decoded17: u5 = 0b10000,
8814 sz: Sz,
8815 o2: u1 = 0b1,
8816 decoded24: u5 = 0b01110,
8817 U: std.builtin.Signedness = .signed,
8818 Q: Q,
8819 decoded31: u1 = 0b0,
8820 };
8821
8822 /// C7.2.57 FCMEQ (zero)
8823 pub const Fcmeq = packed struct {
8824 Rd: Register.Encoded,
8825 Rn: Register.Encoded,
8826 decoded10: u2 = 0b10,
8827 opcode: u5 = 0b01101,
8828 decoded17: u5 = 0b10000,
8829 sz: Sz,
8830 o2: u1 = 0b1,
8831 decoded24: u5 = 0b01110,
8832 U: std.builtin.Signedness = .signed,
8833 Q: Q,
8834 decoded31: u1 = 0b0,
8835 };
8836
8837 /// C7.2.65 FCMLT (zero)
8838 pub const Fcmlt = packed struct {
8839 Rd: Register.Encoded,
8840 Rn: Register.Encoded,
8841 decoded10: u2 = 0b10,
8842 opcode: u5 = 0b01110,
8843 decoded17: u5 = 0b10000,
8844 sz: Sz,
8845 o2: u1 = 0b1,
8846 decoded24: u5 = 0b01110,
8847 U: std.builtin.Signedness = .signed,
8848 Q: Q,
8849 decoded31: u1 = 0b0,
8850 };
8851
8852 /// C7.2.45 FABS (vector)
8853 pub const Fabs = packed struct {
8854 Rd: Register.Encoded,
8855 Rn: Register.Encoded,
8856 decoded10: u2 = 0b10,
8857 opcode: u5 = 0b01111,
8858 decoded17: u5 = 0b10000,
8859 sz: Sz,
8860 o2: u1 = 0b1,
8861 decoded24: u5 = 0b01110,
8862 U: std.builtin.Signedness = .signed,
8863 Q: Q,
8864 decoded31: u1 = 0b0,
8865 };
8866
8867 /// C7.2.163 FRINTP (vector)
8868 pub const Frintp = packed struct {
8869 Rd: Register.Encoded,
8870 Rn: Register.Encoded,
8871 decoded10: u2 = 0b10,
8872 opcode: u5 = 0b11000,
8873 decoded17: u5 = 0b10000,
8874 sz: Sz,
8875 o2: u1 = 0b1,
8876 decoded24: u5 = 0b01110,
8877 U: std.builtin.Signedness = .signed,
8878 Q: Q,
8879 decoded31: u1 = 0b0,
8880 };
8881
8882 /// C7.2.167 FRINTZ (vector)
8883 pub const Frintz = packed struct {
8884 Rd: Register.Encoded,
8885 Rn: Register.Encoded,
8886 decoded10: u2 = 0b10,
8887 opcode: u5 = 0b11001,
8888 decoded17: u5 = 0b10000,
8889 sz: Sz,
8890 o2: u1 = 0b1,
8891 decoded24: u5 = 0b01110,
8892 U: std.builtin.Signedness = .signed,
8893 Q: Q,
8894 decoded31: u1 = 0b0,
8895 };
8896
8897 /// C7.2.84 FCVTPS (vector)
8898 pub const Fcvtps = packed struct {
8899 Rd: Register.Encoded,
8900 Rn: Register.Encoded,
8901 decoded10: u2 = 0b10,
8902 opcode: u5 = 0b11010,
8903 decoded17: u5 = 0b10000,
8904 sz: Sz,
8905 o2: u1 = 0b1,
8906 decoded24: u5 = 0b01110,
8907 U: std.builtin.Signedness = .signed,
8908 Q: Q,
8909 decoded31: u1 = 0b0,
8910 };
8911
8912 /// C7.2.90 FCVTZS (vector, integer)
8913 pub const Fcvtzs = packed struct {
8914 Rd: Register.Encoded,
8915 Rn: Register.Encoded,
8916 decoded10: u2 = 0b10,
8917 opcode: u5 = 0b11011,
8918 decoded17: u5 = 0b10000,
8919 sz: Sz,
8920 o2: u1 = 0b1,
8921 decoded24: u5 = 0b01110,
8922 U: std.builtin.Signedness = .signed,
8923 Q: Q,
8924 decoded31: u1 = 0b0,
8925 };
8926
8927 /// C7.2.144 FRECPE
8928 pub const Frecpe = packed struct {
8929 Rd: Register.Encoded,
8930 Rn: Register.Encoded,
8931 decoded10: u2 = 0b10,
8932 opcode: u5 = 0b11101,
8933 decoded17: u5 = 0b10000,
8934 sz: Sz,
8935 o2: u1 = 0b1,
8936 decoded24: u5 = 0b01110,
8937 U: std.builtin.Signedness = .signed,
8938 Q: Q,
8939 decoded31: u1 = 0b0,
8940 };
8941
8942 /// C7.2.394 USQADD
8943 pub const Usqadd = packed struct {
8944 Rd: Register.Encoded,
8945 Rn: Register.Encoded,
8946 decoded10: u2 = 0b10,
8947 opcode: u5 = 0b00011,
8948 decoded17: u5 = 0b10000,
8949 size: Size,
8950 decoded24: u5 = 0b01110,
8951 U: std.builtin.Signedness = .unsigned,
8952 Q: Q,
8953 decoded31: u1 = 0b0,
8954 };
8955
8956 /// C7.2.292 SQNEG
8957 pub const Sqneg = packed struct {
8958 Rd: Register.Encoded,
8959 Rn: Register.Encoded,
8960 decoded10: u2 = 0b10,
8961 opcode: u5 = 0b00111,
8962 decoded17: u5 = 0b10000,
8963 size: Size,
8964 decoded24: u5 = 0b01110,
8965 U: std.builtin.Signedness = .unsigned,
8966 Q: Q,
8967 decoded31: u1 = 0b0,
8968 };
8969
8970 /// C7.2.30 CMGE (zero)
8971 pub const Cmge = packed struct {
8972 Rd: Register.Encoded,
8973 Rn: Register.Encoded,
8974 decoded10: u2 = 0b10,
8975 opcode: u5 = 0b01000,
8976 decoded17: u5 = 0b10000,
8977 size: Size,
8978 decoded24: u5 = 0b01110,
8979 U: std.builtin.Signedness = .unsigned,
8980 Q: Q,
8981 decoded31: u1 = 0b0,
8982 };
8983
8984 /// C7.2.35 CMLE (zero)
8985 pub const Cmle = packed struct {
8986 Rd: Register.Encoded,
8987 Rn: Register.Encoded,
8988 decoded10: u2 = 0b10,
8989 opcode: u5 = 0b01001,
8990 decoded17: u5 = 0b10000,
8991 size: Size,
8992 decoded24: u5 = 0b01110,
8993 U: std.builtin.Signedness = .unsigned,
8994 Q: Q,
8995 decoded31: u1 = 0b0,
8996 };
8997
8998 /// C7.2.209 NEG (vector)
8999 pub const Neg = packed struct {
9000 Rd: Register.Encoded,
9001 Rn: Register.Encoded,
9002 decoded10: u2 = 0b10,
9003 opcode: u5 = 0b01011,
9004 decoded17: u5 = 0b10000,
9005 size: Size,
9006 decoded24: u5 = 0b01110,
9007 U: std.builtin.Signedness = .unsigned,
9008 Q: Q,
9009 decoded31: u1 = 0b0,
9010 };
9011
9012 /// C7.2.309 SQXTUN
9013 pub const Sqxtun = packed struct {
9014 Rd: Register.Encoded,
9015 Rn: Register.Encoded,
9016 decoded10: u2 = 0b10,
9017 opcode: u5 = 0b10010,
9018 decoded17: u5 = 0b10000,
9019 size: Size,
9020 decoded24: u5 = 0b01110,
9021 U: std.builtin.Signedness = .unsigned,
9022 Q: Q,
9023 decoded31: u1 = 0b0,
9024 };
9025
9026 /// C7.2.381 UQXTN
9027 pub const Uqxtn = packed struct {
9028 Rd: Register.Encoded,
9029 Rn: Register.Encoded,
9030 decoded10: u2 = 0b10,
9031 opcode: u5 = 0b10100,
9032 decoded17: u5 = 0b10000,
9033 size: Size,
9034 decoded24: u5 = 0b01110,
9035 U: std.builtin.Signedness = .unsigned,
9036 Q: Q,
9037 decoded31: u1 = 0b0,
9038 };
9039
9040 /// C7.2.88 FCVTXN
9041 pub const Fcvtxn = packed struct {
9042 Rd: Register.Encoded,
9043 Rn: Register.Encoded,
9044 decoded10: u2 = 0b10,
9045 opcode: u5 = 0b10110,
9046 decoded17: u5 = 0b10000,
9047 sz: Sz,
9048 o2: u1 = 0b0,
9049 decoded24: u5 = 0b01110,
9050 U: std.builtin.Signedness = .unsigned,
9051 Q: Q,
9052 decoded31: u1 = 0b0,
9053 };
9054
9055 /// C7.2.155 FRINTA (vector)
9056 pub const Frinta = packed struct {
9057 Rd: Register.Encoded,
9058 Rn: Register.Encoded,
9059 decoded10: u2 = 0b10,
9060 opcode: u5 = 0b11000,
9061 decoded17: u5 = 0b10000,
9062 sz: Sz,
9063 o2: u1 = 0b0,
9064 decoded24: u5 = 0b01110,
9065 U: std.builtin.Signedness = .unsigned,
9066 Q: Q,
9067 decoded31: u1 = 0b0,
9068 };
9069
9070 /// C7.2.165 FRINTX (vector)
9071 pub const Frintx = packed struct {
9072 Rd: Register.Encoded,
9073 Rn: Register.Encoded,
9074 decoded10: u2 = 0b10,
9075 opcode: u5 = 0b11001,
9076 decoded17: u5 = 0b10000,
9077 sz: Sz,
9078 o2: u1 = 0b0,
9079 decoded24: u5 = 0b01110,
9080 U: std.builtin.Signedness = .unsigned,
9081 Q: Q,
9082 decoded31: u1 = 0b0,
9083 };
9084
9085 /// C7.2.82 FCVTNU (vector)
9086 pub const Fcvtnu = packed struct {
9087 Rd: Register.Encoded,
9088 Rn: Register.Encoded,
9089 decoded10: u2 = 0b10,
9090 opcode: u5 = 0b11010,
9091 decoded17: u5 = 0b10000,
9092 sz: Sz,
9093 o2: u1 = 0b0,
9094 decoded24: u5 = 0b01110,
9095 U: std.builtin.Signedness = .unsigned,
9096 Q: Q,
9097 decoded31: u1 = 0b0,
9098 };
9099
9100 /// C7.2.77 FCVTMU (vector)
9101 pub const Fcvtmu = packed struct {
9102 Rd: Register.Encoded,
9103 Rn: Register.Encoded,
9104 decoded10: u2 = 0b10,
9105 opcode: u5 = 0b11011,
9106 decoded17: u5 = 0b10000,
9107 sz: Sz,
9108 o2: u1 = 0b0,
9109 decoded24: u5 = 0b01110,
9110 U: std.builtin.Signedness = .unsigned,
9111 Q: Q,
9112 decoded31: u1 = 0b0,
9113 };
9114
9115 /// C7.2.72 FCVTAU (vector)
9116 pub const Fcvtau = packed struct {
9117 Rd: Register.Encoded,
9118 Rn: Register.Encoded,
9119 decoded10: u2 = 0b10,
9120 opcode: u5 = 0b11100,
9121 decoded17: u5 = 0b10000,
9122 sz: Sz,
9123 o2: u1 = 0b0,
9124 decoded24: u5 = 0b01110,
9125 U: std.builtin.Signedness = .unsigned,
9126 Q: Q,
9127 decoded31: u1 = 0b0,
9128 };
9129
9130 /// C7.2.353 UCVTF (vector, integer)
9131 pub const Ucvtf = packed struct {
9132 Rd: Register.Encoded,
9133 Rn: Register.Encoded,
9134 decoded10: u2 = 0b10,
9135 opcode: u5 = 0b11101,
9136 decoded17: u5 = 0b10000,
9137 sz: Sz,
9138 o2: u1 = 0b0,
9139 decoded24: u5 = 0b01110,
9140 U: std.builtin.Signedness = .unsigned,
9141 Q: Q,
9142 decoded31: u1 = 0b0,
9143 };
9144
9145 /// C7.2.210 NOT
9146 pub const Not = packed struct {
9147 Rd: Register.Encoded,
9148 Rn: Register.Encoded,
9149 decoded10: u2 = 0b10,
9150 opcode: u5 = 0b00101,
9151 decoded17: u5 = 0b10000,
9152 size: Size = .byte,
9153 decoded24: u5 = 0b01110,
9154 U: std.builtin.Signedness = .unsigned,
9155 Q: Q,
9156 decoded31: u1 = 0b0,
9157 };
9158
9159 /// C7.2.59 FCMGE (zero)
9160 pub const Fcmge = packed struct {
9161 Rd: Register.Encoded,
9162 Rn: Register.Encoded,
9163 decoded10: u2 = 0b10,
9164 opcode: u5 = 0b01100,
9165 decoded17: u5 = 0b10000,
9166 sz: Sz,
9167 o2: u1 = 0b1,
9168 decoded24: u5 = 0b01110,
9169 U: std.builtin.Signedness = .unsigned,
9170 Q: Q,
9171 decoded31: u1 = 0b0,
9172 };
9173
9174 /// C7.2.64 FCMLE (zero)
9175 pub const Fcmle = packed struct {
9176 Rd: Register.Encoded,
9177 Rn: Register.Encoded,
9178 decoded10: u2 = 0b10,
9179 opcode: u5 = 0b01101,
9180 decoded17: u5 = 0b10000,
9181 sz: Sz,
9182 o2: u1 = 0b1,
9183 decoded24: u5 = 0b01110,
9184 U: std.builtin.Signedness = .unsigned,
9185 Q: Q,
9186 decoded31: u1 = 0b0,
9187 };
9188
9189 /// C7.2.139 FNEG (vector)
9190 pub const Fneg = packed struct {
9191 Rd: Register.Encoded,
9192 Rn: Register.Encoded,
9193 decoded10: u2 = 0b10,
9194 opcode: u5 = 0b01111,
9195 decoded17: u5 = 0b10000,
9196 sz: Sz,
9197 o2: u1 = 0b1,
9198 decoded24: u5 = 0b01110,
9199 U: std.builtin.Signedness = .unsigned,
9200 Q: Q,
9201 decoded31: u1 = 0b0,
9202 };
9203
9204 /// C7.2.157 FRINTI (vector)
9205 pub const Frinti = packed struct {
9206 Rd: Register.Encoded,
9207 Rn: Register.Encoded,
9208 decoded10: u2 = 0b10,
9209 opcode: u5 = 0b11001,
9210 decoded17: u5 = 0b10000,
9211 sz: Sz,
9212 o2: u1 = 0b1,
9213 decoded24: u5 = 0b01110,
9214 U: std.builtin.Signedness = .unsigned,
9215 Q: Q,
9216 decoded31: u1 = 0b0,
9217 };
9218
9219 /// C7.2.86 FCVTPU (vector)
9220 pub const Fcvtpu = packed struct {
9221 Rd: Register.Encoded,
9222 Rn: Register.Encoded,
9223 decoded10: u2 = 0b10,
9224 opcode: u5 = 0b11010,
9225 decoded17: u5 = 0b10000,
9226 sz: Sz,
9227 o2: u1 = 0b1,
9228 decoded24: u5 = 0b01110,
9229 U: std.builtin.Signedness = .unsigned,
9230 Q: Q,
9231 decoded31: u1 = 0b0,
9232 };
9233
9234 /// C7.2.94 FCVTZU (vector, integer)
9235 pub const Fcvtzu = packed struct {
9236 Rd: Register.Encoded,
9237 Rn: Register.Encoded,
9238 decoded10: u2 = 0b10,
9239 opcode: u5 = 0b11011,
9240 decoded17: u5 = 0b10000,
9241 sz: Sz,
9242 o2: u1 = 0b1,
9243 decoded24: u5 = 0b01110,
9244 U: std.builtin.Signedness = .unsigned,
9245 Q: Q,
9246 decoded31: u1 = 0b0,
9247 };
9248
9249 /// C7.2.169 FRSQRTE
9250 pub const Frsqrte = packed struct {
9251 Rd: Register.Encoded,
9252 Rn: Register.Encoded,
9253 decoded10: u2 = 0b10,
9254 opcode: u5 = 0b11101,
9255 decoded17: u5 = 0b10000,
9256 sz: Sz,
9257 o2: u1 = 0b1,
9258 decoded24: u5 = 0b01110,
9259 U: std.builtin.Signedness = .unsigned,
9260 Q: Q,
9261 decoded31: u1 = 0b0,
9262 };
9263
9264 /// C7.2.171 FSQRT (vector)
9265 pub const Fsqrt = packed struct {
9266 Rd: Register.Encoded,
9267 Rn: Register.Encoded,
9268 decoded10: u2 = 0b10,
9269 opcode: u5 = 0b11111,
9270 decoded17: u5 = 0b10000,
9271 sz: Sz,
9272 o2: u1 = 0b1,
9273 decoded24: u5 = 0b01110,
9274 U: std.builtin.Signedness = .unsigned,
9275 Q: Q,
9276 decoded31: u1 = 0b0,
9277 };
9278 };
9279
9280 /// Advanced SIMD across lanes
9281 pub const SimdAcrossLanes = packed union {
9282 group: @This().Group,
9283 addv: Addv,
9284
9285 pub const Group = packed struct {
9286 Rd: Register.Encoded,
9287 Rn: Register.Encoded,
9288 decoded10: u2 = 0b10,
9289 opcode: u5,
9290 decoded17: u5 = 0b11000,
9291 size: Size,
9292 decoded24: u5 = 0b01110,
9293 U: std.builtin.Signedness,
9294 Q: Q,
9295 decoded31: u1 = 0b0,
9296 };
9297
9298 /// C7.2.6 ADDV
9299 pub const Addv = packed struct {
9300 Rd: Register.Encoded,
9301 Rn: Register.Encoded,
9302 decoded10: u2 = 0b10,
9303 opcode: u5 = 0b11011,
9304 decoded17: u5 = 0b11000,
9305 size: Size,
9306 decoded24: u5 = 0b01110,
9307 U: std.builtin.Signedness = .signed,
9308 Q: Q,
9309 decoded31: u1 = 0b0,
9310 };
9311 };
9312
9313 /// Advanced SIMD three same
9314 pub const SimdThreeSame = packed union {
9315 group: @This().Group,
9316 addp: Addp,
9317 @"and": And,
9318 bic: Bic,
9319 orr: Orr,
9320 orn: Orn,
9321 eor: Eor,
9322 bsl: Bsl,
9323 bit: Bit,
9324 bif: Bif,
9325
9326 pub const Group = packed struct {
9327 Rd: Register.Encoded,
9328 Rn: Register.Encoded,
9329 decoded10: u1 = 0b1,
9330 opcode: u5,
9331 Rm: Register.Encoded,
9332 decoded21: u1 = 0b1,
9333 size: Size,
9334 decoded24: u5 = 0b01110,
9335 U: std.builtin.Signedness,
9336 Q: Q,
9337 decoded31: u1 = 0b0,
9338 };
9339
9340 /// C7.2.5 ADDP (vector)
9341 pub const Addp = packed struct {
9342 Rd: Register.Encoded,
9343 Rn: Register.Encoded,
9344 decoded10: u1 = 0b1,
9345 opcode: u5 = 0b10111,
9346 Rm: Register.Encoded,
9347 decoded21: u1 = 0b1,
9348 size: Size,
9349 decoded24: u5 = 0b01110,
9350 U: std.builtin.Signedness = .signed,
9351 Q: Q,
9352 decoded31: u1 = 0b0,
9353 };
9354
9355 /// C7.2.11 AND (vector)
9356 pub const And = packed struct {
9357 Rd: Register.Encoded,
9358 Rn: Register.Encoded,
9359 decoded10: u1 = 0b1,
9360 opcode: u5 = 0b00011,
9361 Rm: Register.Encoded,
9362 decoded21: u1 = 0b1,
9363 size: Size = .byte,
9364 decoded24: u5 = 0b01110,
9365 U: std.builtin.Signedness = .signed,
9366 Q: Q,
9367 decoded31: u1 = 0b0,
9368 };
9369
9370 /// C7.2.21 BIC (vector, register)
9371 pub const Bic = packed struct {
9372 Rd: Register.Encoded,
9373 Rn: Register.Encoded,
9374 decoded10: u1 = 0b1,
9375 opcode: u5 = 0b00011,
9376 Rm: Register.Encoded,
9377 decoded21: u1 = 0b1,
9378 size: Size = .half,
9379 decoded24: u5 = 0b01110,
9380 U: std.builtin.Signedness = .signed,
9381 Q: Q,
9382 decoded31: u1 = 0b0,
9383 };
9384
9385 /// C7.2.213 ORR (vector, register)
9386 pub const Orr = packed struct {
9387 Rd: Register.Encoded,
9388 Rn: Register.Encoded,
9389 decoded10: u1 = 0b1,
9390 opcode: u5 = 0b00011,
9391 Rm: Register.Encoded,
9392 decoded21: u1 = 0b1,
9393 size: Size = .single,
9394 decoded24: u5 = 0b01110,
9395 U: std.builtin.Signedness = .signed,
9396 Q: Q,
9397 decoded31: u1 = 0b0,
9398 };
9399
9400 /// C7.2.211 ORN (vector)
9401 pub const Orn = packed struct {
9402 Rd: Register.Encoded,
9403 Rn: Register.Encoded,
9404 decoded10: u1 = 0b1,
9405 opcode: u5 = 0b00011,
9406 Rm: Register.Encoded,
9407 decoded21: u1 = 0b1,
9408 size: Size = .double,
9409 decoded24: u5 = 0b01110,
9410 U: std.builtin.Signedness = .signed,
9411 Q: Q,
9412 decoded31: u1 = 0b0,
9413 };
9414
9415 /// C7.2.41 EOR (vector)
9416 pub const Eor = packed struct {
9417 Rd: Register.Encoded,
9418 Rn: Register.Encoded,
9419 decoded10: u1 = 0b1,
9420 opcode: u5 = 0b00011,
9421 Rm: Register.Encoded,
9422 decoded21: u1 = 0b1,
9423 size: Size = .byte,
9424 decoded24: u5 = 0b01110,
9425 U: std.builtin.Signedness = .unsigned,
9426 Q: Q,
9427 decoded31: u1 = 0b0,
9428 };
9429
9430 /// C7.2.24 BSL
9431 pub const Bsl = packed struct {
9432 Rd: Register.Encoded,
9433 Rn: Register.Encoded,
9434 decoded10: u1 = 0b1,
9435 opcode: u5 = 0b00011,
9436 Rm: Register.Encoded,
9437 decoded21: u1 = 0b1,
9438 size: Size = .half,
9439 decoded24: u5 = 0b01110,
9440 U: std.builtin.Signedness = .unsigned,
9441 Q: Q,
9442 decoded31: u1 = 0b0,
9443 };
9444
9445 /// C7.2.23 BIT
9446 pub const Bit = packed struct {
9447 Rd: Register.Encoded,
9448 Rn: Register.Encoded,
9449 decoded10: u1 = 0b1,
9450 opcode: u5 = 0b00011,
9451 Rm: Register.Encoded,
9452 decoded21: u1 = 0b1,
9453 size: Size = .single,
9454 decoded24: u5 = 0b01110,
9455 U: std.builtin.Signedness = .unsigned,
9456 Q: Q,
9457 decoded31: u1 = 0b0,
9458 };
9459
9460 /// C7.2.22 BIF
9461 pub const Bif = packed struct {
9462 Rd: Register.Encoded,
9463 Rn: Register.Encoded,
9464 decoded10: u1 = 0b1,
9465 opcode: u5 = 0b00011,
9466 Rm: Register.Encoded,
9467 decoded21: u1 = 0b1,
9468 size: Size = .double,
9469 decoded24: u5 = 0b01110,
9470 U: std.builtin.Signedness = .unsigned,
9471 Q: Q,
9472 decoded31: u1 = 0b0,
9473 };
9474 };
9475
9476 /// Advanced SIMD modified immediate
9477 pub const SimdModifiedImmediate = packed union {
9478 group: @This().Group,
9479 movi: Movi,
9480 orr: Orr,
9481 fmov: Fmov,
9482 mvni: Mvni,
9483 bic: Bic,
9484
9485 pub const Group = packed struct {
9486 Rd: Register.Encoded,
9487 imm5: u5,
9488 decoded10: u1 = 0b1,
9489 o2: u1,
9490 cmode: u4,
9491 imm3: u3,
9492 decoded19: u10 = 0b0111100000,
9493 op: u1,
9494 Q: Q,
9495 decoded31: u1 = 0b0,
9496 };
9497
9498 /// C7.2.204 MOVI
9499 pub const Movi = packed struct {
9500 Rd: Register.Encoded,
9501 imm5: u5,
9502 decoded10: u1 = 0b1,
9503 o2: u1 = 0b0,
9504 cmode: u4,
9505 imm3: u3,
9506 decoded19: u10 = 0b0111100000,
9507 op: u1,
9508 Q: Q,
9509 decoded31: u1 = 0b0,
9510 };
9511
9512 /// C7.2.212 ORR (vector, immediate)
9513 pub const Orr = packed struct {
9514 Rd: Register.Encoded,
9515 imm5: u5,
9516 decoded10: u1 = 0b1,
9517 o2: u1 = 0b0,
9518 cmode0: u1 = 0b1,
9519 cmode: u3,
9520 imm3: u3,
9521 decoded19: u10 = 0b0111100000,
9522 op: u1 = 0b0,
9523 Q: Q,
9524 decoded31: u1 = 0b0,
9525 };
9526
9527 /// C7.2.129 FMOV (vector, immediate)
9528 pub const Fmov = packed struct {
9529 Rd: Register.Encoded,
9530 imm5: u5,
9531 decoded10: u1 = 0b1,
9532 o2: u1 = 0b1,
9533 cmode: u4 = 0b1111,
9534 imm3: u3,
9535 decoded19: u10 = 0b0111100000,
9536 op: u1 = 0b0,
9537 Q: Q,
9538 decoded31: u1 = 0b0,
9539 };
9540
9541 /// C7.2.208 MVNI
9542 pub const Mvni = packed struct {
9543 Rd: Register.Encoded,
9544 imm5: u5,
9545 decoded10: u1 = 0b1,
9546 o2: u1 = 0b0,
9547 cmode: u4,
9548 imm3: u3,
9549 decoded19: u10 = 0b0111100000,
9550 op: u1 = 0b1,
9551 Q: Q,
9552 decoded31: u1 = 0b0,
9553 };
9554
9555 /// C7.2.20 BIC (vector, immediate)
9556 pub const Bic = packed struct {
9557 Rd: Register.Encoded,
9558 imm5: u5,
9559 decoded10: u1 = 0b1,
9560 o2: u1 = 0b0,
9561 cmode0: u1 = 0b1,
9562 cmode: u3,
9563 imm3: u3,
9564 decoded19: u10 = 0b0111100000,
9565 op: u1 = 0b1,
9566 Q: Q,
9567 decoded31: u1 = 0b0,
9568 };
9569 };
9570
9571 /// Conversion between floating-point and integer
9572 pub const ConvertFloatInteger = packed union {
9573 group: @This().Group,
9574 fcvtns: Fcvtns,
9575 fcvtnu: Fcvtnu,
9576 scvtf: Scvtf,
9577 ucvtf: Ucvtf,
9578 fcvtas: Fcvtas,
9579 fcvtau: Fcvtau,
9580 fmov: Fmov,
9581 fcvtps: Fcvtps,
9582 fcvtpu: Fcvtpu,
9583 fcvtms: Fcvtms,
9584 fcvtmu: Fcvtmu,
9585 fcvtzs: Fcvtzs,
9586 fcvtzu: Fcvtzu,
9587 fjcvtzs: Fjcvtzs,
9588
9589 pub const Group = packed struct {
9590 Rd: Register.Encoded,
9591 Rn: Register.Encoded,
9592 decoded10: u6 = 0b000000,
9593 opcode: u3,
9594 rmode: u2,
9595 decoded21: u1 = 0b1,
9596 ptype: Ftype,
9597 decoded24: u5 = 0b11110,
9598 S: bool,
9599 decoded30: u1 = 0b0,
9600 sf: Register.IntegerSize,
9601 };
9602
9603 /// C7.2.81 FCVTNS (scalar)
9604 pub const Fcvtns = packed struct {
9605 Rd: Register.Encoded,
9606 Rn: Register.Encoded,
9607 decoded10: u6 = 0b000000,
9608 opcode: u3 = 0b000,
9609 rmode: Rmode = .n,
9610 decoded21: u1 = 0b1,
9611 ftype: Ftype,
9612 decoded24: u5 = 0b11110,
9613 S: bool = false,
9614 decoded30: u1 = 0b0,
9615 sf: Register.IntegerSize,
9616 };
9617
9618 /// C7.2.83 FCVTNU (scalar)
9619 pub const Fcvtnu = packed struct {
9620 Rd: Register.Encoded,
9621 Rn: Register.Encoded,
9622 decoded10: u6 = 0b000000,
9623 opcode: u3 = 0b001,
9624 rmode: Rmode = .n,
9625 decoded21: u1 = 0b1,
9626 ftype: Ftype,
9627 decoded24: u5 = 0b11110,
9628 S: bool = false,
9629 decoded30: u1 = 0b0,
9630 sf: Register.IntegerSize,
9631 };
9632
9633 /// C7.2.236 SCVTF (scalar, integer)
9634 pub const Scvtf = packed struct {
9635 Rd: Register.Encoded,
9636 Rn: Register.Encoded,
9637 decoded10: u6 = 0b000000,
9638 opcode: u3 = 0b010,
9639 rmode: Rmode = .n,
9640 decoded21: u1 = 0b1,
9641 ftype: Ftype,
9642 decoded24: u5 = 0b11110,
9643 S: bool = false,
9644 decoded30: u1 = 0b0,
9645 sf: Register.IntegerSize,
9646 };
9647
9648 /// C7.2.355 UCVTF (scalar, integer)
9649 pub const Ucvtf = packed struct {
9650 Rd: Register.Encoded,
9651 Rn: Register.Encoded,
9652 decoded10: u6 = 0b000000,
9653 opcode: u3 = 0b011,
9654 rmode: Rmode = .n,
9655 decoded21: u1 = 0b1,
9656 ftype: Ftype,
9657 decoded24: u5 = 0b11110,
9658 S: bool = false,
9659 decoded30: u1 = 0b0,
9660 sf: Register.IntegerSize,
9661 };
9662
9663 /// C7.2.71 FCVTAS (scalar)
9664 pub const Fcvtas = packed struct {
9665 Rd: Register.Encoded,
9666 Rn: Register.Encoded,
9667 decoded10: u6 = 0b000000,
9668 opcode: u3 = 0b100,
9669 rmode: Rmode = .n,
9670 decoded21: u1 = 0b1,
9671 ftype: Ftype,
9672 decoded24: u5 = 0b11110,
9673 S: bool = false,
9674 decoded30: u1 = 0b0,
9675 sf: Register.IntegerSize,
9676 };
9677
9678 /// C7.2.73 FCVTAU (scalar)
9679 pub const Fcvtau = packed struct {
9680 Rd: Register.Encoded,
9681 Rn: Register.Encoded,
9682 decoded10: u6 = 0b000000,
9683 opcode: u3 = 0b101,
9684 rmode: Rmode = .n,
9685 decoded21: u1 = 0b1,
9686 ftype: Ftype,
9687 decoded24: u5 = 0b11110,
9688 S: bool = false,
9689 decoded30: u1 = 0b0,
9690 sf: Register.IntegerSize,
9691 };
9692
9693 /// C7.2.131 FMOV (general)
9694 pub const Fmov = packed struct {
9695 Rd: Register.Encoded,
9696 Rn: Register.Encoded,
9697 decoded10: u6 = 0b000000,
9698 opcode: Opcode,
9699 rmode: Fmov.Rmode,
9700 decoded21: u1 = 0b1,
9701 ftype: Ftype,
9702 decoded24: u5 = 0b11110,
9703 S: bool = false,
9704 decoded30: u1 = 0b0,
9705 sf: Register.IntegerSize,
9706
9707 pub const Opcode = enum(u3) {
9708 float_to_integer = 0b110,
9709 integer_to_float = 0b111,
9710 _,
9711 };
9712
9713 pub const Rmode = enum(u2) {
9714 @"0" = 0b00,
9715 @"1" = 0b01,
9716 _,
9717 };
9718 };
9719
9720 /// C7.2.85 FCVTPS (scalar)
9721 pub const Fcvtps = packed struct {
9722 Rd: Register.Encoded,
9723 Rn: Register.Encoded,
9724 decoded10: u6 = 0b000000,
9725 opcode: u3 = 0b000,
9726 rmode: Rmode = .p,
9727 decoded21: u1 = 0b1,
9728 ftype: Ftype,
9729 decoded24: u5 = 0b11110,
9730 S: bool = false,
9731 decoded30: u1 = 0b0,
9732 sf: Register.IntegerSize,
9733 };
9734
9735 /// C7.2.87 FCVTPU (scalar)
9736 pub const Fcvtpu = packed struct {
9737 Rd: Register.Encoded,
9738 Rn: Register.Encoded,
9739 decoded10: u6 = 0b000000,
9740 opcode: u3 = 0b001,
9741 rmode: Rmode = .p,
9742 decoded21: u1 = 0b1,
9743 ftype: Ftype,
9744 decoded24: u5 = 0b11110,
9745 S: bool = false,
9746 decoded30: u1 = 0b0,
9747 sf: Register.IntegerSize,
9748 };
9749
9750 /// C7.2.76 FCVTMS (scalar)
9751 pub const Fcvtms = packed struct {
9752 Rd: Register.Encoded,
9753 Rn: Register.Encoded,
9754 decoded10: u6 = 0b000000,
9755 opcode: u3 = 0b000,
9756 rmode: Rmode = .m,
9757 decoded21: u1 = 0b1,
9758 ftype: Ftype,
9759 decoded24: u5 = 0b11110,
9760 S: bool = false,
9761 decoded30: u1 = 0b0,
9762 sf: Register.IntegerSize,
9763 };
9764
9765 /// C7.2.78 FCVTMU (scalar)
9766 pub const Fcvtmu = packed struct {
9767 Rd: Register.Encoded,
9768 Rn: Register.Encoded,
9769 decoded10: u6 = 0b000000,
9770 opcode: u3 = 0b001,
9771 rmode: Rmode = .m,
9772 decoded21: u1 = 0b1,
9773 ftype: Ftype,
9774 decoded24: u5 = 0b11110,
9775 S: bool = false,
9776 decoded30: u1 = 0b0,
9777 sf: Register.IntegerSize,
9778 };
9779
9780 /// C7.2.92 FCVTZS (scalar, integer)
9781 pub const Fcvtzs = packed struct {
9782 Rd: Register.Encoded,
9783 Rn: Register.Encoded,
9784 decoded10: u6 = 0b000000,
9785 opcode: u3 = 0b000,
9786 rmode: Rmode = .z,
9787 decoded21: u1 = 0b1,
9788 ftype: Ftype,
9789 decoded24: u5 = 0b11110,
9790 S: bool = false,
9791 decoded30: u1 = 0b0,
9792 sf: Register.IntegerSize,
9793 };
9794
9795 /// C7.2.96 FCVTZU (scalar, integer)
9796 pub const Fcvtzu = packed struct {
9797 Rd: Register.Encoded,
9798 Rn: Register.Encoded,
9799 decoded10: u6 = 0b000000,
9800 opcode: u3 = 0b001,
9801 rmode: Rmode = .z,
9802 decoded21: u1 = 0b1,
9803 ftype: Ftype,
9804 decoded24: u5 = 0b11110,
9805 S: bool = false,
9806 decoded30: u1 = 0b0,
9807 sf: Register.IntegerSize,
9808 };
9809
9810 /// C7.2.99 FJCVTZS
9811 pub const Fjcvtzs = packed struct {
9812 Rd: Register.Encoded,
9813 Rn: Register.Encoded,
9814 decoded10: u6 = 0b000000,
9815 opcode: u3 = 0b110,
9816 rmode: Rmode = .z,
9817 decoded21: u1 = 0b1,
9818 ftype: Ftype = .double,
9819 decoded24: u5 = 0b11110,
9820 S: bool = false,
9821 decoded30: u1 = 0b0,
9822 sf: Register.IntegerSize = .word,
9823 };
9824
9825 pub const Rmode = enum(u2) {
9826 /// to nearest
9827 n = 0b00,
9828 /// toward plus infinity
9829 p = 0b01,
9830 /// toward minus infinity
9831 m = 0b10,
9832 /// toward zero
9833 z = 0b11,
9834 };
9835 };
9836
9837 /// Floating-point data-processing (1 source)
9838 pub const FloatDataProcessingOneSource = packed union {
9839 group: @This().Group,
9840 fmov: Fmov,
9841 fabs: Fabs,
9842 fneg: Fneg,
9843 fsqrt: Fsqrt,
9844 fcvt: Fcvt,
9845 frintn: Frintn,
9846 frintp: Frintp,
9847 frintm: Frintm,
9848 frintz: Frintz,
9849 frinta: Frinta,
9850 frintx: Frintx,
9851 frinti: Frinti,
9852
9853 pub const Group = packed struct {
9854 Rd: Register.Encoded,
9855 Rn: Register.Encoded,
9856 decoded10: u5 = 0b10000,
9857 opcode: u6,
9858 decoded21: u1 = 0b1,
9859 ptype: Ftype,
9860 decoded24: u5 = 0b11110,
9861 S: bool,
9862 decoded30: u1 = 0b0,
9863 M: u1,
9864 };
9865
9866 /// C7.2.130 FMOV (register)
9867 pub const Fmov = packed struct {
9868 Rd: Register.Encoded,
9869 Rn: Register.Encoded,
9870 decoded10: u5 = 0b10000,
9871 opc: u2 = 0b00,
9872 decoded17: u4 = 0b0000,
9873 decoded21: u1 = 0b1,
9874 ftype: Ftype,
9875 decoded24: u5 = 0b11110,
9876 S: bool = false,
9877 decoded30: u1 = 0b0,
9878 M: u1 = 0b0,
9879 };
9880
9881 /// C7.2.46 FABS (scalar)
9882 pub const Fabs = packed struct {
9883 Rd: Register.Encoded,
9884 Rn: Register.Encoded,
9885 decoded10: u5 = 0b10000,
9886 opc: u2 = 0b01,
9887 decoded17: u4 = 0b0000,
9888 decoded21: u1 = 0b1,
9889 ftype: Ftype,
9890 decoded24: u5 = 0b11110,
9891 S: bool = false,
9892 decoded30: u1 = 0b0,
9893 M: u1 = 0b0,
9894 };
9895
9896 /// C7.2.140 FNEG (scalar)
9897 pub const Fneg = packed struct {
9898 Rd: Register.Encoded,
9899 Rn: Register.Encoded,
9900 decoded10: u5 = 0b10000,
9901 opc: u2 = 0b10,
9902 decoded17: u4 = 0b0000,
9903 decoded21: u1 = 0b1,
9904 ftype: Ftype,
9905 decoded24: u5 = 0b11110,
9906 S: bool = false,
9907 decoded30: u1 = 0b0,
9908 M: u1 = 0b0,
9909 };
9910
9911 /// C7.2.172 FSQRT (scalar)
9912 pub const Fsqrt = packed struct {
9913 Rd: Register.Encoded,
9914 Rn: Register.Encoded,
9915 decoded10: u5 = 0b10000,
9916 opc: u2 = 0b11,
9917 decoded17: u4 = 0b0000,
9918 decoded21: u1 = 0b1,
9919 ftype: Ftype,
9920 decoded24: u5 = 0b11110,
9921 S: bool = false,
9922 decoded30: u1 = 0b0,
9923 M: u1 = 0b0,
9924 };
9925
9926 /// C7.2.69 FCVT
9927 pub const Fcvt = packed struct {
9928 Rd: Register.Encoded,
9929 Rn: Register.Encoded,
9930 decoded10: u5 = 0b10000,
9931 opc: Ftype,
9932 decoded17: u4 = 0b0001,
9933 decoded21: u1 = 0b1,
9934 ftype: Ftype,
9935 decoded24: u5 = 0b11110,
9936 S: bool = false,
9937 decoded30: u1 = 0b0,
9938 M: u1 = 0b0,
9939 };
9940
9941 /// C7.2.162 FRINTN (scalar)
9942 pub const Frintn = packed struct {
9943 Rd: Register.Encoded,
9944 Rn: Register.Encoded,
9945 decoded10: u5 = 0b10000,
9946 rmode: Rmode = .n,
9947 decoded18: u3 = 0b001,
9948 decoded21: u1 = 0b1,
9949 ftype: Ftype,
9950 decoded24: u5 = 0b11110,
9951 S: bool = false,
9952 decoded30: u1 = 0b0,
9953 M: u1 = 0b0,
9954 };
9955
9956 /// C7.2.164 FRINTP (scalar)
9957 pub const Frintp = packed struct {
9958 Rd: Register.Encoded,
9959 Rn: Register.Encoded,
9960 decoded10: u5 = 0b10000,
9961 rmode: Rmode = .p,
9962 decoded18: u3 = 0b001,
9963 decoded21: u1 = 0b1,
9964 ftype: Ftype,
9965 decoded24: u5 = 0b11110,
9966 S: bool = false,
9967 decoded30: u1 = 0b0,
9968 M: u1 = 0b0,
9969 };
9970
9971 /// C7.2.160 FRINTM (scalar)
9972 pub const Frintm = packed struct {
9973 Rd: Register.Encoded,
9974 Rn: Register.Encoded,
9975 decoded10: u5 = 0b10000,
9976 rmode: Rmode = .m,
9977 decoded18: u3 = 0b001,
9978 decoded21: u1 = 0b1,
9979 ftype: Ftype,
9980 decoded24: u5 = 0b11110,
9981 S: bool = false,
9982 decoded30: u1 = 0b0,
9983 M: u1 = 0b0,
9984 };
9985
9986 /// C7.2.168 FRINTZ (scalar)
9987 pub const Frintz = packed struct {
9988 Rd: Register.Encoded,
9989 Rn: Register.Encoded,
9990 decoded10: u5 = 0b10000,
9991 rmode: Rmode = .z,
9992 decoded18: u3 = 0b001,
9993 decoded21: u1 = 0b1,
9994 ftype: Ftype,
9995 decoded24: u5 = 0b11110,
9996 S: bool = false,
9997 decoded30: u1 = 0b0,
9998 M: u1 = 0b0,
9999 };
10000
10001 /// C7.2.156 FRINTA (scalar)
10002 pub const Frinta = packed struct {
10003 Rd: Register.Encoded,
10004 Rn: Register.Encoded,
10005 decoded10: u5 = 0b10000,
10006 rmode: Rmode = .a,
10007 decoded18: u3 = 0b001,
10008 decoded21: u1 = 0b1,
10009 ftype: Ftype,
10010 decoded24: u5 = 0b11110,
10011 S: bool = false,
10012 decoded30: u1 = 0b0,
10013 M: u1 = 0b0,
10014 };
10015
10016 /// C7.2.166 FRINTX (scalar)
10017 pub const Frintx = packed struct {
10018 Rd: Register.Encoded,
10019 Rn: Register.Encoded,
10020 decoded10: u5 = 0b10000,
10021 rmode: Rmode = .x,
10022 decoded18: u3 = 0b001,
10023 decoded21: u1 = 0b1,
10024 ftype: Ftype,
10025 decoded24: u5 = 0b11110,
10026 S: bool = false,
10027 decoded30: u1 = 0b0,
10028 M: u1 = 0b0,
10029 };
10030
10031 /// C7.2.158 FRINTI (scalar)
10032 pub const Frinti = packed struct {
10033 Rd: Register.Encoded,
10034 Rn: Register.Encoded,
10035 decoded10: u5 = 0b10000,
10036 rmode: Rmode = .i,
10037 decoded18: u3 = 0b001,
10038 decoded21: u1 = 0b1,
10039 ftype: Ftype,
10040 decoded24: u5 = 0b11110,
10041 S: bool = false,
10042 decoded30: u1 = 0b0,
10043 M: u1 = 0b0,
10044 };
10045
10046 pub const Rmode = enum(u3) {
10047 /// to nearest with ties to even
10048 n = 0b000,
10049 /// toward plus infinity
10050 p = 0b001,
10051 /// toward minus infinity
10052 m = 0b010,
10053 /// toward zero
10054 z = 0b011,
10055 /// to nearest with ties to away
10056 a = 0b100,
10057 /// exact, using current rounding mode
10058 x = 0b110,
10059 /// using current rounding mode
10060 i = 0b111,
10061 _,
10062 };
10063 };
10064
10065 /// Floating-point compare
10066 pub const FloatCompare = packed union {
10067 group: @This().Group,
10068 fcmp: Fcmp,
10069 fcmpe: Fcmpe,
10070
10071 pub const Group = packed struct {
10072 opcode2: u5,
10073 Rn: Register.Encoded,
10074 decoded10: u4 = 0b1000,
10075 op: u2,
10076 Rm: Register.Encoded,
10077 decoded21: u1 = 0b1,
10078 ptype: Ftype,
10079 decoded24: u5 = 0b11110,
10080 S: bool,
10081 decoded30: u1 = 0b0,
10082 M: u1,
10083 };
10084
10085 /// C7.2.66 FCMP
10086 pub const Fcmp = packed struct {
10087 decoded0: u3 = 0b000,
10088 opc0: Opc0,
10089 opc1: u1 = 0b0,
10090 Rn: Register.Encoded,
10091 decoded10: u4 = 0b1000,
10092 op: u2 = 0b00,
10093 Rm: Register.Encoded,
10094 decoded21: u1 = 0b1,
10095 ftype: Ftype,
10096 decoded24: u5 = 0b11110,
10097 S: bool = false,
10098 decoded30: u1 = 0b0,
10099 M: u1 = 0b0,
10100 };
10101
10102 /// C7.2.67 FCMPE
10103 pub const Fcmpe = packed struct {
10104 decoded0: u3 = 0b000,
10105 opc0: Opc0,
10106 opc1: u1 = 0b1,
10107 Rn: Register.Encoded,
10108 decoded10: u4 = 0b1000,
10109 op: u2 = 0b00,
10110 Rm: Register.Encoded,
10111 decoded21: u1 = 0b1,
10112 ftype: Ftype,
10113 decoded24: u5 = 0b11110,
10114 S: bool = false,
10115 decoded30: u1 = 0b0,
10116 M: u1 = 0b0,
10117 };
10118
10119 pub const Opc0 = enum(u1) {
10120 register = 0b00,
10121 zero = 0b01,
10122 };
10123 };
10124
10125 /// Floating-point immediate
10126 pub const FloatImmediate = packed union {
10127 group: @This().Group,
10128 fmov: Fmov,
10129
10130 pub const Group = packed struct {
10131 Rd: Register.Encoded,
10132 imm5: u5,
10133 decoded10: u3 = 0b100,
10134 imm8: u8,
10135 decoded21: u1 = 0b1,
10136 ptype: Ftype,
10137 decoded24: u5 = 0b11110,
10138 S: bool,
10139 decoded30: u1 = 0b0,
10140 M: u1,
10141 };
10142
10143 /// C7.2.132 FMOV (scalar, immediate)
10144 pub const Fmov = packed struct {
10145 Rd: Register.Encoded,
10146 imm5: u5 = 0b00000,
10147 decoded10: u3 = 0b100,
10148 imm8: u8,
10149 decoded21: u1 = 0b1,
10150 ftype: Ftype,
10151 decoded24: u5 = 0b11110,
10152 S: bool = false,
10153 decoded30: u1 = 0b0,
10154 M: u1 = 0b0,
10155 };
10156 };
10157
10158 /// Floating-point data-processing (2 source)
10159 pub const FloatDataProcessingTwoSource = packed union {
10160 group: @This().Group,
10161 fmul: Fmul,
10162 fdiv: Fdiv,
10163 fadd: Fadd,
10164 fsub: Fsub,
10165 fmax: Fmax,
10166 fmin: Fmin,
10167 fmaxnm: Fmaxnm,
10168 fminnm: Fminnm,
10169 fnmul: Fnmul,
10170
10171 pub const Group = packed struct {
10172 Rd: Register.Encoded,
10173 Rn: Register.Encoded,
10174 decoded10: u2 = 0b10,
10175 opcode: Opcode,
10176 Rm: Register.Encoded,
10177 decoded21: u1 = 0b1,
10178 ptype: Ftype,
10179 decoded24: u5 = 0b11110,
10180 S: bool,
10181 decoded30: u1 = 0b0,
10182 M: u1,
10183 };
10184
10185 /// C7.2.136 FMUL (scalar)
10186 pub const Fmul = packed struct {
10187 Rd: Register.Encoded,
10188 Rn: Register.Encoded,
10189 decoded10: u2 = 0b10,
10190 opcode: Opcode = .fmul,
10191 Rm: Register.Encoded,
10192 decoded21: u1 = 0b1,
10193 ftype: Ftype,
10194 decoded24: u5 = 0b11110,
10195 S: bool = false,
10196 decoded30: u1 = 0b0,
10197 M: u1 = 0b0,
10198 };
10199
10200 /// C7.2.98 FDIV (scalar)
10201 pub const Fdiv = packed struct {
10202 Rd: Register.Encoded,
10203 Rn: Register.Encoded,
10204 decoded10: u2 = 0b10,
10205 opcode: Opcode = .fdiv,
10206 Rm: Register.Encoded,
10207 decoded21: u1 = 0b1,
10208 ftype: Ftype,
10209 decoded24: u5 = 0b11110,
10210 S: bool = false,
10211 decoded30: u1 = 0b0,
10212 M: u1 = 0b0,
10213 };
10214
10215 /// C7.2.50 FADD (scalar)
10216 pub const Fadd = packed struct {
10217 Rd: Register.Encoded,
10218 Rn: Register.Encoded,
10219 decoded10: u2 = 0b10,
10220 opcode: Opcode = .fadd,
10221 Rm: Register.Encoded,
10222 decoded21: u1 = 0b1,
10223 ftype: Ftype,
10224 decoded24: u5 = 0b11110,
10225 S: bool = false,
10226 decoded30: u1 = 0b0,
10227 M: u1 = 0b0,
10228 };
10229
10230 /// C7.2.174 FSUB (scalar)
10231 pub const Fsub = packed struct {
10232 Rd: Register.Encoded,
10233 Rn: Register.Encoded,
10234 decoded10: u2 = 0b10,
10235 opcode: Opcode = .fsub,
10236 Rm: Register.Encoded,
10237 decoded21: u1 = 0b1,
10238 ftype: Ftype,
10239 decoded24: u5 = 0b11110,
10240 S: bool = false,
10241 decoded30: u1 = 0b0,
10242 M: u1 = 0b0,
10243 };
10244
10245 /// C7.2.102 FMAX (scalar)
10246 pub const Fmax = packed struct {
10247 Rd: Register.Encoded,
10248 Rn: Register.Encoded,
10249 decoded10: u2 = 0b10,
10250 opcode: Opcode = .fmax,
10251 Rm: Register.Encoded,
10252 decoded21: u1 = 0b1,
10253 ftype: Ftype,
10254 decoded24: u5 = 0b11110,
10255 S: bool = false,
10256 decoded30: u1 = 0b0,
10257 M: u1 = 0b0,
10258 };
10259
10260 /// C7.2.112 FMIN (scalar)
10261 pub const Fmin = packed struct {
10262 Rd: Register.Encoded,
10263 Rn: Register.Encoded,
10264 decoded10: u2 = 0b10,
10265 opcode: Opcode = .fmin,
10266 Rm: Register.Encoded,
10267 decoded21: u1 = 0b1,
10268 ftype: Ftype,
10269 decoded24: u5 = 0b11110,
10270 S: bool = false,
10271 decoded30: u1 = 0b0,
10272 M: u1 = 0b0,
10273 };
10274
10275 /// C7.2.104 FMAXNM (scalar)
10276 pub const Fmaxnm = packed struct {
10277 Rd: Register.Encoded,
10278 Rn: Register.Encoded,
10279 decoded10: u2 = 0b10,
10280 opcode: Opcode = .fmaxnm,
10281 Rm: Register.Encoded,
10282 decoded21: u1 = 0b1,
10283 ftype: Ftype,
10284 decoded24: u5 = 0b11110,
10285 S: bool = false,
10286 decoded30: u1 = 0b0,
10287 M: u1 = 0b0,
10288 };
10289
10290 /// C7.2.114 FMINNM (scalar)
10291 pub const Fminnm = packed struct {
10292 Rd: Register.Encoded,
10293 Rn: Register.Encoded,
10294 decoded10: u2 = 0b10,
10295 opcode: Opcode = .fminnm,
10296 Rm: Register.Encoded,
10297 decoded21: u1 = 0b1,
10298 ftype: Ftype,
10299 decoded24: u5 = 0b11110,
10300 S: bool = false,
10301 decoded30: u1 = 0b0,
10302 M: u1 = 0b0,
10303 };
10304
10305 /// C7.2.143 FNMUL (scalar)
10306 pub const Fnmul = packed struct {
10307 Rd: Register.Encoded,
10308 Rn: Register.Encoded,
10309 decoded10: u2 = 0b10,
10310 opcode: Opcode = .fnmul,
10311 Rm: Register.Encoded,
10312 decoded21: u1 = 0b1,
10313 ftype: Ftype,
10314 decoded24: u5 = 0b11110,
10315 S: bool = false,
10316 decoded30: u1 = 0b0,
10317 M: u1 = 0b0,
10318 };
10319
10320 pub const Opcode = enum(u4) {
10321 fmul = 0b0000,
10322 fdiv = 0b0001,
10323 fadd = 0b0010,
10324 fsub = 0b0011,
10325 fmax = 0b0100,
10326 fmin = 0b0101,
10327 fmaxnm = 0b0110,
10328 fminnm = 0b0111,
10329 fnmul = 0b1000,
10330 _,
10331 };
10332 };
10333
10334 /// Floating-point conditional select
10335 pub const FloatConditionalSelect = packed union {
10336 group: @This().Group,
10337 fcsel: Fcsel,
10338
10339 pub const Group = packed struct {
10340 Rd: Register.Encoded,
10341 Rn: Register.Encoded,
10342 decoded10: u2 = 0b11,
10343 cond: ConditionCode,
10344 Rm: Register.Encoded,
10345 decoded21: u1 = 0b1,
10346 ptype: Ftype,
10347 decoded24: u5 = 0b11110,
10348 S: bool,
10349 decoded30: u1 = 0b0,
10350 M: u1,
10351 };
10352
10353 /// C7.2.68 FCSEL
10354 pub const Fcsel = packed struct {
10355 Rd: Register.Encoded,
10356 Rn: Register.Encoded,
10357 decoded10: u2 = 0b11,
10358 cond: ConditionCode,
10359 Rm: Register.Encoded,
10360 decoded21: u1 = 0b1,
10361 ftype: Ftype,
10362 decoded24: u5 = 0b11110,
10363 S: bool = false,
10364 decoded30: u1 = 0b0,
10365 M: u1 = 0b0,
10366 };
10367
10368 pub const Decoded = union(enum) {
10369 unallocated,
10370 fcsel: Fcsel,
10371 };
10372 pub fn decode(inst: @This()) @This().Decoded {
10373 return switch (inst.group.ptype) {
10374 .quad => .unallocated,
10375 .single, .double, .half => switch (inst.group.S) {
10376 true => .unallocated,
10377 false => switch (inst.group.M) {
10378 0b0 => .{ .fcsel = inst.fcsel },
10379 0b1 => .unallocated,
10380 },
10381 },
10382 };
10383 }
10384 };
10385
10386 /// Floating-point data-processing (3 source)
10387 pub const FloatDataProcessingThreeSource = packed union {
10388 group: @This().Group,
10389 fmadd: Fmadd,
10390 fmsub: Fmsub,
10391 fnmadd: Fnmadd,
10392 fnmsub: Fnmsub,
10393
10394 pub const Group = packed struct {
10395 Rd: Register.Encoded,
10396 Rn: Register.Encoded,
10397 Ra: Register.Encoded,
10398 o0: AddSubtractOp,
10399 Rm: Register.Encoded,
10400 o1: u1,
10401 ptype: Ftype,
10402 decoded24: u5 = 0b11111,
10403 S: bool,
10404 decoded30: u1 = 0b0,
10405 M: u1,
10406 };
10407
10408 /// C7.2.100 FMADD
10409 pub const Fmadd = packed struct {
10410 Rd: Register.Encoded,
10411 Rn: Register.Encoded,
10412 Ra: Register.Encoded,
10413 o0: AddSubtractOp = .add,
10414 Rm: Register.Encoded,
10415 o1: O1 = .fm,
10416 ftype: Ftype,
10417 decoded24: u5 = 0b11111,
10418 S: bool = false,
10419 decoded30: u1 = 0b0,
10420 M: u1 = 0b0,
10421 };
10422
10423 /// C7.2.133 FMSUB
10424 pub const Fmsub = packed struct {
10425 Rd: Register.Encoded,
10426 Rn: Register.Encoded,
10427 Ra: Register.Encoded,
10428 o0: AddSubtractOp = .sub,
8200 Rm: Register.Encoded,10429 Rm: Register.Encoded,
8201 o1: O1 = .fm,10430 o1: O1 = .fm,
8202 ftype: Ftype,10431 ftype: Ftype,
...@@ -8242,42 +10471,81 @@ pub const Instruction = packed union {...@@ -8242,42 +10471,81 @@ pub const Instruction = packed union {
8242 };10471 };
8243 };10472 };
824410473
8245 pub const Q = enum(u1) {
8246 double = 0b0,
8247 quad = 0b1,
8248 };
8249
8250 pub const Size = enum(u2) {10474 pub const Size = enum(u2) {
8251 byte = 0b00,10475 byte = 0b00,
8252 half = 0b01,10476 half = 0b01,
8253 single = 0b10,10477 single = 0b10,
8254 double = 0b11,10478 double = 0b11,
825510479
8256 pub fn toVectorSize(s: Size) Register.VectorSize {10480 pub fn toVectorSize(s: Size) Register.VectorSize {
8257 return switch (s) {10481 return switch (s) {
8258 .byte => .byte,10482 .byte => .byte,
8259 .half => .half,10483 .half => .half,
10484 .single => .single,
10485 .double => .double,
10486 };
10487 }
10488
10489 pub fn fromVectorSize(vs: Register.VectorSize) Size {
10490 return switch (vs) {
10491 else => unreachable,
10492 .byte => .byte,
10493 .half => .half,
10494 .single => .single,
10495 .double => .double,
10496 };
10497 }
10498 };
10499
10500 pub const Sz = enum(u1) {
10501 single = 0b0,
10502 double = 0b1,
10503
10504 pub fn toVectorSize(sz: Sz) Register.VectorSize {
10505 return switch (sz) {
10506 .single => .single,
10507 .double => .double,
10508 };
10509 }
10510
10511 pub fn fromVectorSize(vs: Register.VectorSize) Sz {
10512 return switch (vs) {
10513 else => unreachable,
10514 .single => .single,
10515 .double => .double,
10516 };
10517 }
10518 };
10519
10520 pub const Q = enum(u1) {
10521 double = 0b0,
10522 quad = 0b1,
10523 };
10524
10525 pub const Ftype = enum(u2) {
10526 single = 0b00,
10527 double = 0b01,
10528 quad = 0b10,
10529 half = 0b11,
10530
10531 pub fn toVectorSize(ftype: Ftype) Register.VectorSize {
10532 return switch (ftype) {
10533 _ => unreachable,
8260 .single => .single,10534 .single => .single,
8261 .double => .double,10535 .double => .double,
10536 .half => .half,
8262 };10537 };
8263 }10538 }
826410539
8265 pub fn fromVectorSize(vs: Register.VectorSize) Size {10540 pub fn fromVectorSize(vs: Register.VectorSize) Ftype {
8266 return switch (vs) {10541 return switch (vs) {
8267 .byte => .byte,10542 else => unreachable,
8268 .half => .half,
8269 .single => .single,10543 .single => .single,
8270 .double => .double,10544 .double => .double,
10545 .half => .half,
8271 };10546 };
8272 }10547 }
8273 };10548 };
8274
8275 pub const Ftype = enum(u2) {
8276 single = 0b00,
8277 double = 0b01,
8278 quad = 0b10,
8279 half = 0b11,
8280 };
8281 };10549 };
828210550
8283 pub const AddSubtractOp = enum(u1) {10551 pub const AddSubtractOp = enum(u1) {
...@@ -8320,6 +10588,33 @@ pub const Instruction = packed union {...@@ -8320,6 +10588,33 @@ pub const Instruction = packed union {
8320 };10588 };
8321 }10589 }
832210590
10591 /// C7.2.1 ABS (zero)
10592 pub fn abs(d: Register, n: Register) Instruction {
10593 switch (d.format) {
10594 else => unreachable,
10595 .scalar => |elem_size| {
10596 assert(elem_size == .double and elem_size == n.format.scalar);
10597 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
10598 .abs = .{
10599 .Rd = d.alias.encode(.{ .V = true }),
10600 .Rn = n.alias.encode(.{ .V = true }),
10601 .size = .fromVectorSize(elem_size),
10602 },
10603 } } };
10604 },
10605 .vector => |arrangement| {
10606 assert(arrangement != .@"1d" and n.format.vector == arrangement);
10607 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
10608 .abs = .{
10609 .Rd = d.alias.encode(.{ .V = true }),
10610 .Rn = n.alias.encode(.{ .V = true }),
10611 .size = arrangement.elemSize(),
10612 .Q = arrangement.size(),
10613 },
10614 } } };
10615 },
10616 }
10617 }
8323 /// C6.2.1 ADC10618 /// C6.2.1 ADC
8324 pub fn adc(d: Register, n: Register, m: Register) Instruction {10619 pub fn adc(d: Register, n: Register, m: Register) Instruction {
8325 const sf = d.format.integer;10620 const sf = d.format.integer;
...@@ -8867,6 +11162,45 @@ pub const Instruction = packed union {...@@ -8867,6 +11162,45 @@ pub const Instruction = packed union {
8867 } },11162 } },
8868 }11163 }
8869 }11164 }
11165 /// C7.2.22 BIF
11166 pub fn bif(d: Register, n: Register, m: Register) Instruction {
11167 const arrangement = d.format.vector;
11168 assert(arrangement.elemSize() == .byte and n.format.vector == arrangement and m.format.vector == arrangement);
11169 return .{ .data_processing_vector = .{ .simd_three_same = .{
11170 .bif = .{
11171 .Rd = d.alias.encode(.{ .V = true }),
11172 .Rn = n.alias.encode(.{ .V = true }),
11173 .Rm = m.alias.encode(.{ .V = true }),
11174 .Q = arrangement.size(),
11175 },
11176 } } };
11177 }
11178 /// C7.2.23 BIT
11179 pub fn bit(d: Register, n: Register, m: Register) Instruction {
11180 const arrangement = d.format.vector;
11181 assert(arrangement.elemSize() == .byte and n.format.vector == arrangement and m.format.vector == arrangement);
11182 return .{ .data_processing_vector = .{ .simd_three_same = .{
11183 .bit = .{
11184 .Rd = d.alias.encode(.{ .V = true }),
11185 .Rn = n.alias.encode(.{ .V = true }),
11186 .Rm = m.alias.encode(.{ .V = true }),
11187 .Q = arrangement.size(),
11188 },
11189 } } };
11190 }
11191 /// C7.2.24 BSL
11192 pub fn bsl(d: Register, n: Register, m: Register) Instruction {
11193 const arrangement = d.format.vector;
11194 assert(arrangement.elemSize() == .byte and n.format.vector == arrangement and m.format.vector == arrangement);
11195 return .{ .data_processing_vector = .{ .simd_three_same = .{
11196 .bsl = .{
11197 .Rd = d.alias.encode(.{ .V = true }),
11198 .Rn = n.alias.encode(.{ .V = true }),
11199 .Rm = m.alias.encode(.{ .V = true }),
11200 .Q = arrangement.size(),
11201 },
11202 } } };
11203 }
8870 /// C6.2.34 BL11204 /// C6.2.34 BL
8871 pub fn bl(label: i28) Instruction {11205 pub fn bl(label: i28) Instruction {
8872 return .{ .branch_exception_generating_system = .{ .unconditional_branch_immediate = .{11206 return .{ .branch_exception_generating_system = .{ .unconditional_branch_immediate = .{
...@@ -8999,6 +11333,151 @@ pub const Instruction = packed union {...@@ -8999,6 +11333,151 @@ pub const Instruction = packed union {
8999 },11333 },
9000 } } };11334 } } };
9001 }11335 }
11336 /// C7.2.28 CMEQ (zero)
11337 pub fn cmeq(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11338 switch (form) {
11339 .zero => switch (d.format) {
11340 else => unreachable,
11341 .scalar => |elem_size| {
11342 assert(elem_size == .double and elem_size == n.format.scalar);
11343 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11344 .cmeq = .{
11345 .Rd = d.alias.encode(.{ .V = true }),
11346 .Rn = n.alias.encode(.{ .V = true }),
11347 .size = .fromVectorSize(elem_size),
11348 },
11349 } } };
11350 },
11351 .vector => |arrangement| {
11352 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11353 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11354 .cmeq = .{
11355 .Rd = d.alias.encode(.{ .V = true }),
11356 .Rn = n.alias.encode(.{ .V = true }),
11357 .size = arrangement.elemSize(),
11358 .Q = arrangement.size(),
11359 },
11360 } } };
11361 },
11362 },
11363 }
11364 }
11365 /// C7.2.30 CMGE (zero)
11366 pub fn cmge(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11367 switch (form) {
11368 .zero => switch (d.format) {
11369 else => unreachable,
11370 .scalar => |elem_size| {
11371 assert(elem_size == .double and elem_size == n.format.scalar);
11372 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11373 .cmge = .{
11374 .Rd = d.alias.encode(.{ .V = true }),
11375 .Rn = n.alias.encode(.{ .V = true }),
11376 .size = .fromVectorSize(elem_size),
11377 },
11378 } } };
11379 },
11380 .vector => |arrangement| {
11381 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11382 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11383 .cmge = .{
11384 .Rd = d.alias.encode(.{ .V = true }),
11385 .Rn = n.alias.encode(.{ .V = true }),
11386 .size = arrangement.elemSize(),
11387 .Q = arrangement.size(),
11388 },
11389 } } };
11390 },
11391 },
11392 }
11393 }
11394 /// C7.2.32 CMGT (zero)
11395 pub fn cmgt(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11396 switch (form) {
11397 .zero => switch (d.format) {
11398 else => unreachable,
11399 .scalar => |elem_size| {
11400 assert(elem_size == .double and elem_size == n.format.scalar);
11401 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11402 .cmgt = .{
11403 .Rd = d.alias.encode(.{ .V = true }),
11404 .Rn = n.alias.encode(.{ .V = true }),
11405 .size = .fromVectorSize(elem_size),
11406 },
11407 } } };
11408 },
11409 .vector => |arrangement| {
11410 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11411 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11412 .cmgt = .{
11413 .Rd = d.alias.encode(.{ .V = true }),
11414 .Rn = n.alias.encode(.{ .V = true }),
11415 .size = arrangement.elemSize(),
11416 .Q = arrangement.size(),
11417 },
11418 } } };
11419 },
11420 },
11421 }
11422 }
11423 /// C7.2.35 CMLE (zero)
11424 pub fn cmle(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11425 switch (form) {
11426 .zero => switch (d.format) {
11427 else => unreachable,
11428 .scalar => |elem_size| {
11429 assert(elem_size == .double and elem_size == n.format.scalar);
11430 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11431 .cmle = .{
11432 .Rd = d.alias.encode(.{ .V = true }),
11433 .Rn = n.alias.encode(.{ .V = true }),
11434 .size = .fromVectorSize(elem_size),
11435 },
11436 } } };
11437 },
11438 .vector => |arrangement| {
11439 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11440 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11441 .cmle = .{
11442 .Rd = d.alias.encode(.{ .V = true }),
11443 .Rn = n.alias.encode(.{ .V = true }),
11444 .size = arrangement.elemSize(),
11445 .Q = arrangement.size(),
11446 },
11447 } } };
11448 },
11449 },
11450 }
11451 }
11452 /// C7.2.36 CMLT (zero)
11453 pub fn cmlt(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11454 switch (form) {
11455 .zero => switch (d.format) {
11456 else => unreachable,
11457 .scalar => |elem_size| {
11458 assert(elem_size == .double and elem_size == n.format.scalar);
11459 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11460 .cmlt = .{
11461 .Rd = d.alias.encode(.{ .V = true }),
11462 .Rn = n.alias.encode(.{ .V = true }),
11463 .size = .fromVectorSize(elem_size),
11464 },
11465 } } };
11466 },
11467 .vector => |arrangement| {
11468 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11469 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11470 .cmlt = .{
11471 .Rd = d.alias.encode(.{ .V = true }),
11472 .Rn = n.alias.encode(.{ .V = true }),
11473 .size = arrangement.elemSize(),
11474 .Q = arrangement.size(),
11475 },
11476 } } };
11477 },
11478 },
11479 }
11480 }
9002 /// C7.2.38 CNT11481 /// C7.2.38 CNT
9003 pub fn cnt(d: Register, n: Register) Instruction {11482 pub fn cnt(d: Register, n: Register) Instruction {
9004 const arrangement = d.format.vector;11483 const arrangement = d.format.vector;
...@@ -9094,6 +11573,57 @@ pub const Instruction = packed union {...@@ -9094,6 +11573,57 @@ pub const Instruction = packed union {
9094 },11573 },
9095 } } };11574 } } };
9096 }11575 }
11576 /// C7.2.39 DUP (element)
11577 /// C7.2.40 DUP (general)
11578 pub fn dup(d: Register, n: Register) Instruction {
11579 switch (d.format) {
11580 else => unreachable,
11581 .scalar => |elem_size| {
11582 assert(@intFromEnum(elem_size) <= @intFromEnum(Register.VectorSize.double) and elem_size == n.format.element.size);
11583 return .{ .data_processing_vector = .{ .simd_scalar_copy = .{
11584 .dup = .{
11585 .Rd = d.alias.encode(.{ .V = true }),
11586 .Rn = n.alias.encode(.{ .V = true }),
11587 .imm5 = @shlExact(@as(u5, n.format.element.index) << 1 | @as(u5, 0b1), @intFromEnum(elem_size)),
11588 },
11589 } } };
11590 },
11591 .vector => |arrangement| {
11592 assert(arrangement != .@"1d");
11593 const elem_size = arrangement.elemSize();
11594 switch (n.format) {
11595 else => unreachable,
11596 .element => |element| {
11597 assert(elem_size.toVectorSize() == element.size);
11598 return .{ .data_processing_vector = .{ .simd_copy = .{
11599 .dup = .{
11600 .Rd = d.alias.encode(.{ .V = true }),
11601 .Rn = n.alias.encode(.{ .V = true }),
11602 .imm4 = .element,
11603 .imm5 = @shlExact(@as(u5, element.index) << 1 | @as(u5, 0b1), @intFromEnum(elem_size)),
11604 .Q = arrangement.size(),
11605 },
11606 } } };
11607 },
11608 .integer => |sf| {
11609 assert(sf == @as(Register.IntegerSize, switch (elem_size) {
11610 .byte, .half, .single => .word,
11611 .double => .doubleword,
11612 }));
11613 return .{ .data_processing_vector = .{ .simd_copy = .{
11614 .dup = .{
11615 .Rd = d.alias.encode(.{ .V = true }),
11616 .Rn = n.alias.encode(.{}),
11617 .imm4 = .general,
11618 .imm5 = @shlExact(@as(u5, 0b1), @intFromEnum(elem_size)),
11619 .Q = arrangement.size(),
11620 },
11621 } } };
11622 },
11623 }
11624 },
11625 }
11626 }
9097 /// C6.2.118 EON (shifted register)11627 /// C6.2.118 EON (shifted register)
9098 pub fn eon(d: Register, n: Register, form: union(enum) {11628 pub fn eon(d: Register, n: Register, form: union(enum) {
9099 register: Register,11629 register: Register,
...@@ -9180,72 +11710,343 @@ pub const Instruction = packed union {...@@ -9180,72 +11710,343 @@ pub const Instruction = packed union {
9180 } },11710 } },
9181 }11711 }
9182 },11712 },
9183 .vector => |arrangement| {11713 .vector => |arrangement| {
9184 const m = form.register;11714 const m = form.register;
9185 assert(arrangement.elemSize() == .byte and n.format.vector == arrangement and m.format.vector == arrangement);11715 assert(arrangement.elemSize() == .byte and n.format.vector == arrangement and m.format.vector == arrangement);
9186 return .{ .data_processing_vector = .{ .simd_three_same = .{11716 return .{ .data_processing_vector = .{ .simd_three_same = .{
9187 .eor = .{11717 .eor = .{
9188 .Rd = d.alias.encode(.{ .V = true }),11718 .Rd = d.alias.encode(.{ .V = true }),
9189 .Rn = n.alias.encode(.{ .V = true }),11719 .Rn = n.alias.encode(.{ .V = true }),
9190 .Rm = m.alias.encode(.{ .V = true }),11720 .Rm = m.alias.encode(.{ .V = true }),
9191 .Q = arrangement.size(),11721 .Q = arrangement.size(),
11722 },
11723 } } };
11724 },
11725 }
11726 }
11727 /// C6.2.124 EXTR
11728 pub fn extr(d: Register, n: Register, m: Register, lsb: u6) Instruction {
11729 const sf = d.format.integer;
11730 assert(n.format.integer == sf and m.format.integer == sf);
11731 return .{ .data_processing_immediate = .{ .extract = .{
11732 .extr = .{
11733 .Rd = d.alias.encode(.{}),
11734 .Rn = n.alias.encode(.{}),
11735 .imms = switch (sf) {
11736 .word => @as(u5, @intCast(lsb)),
11737 .doubleword => @as(u6, @intCast(lsb)),
11738 },
11739 .Rm = m.alias.encode(.{}),
11740 .N = sf,
11741 .sf = sf,
11742 },
11743 } } };
11744 }
11745 /// C7.2.45 FABS (vector)
11746 /// C7.2.46 FABS (scalar)
11747 pub fn fabs(d: Register, n: Register) Instruction {
11748 switch (d.format) {
11749 else => unreachable,
11750 .vector => |arrangement| {
11751 assert(n.format.vector == arrangement);
11752 switch (arrangement.elemSize()) {
11753 else => unreachable,
11754 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
11755 .fabs = .{
11756 .Rd = d.alias.encode(.{ .V = true }),
11757 .Rn = n.alias.encode(.{ .V = true }),
11758 .Q = arrangement.size(),
11759 },
11760 } } },
11761 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11762 .fabs = .{
11763 .Rd = d.alias.encode(.{ .V = true }),
11764 .Rn = n.alias.encode(.{ .V = true }),
11765 .sz = arrangement.elemSz(),
11766 .Q = arrangement.size(),
11767 },
11768 } } },
11769 }
11770 },
11771 .scalar => |ftype| {
11772 assert(n.format.scalar == ftype);
11773 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
11774 .fabs = .{
11775 .Rd = d.alias.encode(.{ .V = true }),
11776 .Rn = n.alias.encode(.{ .V = true }),
11777 .ftype = .fromVectorSize(ftype),
11778 },
11779 } } };
11780 },
11781 }
11782 }
11783 /// C7.2.50 FADD (scalar)
11784 pub fn fadd(d: Register, n: Register, m: Register) Instruction {
11785 const ftype = d.format.scalar;
11786 assert(n.format.scalar == ftype and m.format.scalar == ftype);
11787 return .{ .data_processing_vector = .{ .float_data_processing_two_source = .{
11788 .fadd = .{
11789 .Rd = d.alias.encode(.{ .V = true }),
11790 .Rn = n.alias.encode(.{ .V = true }),
11791 .Rm = m.alias.encode(.{ .V = true }),
11792 .ftype = .fromVectorSize(ftype),
11793 },
11794 } } };
11795 }
11796 /// C7.2.57 FCMEQ (zero)
11797 pub fn fcmeq(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11798 switch (form) {
11799 .zero => switch (d.format) {
11800 else => unreachable,
11801 .scalar => |ftype| switch (n.format) {
11802 else => unreachable,
11803 .scalar => |n_scalar| {
11804 assert(n_scalar == ftype);
11805 switch (ftype) {
11806 else => unreachable,
11807 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
11808 .fcmeq = .{
11809 .Rd = d.alias.encode(.{ .V = true }),
11810 .Rn = n.alias.encode(.{ .V = true }),
11811 },
11812 } } },
11813 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11814 .fcmeq = .{
11815 .Rd = d.alias.encode(.{ .V = true }),
11816 .Rn = n.alias.encode(.{ .V = true }),
11817 .sz = .fromVectorSize(ftype),
11818 },
11819 } } },
11820 }
11821 },
11822 },
11823 .vector => |arrangement| {
11824 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11825 switch (arrangement.elemSize()) {
11826 else => unreachable,
11827 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
11828 .fcmeq = .{
11829 .Rd = d.alias.encode(.{ .V = true }),
11830 .Rn = n.alias.encode(.{ .V = true }),
11831 .Q = arrangement.size(),
11832 },
11833 } } },
11834 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11835 .fcmeq = .{
11836 .Rd = d.alias.encode(.{ .V = true }),
11837 .Rn = n.alias.encode(.{ .V = true }),
11838 .sz = arrangement.elemSz(),
11839 .Q = arrangement.size(),
11840 },
11841 } } },
11842 }
11843 },
11844 },
11845 }
11846 }
11847 /// C7.2.59 FCMGE (zero)
11848 pub fn fcmge(d: Register, n: Register, form: union(enum) { zero }) Instruction {
11849 switch (form) {
11850 .zero => switch (d.format) {
11851 else => unreachable,
11852 .scalar => |ftype| switch (n.format) {
11853 else => unreachable,
11854 .scalar => |n_scalar| {
11855 assert(n_scalar == ftype);
11856 switch (ftype) {
11857 else => unreachable,
11858 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
11859 .fcmge = .{
11860 .Rd = d.alias.encode(.{ .V = true }),
11861 .Rn = n.alias.encode(.{ .V = true }),
11862 },
11863 } } },
11864 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11865 .fcmge = .{
11866 .Rd = d.alias.encode(.{ .V = true }),
11867 .Rn = n.alias.encode(.{ .V = true }),
11868 .sz = .fromVectorSize(ftype),
11869 },
11870 } } },
11871 }
9192 },11872 },
9193 } } };11873 },
11874 .vector => |arrangement| {
11875 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11876 switch (arrangement.elemSize()) {
11877 else => unreachable,
11878 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
11879 .fcmge = .{
11880 .Rd = d.alias.encode(.{ .V = true }),
11881 .Rn = n.alias.encode(.{ .V = true }),
11882 .Q = arrangement.size(),
11883 },
11884 } } },
11885 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11886 .fcmge = .{
11887 .Rd = d.alias.encode(.{ .V = true }),
11888 .Rn = n.alias.encode(.{ .V = true }),
11889 .sz = arrangement.elemSz(),
11890 .Q = arrangement.size(),
11891 },
11892 } } },
11893 }
11894 },
9194 },11895 },
9195 }11896 }
9196 }11897 }
9197 /// C6.2.124 EXTR11898 /// C7.2.61 FCMGT (zero)
9198 pub fn extr(d: Register, n: Register, m: Register, lsb: u6) Instruction {11899 pub fn fcmgt(d: Register, n: Register, form: union(enum) { zero }) Instruction {
9199 const sf = d.format.integer;11900 switch (form) {
9200 assert(n.format.integer == sf and m.format.integer == sf);11901 .zero => switch (d.format) {
9201 return .{ .data_processing_immediate = .{ .extract = .{11902 else => unreachable,
9202 .extr = .{11903 .scalar => |ftype| switch (n.format) {
9203 .Rd = d.alias.encode(.{}),11904 else => unreachable,
9204 .Rn = n.alias.encode(.{}),11905 .scalar => |n_scalar| {
9205 .imms = switch (sf) {11906 assert(n_scalar == ftype);
9206 .word => @as(u5, @intCast(lsb)),11907 switch (ftype) {
9207 .doubleword => @as(u6, @intCast(lsb)),11908 else => unreachable,
11909 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
11910 .fcmgt = .{
11911 .Rd = d.alias.encode(.{ .V = true }),
11912 .Rn = n.alias.encode(.{ .V = true }),
11913 },
11914 } } },
11915 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11916 .fcmgt = .{
11917 .Rd = d.alias.encode(.{ .V = true }),
11918 .Rn = n.alias.encode(.{ .V = true }),
11919 .sz = .fromVectorSize(ftype),
11920 },
11921 } } },
11922 }
11923 },
11924 },
11925 .vector => |arrangement| {
11926 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11927 switch (arrangement.elemSize()) {
11928 else => unreachable,
11929 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
11930 .fcmgt = .{
11931 .Rd = d.alias.encode(.{ .V = true }),
11932 .Rn = n.alias.encode(.{ .V = true }),
11933 .Q = arrangement.size(),
11934 },
11935 } } },
11936 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11937 .fcmgt = .{
11938 .Rd = d.alias.encode(.{ .V = true }),
11939 .Rn = n.alias.encode(.{ .V = true }),
11940 .sz = arrangement.elemSz(),
11941 .Q = arrangement.size(),
11942 },
11943 } } },
11944 }
9208 },11945 },
9209 .Rm = m.alias.encode(.{}),
9210 .N = sf,
9211 .sf = sf,
9212 },11946 },
9213 } } };11947 }
9214 }11948 }
9215 /// C7.2.46 FABS (scalar)11949 /// C7.2.64 FCMLE (zero)
9216 pub fn fabs(d: Register, n: Register) Instruction {11950 pub fn fcmle(d: Register, n: Register, form: union(enum) { zero }) Instruction {
9217 const ftype = d.format.scalar;11951 switch (form) {
9218 assert(n.format.scalar == ftype);11952 .zero => switch (d.format) {
9219 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{11953 else => unreachable,
9220 .fabs = .{11954 .scalar => |ftype| switch (n.format) {
9221 .Rd = d.alias.encode(.{ .V = true }),
9222 .Rn = n.alias.encode(.{ .V = true }),
9223 .ftype = switch (ftype) {
9224 else => unreachable,11955 else => unreachable,
9225 .single => .single,11956 .scalar => |n_scalar| {
9226 .double => .double,11957 assert(n_scalar == ftype);
9227 .half => .half,11958 switch (ftype) {
11959 else => unreachable,
11960 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
11961 .fcmle = .{
11962 .Rd = d.alias.encode(.{ .V = true }),
11963 .Rn = n.alias.encode(.{ .V = true }),
11964 },
11965 } } },
11966 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
11967 .fcmle = .{
11968 .Rd = d.alias.encode(.{ .V = true }),
11969 .Rn = n.alias.encode(.{ .V = true }),
11970 .sz = .fromVectorSize(ftype),
11971 },
11972 } } },
11973 }
11974 },
11975 },
11976 .vector => |arrangement| {
11977 assert(arrangement != .@"1d" and n.format.vector == arrangement);
11978 switch (arrangement.elemSize()) {
11979 else => unreachable,
11980 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
11981 .fcmle = .{
11982 .Rd = d.alias.encode(.{ .V = true }),
11983 .Rn = n.alias.encode(.{ .V = true }),
11984 .Q = arrangement.size(),
11985 },
11986 } } },
11987 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
11988 .fcmle = .{
11989 .Rd = d.alias.encode(.{ .V = true }),
11990 .Rn = n.alias.encode(.{ .V = true }),
11991 .sz = arrangement.elemSz(),
11992 .Q = arrangement.size(),
11993 },
11994 } } },
11995 }
9228 },11996 },
9229 },11997 },
9230 } } };11998 }
9231 }11999 }
9232 /// C7.2.50 FADD (scalar)12000 /// C7.2.65 FCMLT (zero)
9233 pub fn fadd(d: Register, n: Register, m: Register) Instruction {12001 pub fn fcmlt(d: Register, n: Register, form: union(enum) { zero }) Instruction {
9234 const ftype = d.format.scalar;12002 switch (form) {
9235 assert(n.format.scalar == ftype and m.format.scalar == ftype);12003 .zero => switch (d.format) {
9236 return .{ .data_processing_vector = .{ .float_data_processing_two_source = .{12004 else => unreachable,
9237 .fadd = .{12005 .scalar => |ftype| switch (n.format) {
9238 .Rd = d.alias.encode(.{ .V = true }),
9239 .Rn = n.alias.encode(.{ .V = true }),
9240 .Rm = m.alias.encode(.{ .V = true }),
9241 .ftype = switch (ftype) {
9242 else => unreachable,12006 else => unreachable,
9243 .single => .single,12007 .scalar => |n_scalar| {
9244 .double => .double,12008 assert(n_scalar == ftype);
9245 .half => .half,12009 switch (ftype) {
12010 else => unreachable,
12011 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12012 .fcmlt = .{
12013 .Rd = d.alias.encode(.{ .V = true }),
12014 .Rn = n.alias.encode(.{ .V = true }),
12015 },
12016 } } },
12017 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12018 .fcmlt = .{
12019 .Rd = d.alias.encode(.{ .V = true }),
12020 .Rn = n.alias.encode(.{ .V = true }),
12021 .sz = .fromVectorSize(ftype),
12022 },
12023 } } },
12024 }
12025 },
12026 },
12027 .vector => |arrangement| {
12028 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12029 switch (arrangement.elemSize()) {
12030 else => unreachable,
12031 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12032 .fcmlt = .{
12033 .Rd = d.alias.encode(.{ .V = true }),
12034 .Rn = n.alias.encode(.{ .V = true }),
12035 .Q = arrangement.size(),
12036 },
12037 } } },
12038 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12039 .fcmlt = .{
12040 .Rd = d.alias.encode(.{ .V = true }),
12041 .Rn = n.alias.encode(.{ .V = true }),
12042 .sz = arrangement.elemSz(),
12043 .Q = arrangement.size(),
12044 },
12045 } } },
12046 }
9246 },12047 },
9247 },12048 },
9248 } } };12049 }
9249 }12050 }
9250 /// C7.2.66 FCMP12051 /// C7.2.66 FCMP
9251 pub fn fcmp(n: Register, form: union(enum) { register: Register, zero }) Instruction {12052 pub fn fcmp(n: Register, form: union(enum) { register: Register, zero }) Instruction {
...@@ -9258,12 +12059,7 @@ pub const Instruction = packed union {...@@ -9258,12 +12059,7 @@ pub const Instruction = packed union {
9258 .opc0 = .register,12059 .opc0 = .register,
9259 .Rn = n.alias.encode(.{ .V = true }),12060 .Rn = n.alias.encode(.{ .V = true }),
9260 .Rm = m.alias.encode(.{ .V = true }),12061 .Rm = m.alias.encode(.{ .V = true }),
9261 .ftype = switch (ftype) {12062 .ftype = .fromVectorSize(ftype),
9262 else => unreachable,
9263 .single => .single,
9264 .double => .double,
9265 .half => .half,
9266 },
9267 },12063 },
9268 } } };12064 } } };
9269 },12065 },
...@@ -9272,12 +12068,7 @@ pub const Instruction = packed union {...@@ -9272,12 +12068,7 @@ pub const Instruction = packed union {
9272 .opc0 = .register,12068 .opc0 = .register,
9273 .Rn = n.alias.encode(.{ .V = true }),12069 .Rn = n.alias.encode(.{ .V = true }),
9274 .Rm = @enumFromInt(0b00000),12070 .Rm = @enumFromInt(0b00000),
9275 .ftype = switch (ftype) {12071 .ftype = .fromVectorSize(ftype),
9276 else => unreachable,
9277 .single => .single,
9278 .double => .double,
9279 .half => .half,
9280 },
9281 },12072 },
9282 } } },12073 } } },
9283 }12074 }
...@@ -9293,12 +12084,7 @@ pub const Instruction = packed union {...@@ -9293,12 +12084,7 @@ pub const Instruction = packed union {
9293 .opc0 = .zero,12084 .opc0 = .zero,
9294 .Rn = n.alias.encode(.{ .V = true }),12085 .Rn = n.alias.encode(.{ .V = true }),
9295 .Rm = m.alias.encode(.{ .V = true }),12086 .Rm = m.alias.encode(.{ .V = true }),
9296 .ftype = switch (ftype) {12087 .ftype = .fromVectorSize(ftype),
9297 else => unreachable,
9298 .single => .single,
9299 .double => .double,
9300 .half => .half,
9301 },
9302 },12088 },
9303 } } };12089 } } };
9304 },12090 },
...@@ -9307,16 +12093,25 @@ pub const Instruction = packed union {...@@ -9307,16 +12093,25 @@ pub const Instruction = packed union {
9307 .opc0 = .zero,12093 .opc0 = .zero,
9308 .Rn = n.alias.encode(.{ .V = true }),12094 .Rn = n.alias.encode(.{ .V = true }),
9309 .Rm = @enumFromInt(0b00000),12095 .Rm = @enumFromInt(0b00000),
9310 .ftype = switch (ftype) {12096 .ftype = .fromVectorSize(ftype),
9311 else => unreachable,
9312 .single => .single,
9313 .double => .double,
9314 .half => .half,
9315 },
9316 },12097 },
9317 } } },12098 } } },
9318 }12099 }
9319 }12100 }
12101 /// C7.2.68 FCSEL
12102 pub fn fcsel(d: Register, n: Register, m: Register, cond: ConditionCode) Instruction {
12103 const ftype = d.format.scalar;
12104 assert(n.format.scalar == ftype and m.format.scalar == ftype);
12105 return .{ .data_processing_vector = .{ .float_conditional_select = .{
12106 .fcsel = .{
12107 .Rd = d.alias.encode(.{ .V = true }),
12108 .Rn = n.alias.encode(.{ .V = true }),
12109 .cond = cond,
12110 .Rm = m.alias.encode(.{ .V = true }),
12111 .ftype = .fromVectorSize(ftype),
12112 },
12113 } } };
12114 }
9320 /// C7.2.69 FCVT12115 /// C7.2.69 FCVT
9321 pub fn fcvt(d: Register, n: Register) Instruction {12116 pub fn fcvt(d: Register, n: Register) Instruction {
9322 assert(d.format.scalar != n.format.scalar);12117 assert(d.format.scalar != n.format.scalar);
...@@ -9330,174 +12125,589 @@ pub const Instruction = packed union {...@@ -9330,174 +12125,589 @@ pub const Instruction = packed union {
9330 .double => .double,12125 .double => .double,
9331 .half => .half,12126 .half => .half,
9332 },12127 },
9333 .ftype = switch (n.format.scalar) {12128 .ftype = .fromVectorSize(n.format.scalar),
9334 else => unreachable,
9335 .single => .single,
9336 .double => .double,
9337 .half => .half,
9338 },
9339 },12129 },
9340 } } };12130 } } };
9341 }12131 }
12132 /// C7.2.70 FCVTAS (vector)
9342 /// C7.2.71 FCVTAS (scalar)12133 /// C7.2.71 FCVTAS (scalar)
9343 pub fn fcvtas(d: Register, n: Register) Instruction {12134 pub fn fcvtas(d: Register, n: Register) Instruction {
9344 return .{ .data_processing_vector = .{ .convert_float_integer = .{12135 switch (d.format) {
9345 .fcvtas = .{12136 else => unreachable,
9346 .Rd = d.alias.encode(.{}),12137 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9347 .Rn = n.alias.encode(.{ .V = true }),12138 .fcvtas = .{
9348 .ftype = switch (n.format.scalar) {12139 .Rd = d.alias.encode(.{}),
9349 else => unreachable,12140 .Rn = n.alias.encode(.{ .V = true }),
9350 .single => .single,12141 .ftype = .fromVectorSize(n.format.scalar),
9351 .double => .double,12142 .sf = sf,
9352 .half => .half,12143 },
12144 } } },
12145 .scalar => |elem_size| switch (n.format) {
12146 else => unreachable,
12147 .scalar => |ftype| {
12148 assert(ftype == elem_size);
12149 switch (elem_size) {
12150 else => unreachable,
12151 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12152 .fcvtas = .{
12153 .Rd = d.alias.encode(.{ .V = true }),
12154 .Rn = n.alias.encode(.{ .V = true }),
12155 },
12156 } } },
12157 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12158 .fcvtas = .{
12159 .Rd = d.alias.encode(.{ .V = true }),
12160 .Rn = n.alias.encode(.{ .V = true }),
12161 .sz = .fromVectorSize(elem_size),
12162 },
12163 } } },
12164 }
9353 },12165 },
9354 .sf = d.format.integer,
9355 },12166 },
9356 } } };12167 .vector => |arrangement| {
12168 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12169 switch (arrangement.elemSize()) {
12170 else => unreachable,
12171 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12172 .fcvtas = .{
12173 .Rd = d.alias.encode(.{ .V = true }),
12174 .Rn = n.alias.encode(.{ .V = true }),
12175 .Q = arrangement.size(),
12176 },
12177 } } },
12178 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12179 .fcvtas = .{
12180 .Rd = d.alias.encode(.{ .V = true }),
12181 .Rn = n.alias.encode(.{ .V = true }),
12182 .sz = arrangement.elemSz(),
12183 .Q = arrangement.size(),
12184 },
12185 } } },
12186 }
12187 },
12188 }
9357 }12189 }
12190 /// C7.2.72 FCVTAU (vector)
9358 /// C7.2.73 FCVTAU (scalar)12191 /// C7.2.73 FCVTAU (scalar)
9359 pub fn fcvtau(d: Register, n: Register) Instruction {12192 pub fn fcvtau(d: Register, n: Register) Instruction {
9360 return .{ .data_processing_vector = .{ .convert_float_integer = .{12193 switch (d.format) {
9361 .fcvtau = .{12194 else => unreachable,
9362 .Rd = d.alias.encode(.{}),12195 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9363 .Rn = n.alias.encode(.{ .V = true }),12196 .fcvtau = .{
9364 .ftype = switch (n.format.scalar) {12197 .Rd = d.alias.encode(.{}),
9365 else => unreachable,12198 .Rn = n.alias.encode(.{ .V = true }),
9366 .single => .single,12199 .ftype = .fromVectorSize(n.format.scalar),
9367 .double => .double,12200 .sf = sf,
9368 .half => .half,12201 },
12202 } } },
12203 .scalar => |elem_size| switch (n.format) {
12204 else => unreachable,
12205 .scalar => |ftype| {
12206 assert(ftype == elem_size);
12207 switch (elem_size) {
12208 else => unreachable,
12209 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12210 .fcvtau = .{
12211 .Rd = d.alias.encode(.{ .V = true }),
12212 .Rn = n.alias.encode(.{ .V = true }),
12213 },
12214 } } },
12215 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12216 .fcvtau = .{
12217 .Rd = d.alias.encode(.{ .V = true }),
12218 .Rn = n.alias.encode(.{ .V = true }),
12219 .sz = .fromVectorSize(elem_size),
12220 },
12221 } } },
12222 }
9369 },12223 },
9370 .sf = d.format.integer,
9371 },12224 },
9372 } } };12225 .vector => |arrangement| {
12226 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12227 switch (arrangement.elemSize()) {
12228 else => unreachable,
12229 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12230 .fcvtau = .{
12231 .Rd = d.alias.encode(.{ .V = true }),
12232 .Rn = n.alias.encode(.{ .V = true }),
12233 .Q = arrangement.size(),
12234 },
12235 } } },
12236 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12237 .fcvtau = .{
12238 .Rd = d.alias.encode(.{ .V = true }),
12239 .Rn = n.alias.encode(.{ .V = true }),
12240 .sz = arrangement.elemSz(),
12241 .Q = arrangement.size(),
12242 },
12243 } } },
12244 }
12245 },
12246 }
9373 }12247 }
12248 /// C7.2.75 FCVTMS (vector)
9374 /// C7.2.76 FCVTMS (scalar)12249 /// C7.2.76 FCVTMS (scalar)
9375 pub fn fcvtms(d: Register, n: Register) Instruction {12250 pub fn fcvtms(d: Register, n: Register) Instruction {
9376 return .{ .data_processing_vector = .{ .convert_float_integer = .{12251 switch (d.format) {
9377 .fcvtms = .{12252 else => unreachable,
9378 .Rd = d.alias.encode(.{}),12253 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9379 .Rn = n.alias.encode(.{ .V = true }),12254 .fcvtms = .{
9380 .ftype = switch (n.format.scalar) {12255 .Rd = d.alias.encode(.{}),
9381 else => unreachable,12256 .Rn = n.alias.encode(.{ .V = true }),
9382 .single => .single,12257 .ftype = .fromVectorSize(n.format.scalar),
9383 .double => .double,12258 .sf = sf,
9384 .half => .half,12259 },
12260 } } },
12261 .scalar => |elem_size| switch (n.format) {
12262 else => unreachable,
12263 .scalar => |ftype| {
12264 assert(ftype == elem_size);
12265 switch (elem_size) {
12266 else => unreachable,
12267 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12268 .fcvtms = .{
12269 .Rd = d.alias.encode(.{ .V = true }),
12270 .Rn = n.alias.encode(.{ .V = true }),
12271 },
12272 } } },
12273 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12274 .fcvtms = .{
12275 .Rd = d.alias.encode(.{ .V = true }),
12276 .Rn = n.alias.encode(.{ .V = true }),
12277 .sz = .fromVectorSize(elem_size),
12278 },
12279 } } },
12280 }
9385 },12281 },
9386 .sf = d.format.integer,
9387 },12282 },
9388 } } };12283 .vector => |arrangement| {
12284 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12285 switch (arrangement.elemSize()) {
12286 else => unreachable,
12287 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12288 .fcvtms = .{
12289 .Rd = d.alias.encode(.{ .V = true }),
12290 .Rn = n.alias.encode(.{ .V = true }),
12291 .Q = arrangement.size(),
12292 },
12293 } } },
12294 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12295 .fcvtms = .{
12296 .Rd = d.alias.encode(.{ .V = true }),
12297 .Rn = n.alias.encode(.{ .V = true }),
12298 .sz = arrangement.elemSz(),
12299 .Q = arrangement.size(),
12300 },
12301 } } },
12302 }
12303 },
12304 }
9389 }12305 }
12306 /// C7.2.77 FCVTMU (vector)
9390 /// C7.2.78 FCVTMU (scalar)12307 /// C7.2.78 FCVTMU (scalar)
9391 pub fn fcvtmu(d: Register, n: Register) Instruction {12308 pub fn fcvtmu(d: Register, n: Register) Instruction {
9392 return .{ .data_processing_vector = .{ .convert_float_integer = .{12309 switch (d.format) {
9393 .fcvtmu = .{12310 else => unreachable,
9394 .Rd = d.alias.encode(.{}),12311 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9395 .Rn = n.alias.encode(.{ .V = true }),12312 .fcvtmu = .{
9396 .ftype = switch (n.format.scalar) {12313 .Rd = d.alias.encode(.{}),
9397 else => unreachable,12314 .Rn = n.alias.encode(.{ .V = true }),
9398 .single => .single,12315 .ftype = .fromVectorSize(n.format.scalar),
9399 .double => .double,12316 .sf = sf,
9400 .half => .half,12317 },
12318 } } },
12319 .scalar => |elem_size| switch (n.format) {
12320 else => unreachable,
12321 .scalar => |ftype| {
12322 assert(ftype == elem_size);
12323 switch (elem_size) {
12324 else => unreachable,
12325 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12326 .fcvtmu = .{
12327 .Rd = d.alias.encode(.{ .V = true }),
12328 .Rn = n.alias.encode(.{ .V = true }),
12329 },
12330 } } },
12331 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12332 .fcvtmu = .{
12333 .Rd = d.alias.encode(.{ .V = true }),
12334 .Rn = n.alias.encode(.{ .V = true }),
12335 .sz = .fromVectorSize(elem_size),
12336 },
12337 } } },
12338 }
9401 },12339 },
9402 .sf = d.format.integer,
9403 },12340 },
9404 } } };12341 .vector => |arrangement| {
12342 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12343 switch (arrangement.elemSize()) {
12344 else => unreachable,
12345 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12346 .fcvtmu = .{
12347 .Rd = d.alias.encode(.{ .V = true }),
12348 .Rn = n.alias.encode(.{ .V = true }),
12349 .Q = arrangement.size(),
12350 },
12351 } } },
12352 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12353 .fcvtmu = .{
12354 .Rd = d.alias.encode(.{ .V = true }),
12355 .Rn = n.alias.encode(.{ .V = true }),
12356 .sz = arrangement.elemSz(),
12357 .Q = arrangement.size(),
12358 },
12359 } } },
12360 }
12361 },
12362 }
9405 }12363 }
12364 /// C7.2.80 FCVTNS (vector)
9406 /// C7.2.81 FCVTNS (scalar)12365 /// C7.2.81 FCVTNS (scalar)
9407 pub fn fcvtns(d: Register, n: Register) Instruction {12366 pub fn fcvtns(d: Register, n: Register) Instruction {
9408 return .{ .data_processing_vector = .{ .convert_float_integer = .{12367 switch (d.format) {
9409 .fcvtns = .{12368 else => unreachable,
9410 .Rd = d.alias.encode(.{}),12369 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9411 .Rn = n.alias.encode(.{ .V = true }),12370 .fcvtns = .{
9412 .ftype = switch (n.format.scalar) {12371 .Rd = d.alias.encode(.{}),
9413 else => unreachable,12372 .Rn = n.alias.encode(.{ .V = true }),
9414 .single => .single,12373 .ftype = .fromVectorSize(n.format.scalar),
9415 .double => .double,12374 .sf = sf,
9416 .half => .half,12375 },
12376 } } },
12377 .scalar => |elem_size| switch (n.format) {
12378 else => unreachable,
12379 .scalar => |ftype| {
12380 assert(ftype == elem_size);
12381 switch (elem_size) {
12382 else => unreachable,
12383 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12384 .fcvtns = .{
12385 .Rd = d.alias.encode(.{ .V = true }),
12386 .Rn = n.alias.encode(.{ .V = true }),
12387 },
12388 } } },
12389 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12390 .fcvtns = .{
12391 .Rd = d.alias.encode(.{ .V = true }),
12392 .Rn = n.alias.encode(.{ .V = true }),
12393 .sz = .fromVectorSize(elem_size),
12394 },
12395 } } },
12396 }
9417 },12397 },
9418 .sf = d.format.integer,
9419 },12398 },
9420 } } };12399 .vector => |arrangement| {
12400 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12401 switch (arrangement.elemSize()) {
12402 else => unreachable,
12403 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12404 .fcvtns = .{
12405 .Rd = d.alias.encode(.{ .V = true }),
12406 .Rn = n.alias.encode(.{ .V = true }),
12407 .Q = arrangement.size(),
12408 },
12409 } } },
12410 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12411 .fcvtns = .{
12412 .Rd = d.alias.encode(.{ .V = true }),
12413 .Rn = n.alias.encode(.{ .V = true }),
12414 .sz = arrangement.elemSz(),
12415 .Q = arrangement.size(),
12416 },
12417 } } },
12418 }
12419 },
12420 }
9421 }12421 }
12422 /// C7.2.82 FCVTNU (vector)
9422 /// C7.2.83 FCVTNU (scalar)12423 /// C7.2.83 FCVTNU (scalar)
9423 pub fn fcvtnu(d: Register, n: Register) Instruction {12424 pub fn fcvtnu(d: Register, n: Register) Instruction {
9424 return .{ .data_processing_vector = .{ .convert_float_integer = .{12425 switch (d.format) {
9425 .fcvtnu = .{12426 else => unreachable,
9426 .Rd = d.alias.encode(.{}),12427 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9427 .Rn = n.alias.encode(.{ .V = true }),12428 .fcvtnu = .{
9428 .ftype = switch (n.format.scalar) {12429 .Rd = d.alias.encode(.{}),
9429 else => unreachable,12430 .Rn = n.alias.encode(.{ .V = true }),
9430 .single => .single,12431 .ftype = .fromVectorSize(n.format.scalar),
9431 .double => .double,12432 .sf = sf,
9432 .half => .half,12433 },
12434 } } },
12435 .scalar => |elem_size| switch (n.format) {
12436 else => unreachable,
12437 .scalar => |ftype| {
12438 assert(ftype == elem_size);
12439 switch (elem_size) {
12440 else => unreachable,
12441 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12442 .fcvtnu = .{
12443 .Rd = d.alias.encode(.{ .V = true }),
12444 .Rn = n.alias.encode(.{ .V = true }),
12445 },
12446 } } },
12447 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12448 .fcvtnu = .{
12449 .Rd = d.alias.encode(.{ .V = true }),
12450 .Rn = n.alias.encode(.{ .V = true }),
12451 .sz = .fromVectorSize(elem_size),
12452 },
12453 } } },
12454 }
9433 },12455 },
9434 .sf = d.format.integer,
9435 },12456 },
9436 } } };12457 .vector => |arrangement| {
12458 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12459 switch (arrangement.elemSize()) {
12460 else => unreachable,
12461 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12462 .fcvtnu = .{
12463 .Rd = d.alias.encode(.{ .V = true }),
12464 .Rn = n.alias.encode(.{ .V = true }),
12465 .Q = arrangement.size(),
12466 },
12467 } } },
12468 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12469 .fcvtnu = .{
12470 .Rd = d.alias.encode(.{ .V = true }),
12471 .Rn = n.alias.encode(.{ .V = true }),
12472 .sz = arrangement.elemSz(),
12473 .Q = arrangement.size(),
12474 },
12475 } } },
12476 }
12477 },
12478 }
9437 }12479 }
12480 /// C7.2.84 FCVTPS (vector)
9438 /// C7.2.85 FCVTPS (scalar)12481 /// C7.2.85 FCVTPS (scalar)
9439 pub fn fcvtps(d: Register, n: Register) Instruction {12482 pub fn fcvtps(d: Register, n: Register) Instruction {
9440 return .{ .data_processing_vector = .{ .convert_float_integer = .{12483 switch (d.format) {
9441 .fcvtps = .{12484 else => unreachable,
9442 .Rd = d.alias.encode(.{}),12485 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9443 .Rn = n.alias.encode(.{ .V = true }),12486 .fcvtps = .{
9444 .ftype = switch (n.format.scalar) {12487 .Rd = d.alias.encode(.{}),
9445 else => unreachable,12488 .Rn = n.alias.encode(.{ .V = true }),
9446 .single => .single,12489 .ftype = .fromVectorSize(n.format.scalar),
9447 .double => .double,12490 .sf = sf,
9448 .half => .half,12491 },
12492 } } },
12493 .scalar => |elem_size| switch (n.format) {
12494 else => unreachable,
12495 .scalar => |ftype| {
12496 assert(ftype == elem_size);
12497 switch (elem_size) {
12498 else => unreachable,
12499 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12500 .fcvtps = .{
12501 .Rd = d.alias.encode(.{ .V = true }),
12502 .Rn = n.alias.encode(.{ .V = true }),
12503 },
12504 } } },
12505 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12506 .fcvtps = .{
12507 .Rd = d.alias.encode(.{ .V = true }),
12508 .Rn = n.alias.encode(.{ .V = true }),
12509 .sz = .fromVectorSize(elem_size),
12510 },
12511 } } },
12512 }
9449 },12513 },
9450 .sf = d.format.integer,
9451 },12514 },
9452 } } };12515 .vector => |arrangement| {
12516 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12517 switch (arrangement.elemSize()) {
12518 else => unreachable,
12519 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12520 .fcvtps = .{
12521 .Rd = d.alias.encode(.{ .V = true }),
12522 .Rn = n.alias.encode(.{ .V = true }),
12523 .Q = arrangement.size(),
12524 },
12525 } } },
12526 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12527 .fcvtps = .{
12528 .Rd = d.alias.encode(.{ .V = true }),
12529 .Rn = n.alias.encode(.{ .V = true }),
12530 .sz = arrangement.elemSz(),
12531 .Q = arrangement.size(),
12532 },
12533 } } },
12534 }
12535 },
12536 }
9453 }12537 }
12538 /// C7.2.86 FCVTPU (vector)
9454 /// C7.2.87 FCVTPU (scalar)12539 /// C7.2.87 FCVTPU (scalar)
9455 pub fn fcvtpu(d: Register, n: Register) Instruction {12540 pub fn fcvtpu(d: Register, n: Register) Instruction {
9456 return .{ .data_processing_vector = .{ .convert_float_integer = .{12541 switch (d.format) {
9457 .fcvtpu = .{12542 else => unreachable,
9458 .Rd = d.alias.encode(.{}),12543 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9459 .Rn = n.alias.encode(.{ .V = true }),12544 .fcvtpu = .{
9460 .ftype = switch (n.format.scalar) {12545 .Rd = d.alias.encode(.{}),
9461 else => unreachable,12546 .Rn = n.alias.encode(.{ .V = true }),
9462 .single => .single,12547 .ftype = .fromVectorSize(n.format.scalar),
9463 .double => .double,12548 .sf = sf,
9464 .half => .half,12549 },
12550 } } },
12551 .scalar => |elem_size| switch (n.format) {
12552 else => unreachable,
12553 .scalar => |ftype| {
12554 assert(ftype == elem_size);
12555 switch (elem_size) {
12556 else => unreachable,
12557 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12558 .fcvtpu = .{
12559 .Rd = d.alias.encode(.{ .V = true }),
12560 .Rn = n.alias.encode(.{ .V = true }),
12561 },
12562 } } },
12563 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12564 .fcvtpu = .{
12565 .Rd = d.alias.encode(.{ .V = true }),
12566 .Rn = n.alias.encode(.{ .V = true }),
12567 .sz = .fromVectorSize(elem_size),
12568 },
12569 } } },
12570 }
9465 },12571 },
9466 .sf = d.format.integer,
9467 },12572 },
9468 } } };12573 .vector => |arrangement| {
12574 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12575 switch (arrangement.elemSize()) {
12576 else => unreachable,
12577 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
12578 .fcvtpu = .{
12579 .Rd = d.alias.encode(.{ .V = true }),
12580 .Rn = n.alias.encode(.{ .V = true }),
12581 .Q = arrangement.size(),
12582 },
12583 } } },
12584 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12585 .fcvtpu = .{
12586 .Rd = d.alias.encode(.{ .V = true }),
12587 .Rn = n.alias.encode(.{ .V = true }),
12588 .sz = arrangement.elemSz(),
12589 .Q = arrangement.size(),
12590 },
12591 } } },
12592 }
12593 },
12594 }
9469 }12595 }
12596 /// C7.2.90 FCVTZS (vector, integer)
9470 /// C7.2.92 FCVTZS (scalar, integer)12597 /// C7.2.92 FCVTZS (scalar, integer)
9471 pub fn fcvtzs(d: Register, n: Register) Instruction {12598 pub fn fcvtzs(d: Register, n: Register) Instruction {
9472 return .{ .data_processing_vector = .{ .convert_float_integer = .{12599 switch (d.format) {
9473 .fcvtzs = .{12600 else => unreachable,
9474 .Rd = d.alias.encode(.{}),12601 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
9475 .Rn = n.alias.encode(.{ .V = true }),12602 .fcvtzs = .{
9476 .ftype = switch (n.format.scalar) {12603 .Rd = d.alias.encode(.{}),
12604 .Rn = n.alias.encode(.{ .V = true }),
12605 .ftype = .fromVectorSize(n.format.scalar),
12606 .sf = sf,
12607 },
12608 } } },
12609 .scalar => |elem_size| switch (n.format) {
12610 else => unreachable,
12611 .scalar => |ftype| {
12612 assert(ftype == elem_size);
12613 switch (elem_size) {
12614 else => unreachable,
12615 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12616 .fcvtzs = .{
12617 .Rd = d.alias.encode(.{ .V = true }),
12618 .Rn = n.alias.encode(.{ .V = true }),
12619 },
12620 } } },
12621 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12622 .fcvtzs = .{
12623 .Rd = d.alias.encode(.{ .V = true }),
12624 .Rn = n.alias.encode(.{ .V = true }),
12625 .sz = .fromVectorSize(elem_size),
12626 },
12627 } } },
12628 }
12629 },
12630 },
12631 .vector => |arrangement| {
12632 assert(arrangement != .@"1d" and n.format.vector == arrangement);
12633 switch (arrangement.elemSize()) {
9477 else => unreachable,12634 else => unreachable,
9478 .single => .single,12635 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9479 .double => .double,12636 .fcvtzs = .{
9480 .half => .half,12637 .Rd = d.alias.encode(.{ .V = true }),
12638 .Rn = n.alias.encode(.{ .V = true }),
12639 .Q = arrangement.size(),
12640 },
12641 } } },
12642 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12643 .fcvtzs = .{
12644 .Rd = d.alias.encode(.{ .V = true }),
12645 .Rn = n.alias.encode(.{ .V = true }),
12646 .sz = arrangement.elemSz(),
12647 .Q = arrangement.size(),
12648 },
12649 } } },
12650 }
12651 },
12652 }
12653 }
12654 /// C7.2.94 FCVTZU (vector, integer)
12655 /// C7.2.96 FCVTZU (scalar, integer)
12656 pub fn fcvtzu(d: Register, n: Register) Instruction {
12657 switch (d.format) {
12658 else => unreachable,
12659 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
12660 .fcvtzu = .{
12661 .Rd = d.alias.encode(.{}),
12662 .Rn = n.alias.encode(.{ .V = true }),
12663 .ftype = .fromVectorSize(n.format.scalar),
12664 .sf = sf,
12665 },
12666 } } },
12667 .scalar => |elem_size| switch (n.format) {
12668 else => unreachable,
12669 .scalar => |ftype| {
12670 assert(ftype == elem_size);
12671 switch (elem_size) {
12672 else => unreachable,
12673 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
12674 .fcvtzu = .{
12675 .Rd = d.alias.encode(.{ .V = true }),
12676 .Rn = n.alias.encode(.{ .V = true }),
12677 },
12678 } } },
12679 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
12680 .fcvtzu = .{
12681 .Rd = d.alias.encode(.{ .V = true }),
12682 .Rn = n.alias.encode(.{ .V = true }),
12683 .sz = .fromVectorSize(elem_size),
12684 },
12685 } } },
12686 }
9481 },12687 },
9482 .sf = d.format.integer,
9483 },12688 },
9484 } } };12689 .vector => |arrangement| {
9485 }12690 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9486 /// C7.2.96 FCVTZU (scalar, integer)12691 switch (arrangement.elemSize()) {
9487 pub fn fcvtzu(d: Register, n: Register) Instruction {
9488 return .{ .data_processing_vector = .{ .convert_float_integer = .{
9489 .fcvtzu = .{
9490 .Rd = d.alias.encode(.{}),
9491 .Rn = n.alias.encode(.{ .V = true }),
9492 .ftype = switch (n.format.scalar) {
9493 else => unreachable,12692 else => unreachable,
9494 .single => .single,12693 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9495 .double => .double,12694 .fcvtzu = .{
9496 .half => .half,12695 .Rd = d.alias.encode(.{ .V = true }),
9497 },12696 .Rn = n.alias.encode(.{ .V = true }),
9498 .sf = d.format.integer,12697 .Q = arrangement.size(),
12698 },
12699 } } },
12700 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12701 .fcvtzu = .{
12702 .Rd = d.alias.encode(.{ .V = true }),
12703 .Rn = n.alias.encode(.{ .V = true }),
12704 .sz = arrangement.elemSz(),
12705 .Q = arrangement.size(),
12706 },
12707 } } },
12708 }
9499 },12709 },
9500 } } };12710 }
9501 }12711 }
9502 /// C7.2.98 FDIV (scalar)12712 /// C7.2.98 FDIV (scalar)
9503 pub fn fdiv(d: Register, n: Register, m: Register) Instruction {12713 pub fn fdiv(d: Register, n: Register, m: Register) Instruction {
...@@ -9508,12 +12718,7 @@ pub const Instruction = packed union {...@@ -9508,12 +12718,7 @@ pub const Instruction = packed union {
9508 .Rd = d.alias.encode(.{ .V = true }),12718 .Rd = d.alias.encode(.{ .V = true }),
9509 .Rn = n.alias.encode(.{ .V = true }),12719 .Rn = n.alias.encode(.{ .V = true }),
9510 .Rm = m.alias.encode(.{ .V = true }),12720 .Rm = m.alias.encode(.{ .V = true }),
9511 .ftype = switch (ftype) {12721 .ftype = .fromVectorSize(ftype),
9512 else => unreachable,
9513 .single => .single,
9514 .double => .double,
9515 .half => .half,
9516 },
9517 },12722 },
9518 } } };12723 } } };
9519 }12724 }
...@@ -9538,12 +12743,7 @@ pub const Instruction = packed union {...@@ -9538,12 +12743,7 @@ pub const Instruction = packed union {
9538 .Rn = n.alias.encode(.{ .V = true }),12743 .Rn = n.alias.encode(.{ .V = true }),
9539 .Rm = m.alias.encode(.{ .V = true }),12744 .Rm = m.alias.encode(.{ .V = true }),
9540 .Ra = a.alias.encode(.{ .V = true }),12745 .Ra = a.alias.encode(.{ .V = true }),
9541 .ftype = switch (ftype) {12746 .ftype = .fromVectorSize(ftype),
9542 else => unreachable,
9543 .single => .single,
9544 .double => .double,
9545 .half => .half,
9546 },
9547 },12747 },
9548 } } };12748 } } };
9549 }12749 }
...@@ -9556,12 +12756,7 @@ pub const Instruction = packed union {...@@ -9556,12 +12756,7 @@ pub const Instruction = packed union {
9556 .Rd = d.alias.encode(.{ .V = true }),12756 .Rd = d.alias.encode(.{ .V = true }),
9557 .Rn = n.alias.encode(.{ .V = true }),12757 .Rn = n.alias.encode(.{ .V = true }),
9558 .Rm = m.alias.encode(.{ .V = true }),12758 .Rm = m.alias.encode(.{ .V = true }),
9559 .ftype = switch (ftype) {12759 .ftype = .fromVectorSize(ftype),
9560 else => unreachable,
9561 .single => .single,
9562 .double => .double,
9563 .half => .half,
9564 },
9565 },12760 },
9566 } } };12761 } } };
9567 }12762 }
...@@ -9574,12 +12769,7 @@ pub const Instruction = packed union {...@@ -9574,12 +12769,7 @@ pub const Instruction = packed union {
9574 .Rd = d.alias.encode(.{ .V = true }),12769 .Rd = d.alias.encode(.{ .V = true }),
9575 .Rn = n.alias.encode(.{ .V = true }),12770 .Rn = n.alias.encode(.{ .V = true }),
9576 .Rm = m.alias.encode(.{ .V = true }),12771 .Rm = m.alias.encode(.{ .V = true }),
9577 .ftype = switch (ftype) {12772 .ftype = .fromVectorSize(ftype),
9578 else => unreachable,
9579 .single => .single,
9580 .double => .double,
9581 .half => .half,
9582 },
9583 },12773 },
9584 } } };12774 } } };
9585 }12775 }
...@@ -9592,12 +12782,7 @@ pub const Instruction = packed union {...@@ -9592,12 +12782,7 @@ pub const Instruction = packed union {
9592 .Rd = d.alias.encode(.{ .V = true }),12782 .Rd = d.alias.encode(.{ .V = true }),
9593 .Rn = n.alias.encode(.{ .V = true }),12783 .Rn = n.alias.encode(.{ .V = true }),
9594 .Rm = m.alias.encode(.{ .V = true }),12784 .Rm = m.alias.encode(.{ .V = true }),
9595 .ftype = switch (ftype) {12785 .ftype = .fromVectorSize(ftype),
9596 else => unreachable,
9597 .single => .single,
9598 .double => .double,
9599 .half => .half,
9600 },
9601 },12786 },
9602 } } };12787 } } };
9603 }12788 }
...@@ -9610,12 +12795,7 @@ pub const Instruction = packed union {...@@ -9610,12 +12795,7 @@ pub const Instruction = packed union {
9610 .Rd = d.alias.encode(.{ .V = true }),12795 .Rd = d.alias.encode(.{ .V = true }),
9611 .Rn = n.alias.encode(.{ .V = true }),12796 .Rn = n.alias.encode(.{ .V = true }),
9612 .Rm = m.alias.encode(.{ .V = true }),12797 .Rm = m.alias.encode(.{ .V = true }),
9613 .ftype = switch (ftype) {12798 .ftype = .fromVectorSize(ftype),
9614 else => unreachable,
9615 .single => .single,
9616 .double => .double,
9617 .half => .half,
9618 },
9619 },12799 },
9620 } } };12800 } } };
9621 }12801 }
...@@ -9642,12 +12822,7 @@ pub const Instruction = packed union {...@@ -9642,12 +12822,7 @@ pub const Instruction = packed union {
9642 .fmov = .{12822 .fmov = .{
9643 .Rd = d.alias.encode(.{ .V = true }),12823 .Rd = d.alias.encode(.{ .V = true }),
9644 .imm8 = imm,12824 .imm8 = imm,
9645 .ftype = switch (ftype) {12825 .ftype = .fromVectorSize(ftype),
9646 else => unreachable,
9647 .single => .single,
9648 .double => .double,
9649 .half => .half,
9650 },
9651 },12826 },
9652 } } },12827 } } },
9653 .vector => |arrangement| {12828 .vector => |arrangement| {
...@@ -9680,12 +12855,7 @@ pub const Instruction = packed union {...@@ -9680,12 +12855,7 @@ pub const Instruction = packed union {
9680 .Rn = n.alias.encode(.{ .V = true }),12855 .Rn = n.alias.encode(.{ .V = true }),
9681 .opcode = .float_to_integer,12856 .opcode = .float_to_integer,
9682 .rmode = .@"0",12857 .rmode = .@"0",
9683 .ftype = switch (ftype) {12858 .ftype = .fromVectorSize(ftype),
9684 else => unreachable,
9685 .single => .single,
9686 .double => .double,
9687 .half => .half,
9688 },
9689 .sf = sf,12859 .sf = sf,
9690 },12860 },
9691 } } };12861 } } };
...@@ -9723,12 +12893,7 @@ pub const Instruction = packed union {...@@ -9723,12 +12893,7 @@ pub const Instruction = packed union {
9723 .Rn = n.alias.encode(.{}),12893 .Rn = n.alias.encode(.{}),
9724 .opcode = .integer_to_float,12894 .opcode = .integer_to_float,
9725 .rmode = .@"0",12895 .rmode = .@"0",
9726 .ftype = switch (ftype) {12896 .ftype = .fromVectorSize(ftype),
9727 else => unreachable,
9728 .single => .single,
9729 .double => .double,
9730 .half => .half,
9731 },
9732 .sf = sf,12897 .sf = sf,
9733 },12898 },
9734 } } };12899 } } };
...@@ -9739,12 +12904,7 @@ pub const Instruction = packed union {...@@ -9739,12 +12904,7 @@ pub const Instruction = packed union {
9739 .fmov = .{12904 .fmov = .{
9740 .Rd = d.alias.encode(.{ .V = true }),12905 .Rd = d.alias.encode(.{ .V = true }),
9741 .Rn = n.alias.encode(.{ .V = true }),12906 .Rn = n.alias.encode(.{ .V = true }),
9742 .ftype = switch (ftype) {12907 .ftype = .fromVectorSize(ftype),
9743 else => unreachable,
9744 .single => .single,
9745 .double => .double,
9746 .half => .half,
9747 },
9748 },12908 },
9749 } } };12909 } } };
9750 },12910 },
...@@ -9781,12 +12941,7 @@ pub const Instruction = packed union {...@@ -9781,12 +12941,7 @@ pub const Instruction = packed union {
9781 .Rn = n.alias.encode(.{ .V = true }),12941 .Rn = n.alias.encode(.{ .V = true }),
9782 .Rm = m.alias.encode(.{ .V = true }),12942 .Rm = m.alias.encode(.{ .V = true }),
9783 .Ra = a.alias.encode(.{ .V = true }),12943 .Ra = a.alias.encode(.{ .V = true }),
9784 .ftype = switch (ftype) {12944 .ftype = .fromVectorSize(ftype),
9785 else => unreachable,
9786 .single => .single,
9787 .double => .double,
9788 .half => .half,
9789 },
9790 },12945 },
9791 } } };12946 } } };
9792 }12947 }
...@@ -9799,31 +12954,47 @@ pub const Instruction = packed union {...@@ -9799,31 +12954,47 @@ pub const Instruction = packed union {
9799 .Rd = d.alias.encode(.{ .V = true }),12954 .Rd = d.alias.encode(.{ .V = true }),
9800 .Rn = n.alias.encode(.{ .V = true }),12955 .Rn = n.alias.encode(.{ .V = true }),
9801 .Rm = m.alias.encode(.{ .V = true }),12956 .Rm = m.alias.encode(.{ .V = true }),
9802 .ftype = switch (ftype) {12957 .ftype = .fromVectorSize(ftype),
9803 else => unreachable,
9804 .single => .single,
9805 .double => .double,
9806 .half => .half,
9807 },
9808 },12958 },
9809 } } };12959 } } };
9810 }12960 }
12961 /// C7.2.139 FNEG (vector)
9811 /// C7.2.140 FNEG (scalar)12962 /// C7.2.140 FNEG (scalar)
9812 pub fn fneg(d: Register, n: Register) Instruction {12963 pub fn fneg(d: Register, n: Register) Instruction {
9813 const ftype = d.format.scalar;12964 switch (d.format) {
9814 assert(n.format.scalar == ftype);12965 else => unreachable,
9815 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{12966 .vector => |arrangement| {
9816 .fneg = .{12967 assert(n.format.vector == arrangement);
9817 .Rd = d.alias.encode(.{ .V = true }),12968 switch (arrangement.elemSize()) {
9818 .Rn = n.alias.encode(.{ .V = true }),
9819 .ftype = switch (ftype) {
9820 else => unreachable,12969 else => unreachable,
9821 .single => .single,12970 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9822 .double => .double,12971 .fneg = .{
9823 .half => .half,12972 .Rd = d.alias.encode(.{ .V = true }),
9824 },12973 .Rn = n.alias.encode(.{ .V = true }),
12974 .Q = arrangement.size(),
12975 },
12976 } } },
12977 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
12978 .fneg = .{
12979 .Rd = d.alias.encode(.{ .V = true }),
12980 .Rn = n.alias.encode(.{ .V = true }),
12981 .sz = arrangement.elemSz(),
12982 .Q = arrangement.size(),
12983 },
12984 } } },
12985 }
9825 },12986 },
9826 } } };12987 .scalar => |ftype| {
12988 assert(n.format.scalar == ftype);
12989 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
12990 .fneg = .{
12991 .Rd = d.alias.encode(.{ .V = true }),
12992 .Rn = n.alias.encode(.{ .V = true }),
12993 .ftype = .fromVectorSize(ftype),
12994 },
12995 } } };
12996 },
12997 }
9827 }12998 }
9828 /// C7.2.141 FNMADD12999 /// C7.2.141 FNMADD
9829 pub fn fnmadd(d: Register, n: Register, m: Register, a: Register) Instruction {13000 pub fn fnmadd(d: Register, n: Register, m: Register, a: Register) Instruction {
...@@ -9835,12 +13006,7 @@ pub const Instruction = packed union {...@@ -9835,12 +13006,7 @@ pub const Instruction = packed union {
9835 .Rn = n.alias.encode(.{ .V = true }),13006 .Rn = n.alias.encode(.{ .V = true }),
9836 .Rm = m.alias.encode(.{ .V = true }),13007 .Rm = m.alias.encode(.{ .V = true }),
9837 .Ra = a.alias.encode(.{ .V = true }),13008 .Ra = a.alias.encode(.{ .V = true }),
9838 .ftype = switch (ftype) {13009 .ftype = .fromVectorSize(ftype),
9839 else => unreachable,
9840 .single => .single,
9841 .double => .double,
9842 .half => .half,
9843 },
9844 },13010 },
9845 } } };13011 } } };
9846 }13012 }
...@@ -9854,12 +13020,7 @@ pub const Instruction = packed union {...@@ -9854,12 +13020,7 @@ pub const Instruction = packed union {
9854 .Rn = n.alias.encode(.{ .V = true }),13020 .Rn = n.alias.encode(.{ .V = true }),
9855 .Rm = m.alias.encode(.{ .V = true }),13021 .Rm = m.alias.encode(.{ .V = true }),
9856 .Ra = a.alias.encode(.{ .V = true }),13022 .Ra = a.alias.encode(.{ .V = true }),
9857 .ftype = switch (ftype) {13023 .ftype = .fromVectorSize(ftype),
9858 else => unreachable,
9859 .single => .single,
9860 .double => .double,
9861 .half => .half,
9862 },
9863 },13024 },
9864 } } };13025 } } };
9865 }13026 }
...@@ -9872,150 +13033,313 @@ pub const Instruction = packed union {...@@ -9872,150 +13033,313 @@ pub const Instruction = packed union {
9872 .Rd = d.alias.encode(.{ .V = true }),13033 .Rd = d.alias.encode(.{ .V = true }),
9873 .Rn = n.alias.encode(.{ .V = true }),13034 .Rn = n.alias.encode(.{ .V = true }),
9874 .Rm = m.alias.encode(.{ .V = true }),13035 .Rm = m.alias.encode(.{ .V = true }),
9875 .ftype = switch (ftype) {13036 .ftype = .fromVectorSize(ftype),
9876 else => unreachable,
9877 .single => .single,
9878 .double => .double,
9879 .half => .half,
9880 },
9881 },13037 },
9882 } } };13038 } } };
9883 }13039 }
13040 /// C7.2.155 FRINTA (vector)
9884 /// C7.2.156 FRINTA (scalar)13041 /// C7.2.156 FRINTA (scalar)
9885 pub fn frinta(d: Register, n: Register) Instruction {13042 pub fn frinta(d: Register, n: Register) Instruction {
9886 const ftype = d.format.scalar;13043 switch (d.format) {
9887 assert(n.format.scalar == ftype);13044 else => unreachable,
9888 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13045 .vector => |arrangement| {
9889 .frinta = .{13046 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9890 .Rd = d.alias.encode(.{ .V = true }),13047 switch (arrangement.elemSize()) {
9891 .Rn = n.alias.encode(.{ .V = true }),
9892 .ftype = switch (ftype) {
9893 else => unreachable,13048 else => unreachable,
9894 .single => .single,13049 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9895 .double => .double,13050 .frinta = .{
9896 .half => .half,13051 .Rd = d.alias.encode(.{ .V = true }),
9897 },13052 .Rn = n.alias.encode(.{ .V = true }),
13053 .Q = arrangement.size(),
13054 },
13055 } } },
13056 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13057 .frinta = .{
13058 .Rd = d.alias.encode(.{ .V = true }),
13059 .Rn = n.alias.encode(.{ .V = true }),
13060 .sz = arrangement.elemSz(),
13061 .Q = arrangement.size(),
13062 },
13063 } } },
13064 }
9898 },13065 },
9899 } } };13066 .scalar => |ftype| {
13067 assert(n.format.scalar == ftype);
13068 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13069 .frinta = .{
13070 .Rd = d.alias.encode(.{ .V = true }),
13071 .Rn = n.alias.encode(.{ .V = true }),
13072 .ftype = .fromVectorSize(ftype),
13073 },
13074 } } };
13075 },
13076 }
9900 }13077 }
13078 /// C7.2.157 FRINTI (vector)
9901 /// C7.2.158 FRINTI (scalar)13079 /// C7.2.158 FRINTI (scalar)
9902 pub fn frinti(d: Register, n: Register) Instruction {13080 pub fn frinti(d: Register, n: Register) Instruction {
9903 const ftype = d.format.scalar;13081 switch (d.format) {
9904 assert(n.format.scalar == ftype);13082 else => unreachable,
9905 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13083 .vector => |arrangement| {
9906 .frinti = .{13084 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9907 .Rd = d.alias.encode(.{ .V = true }),13085 switch (arrangement.elemSize()) {
9908 .Rn = n.alias.encode(.{ .V = true }),
9909 .ftype = switch (ftype) {
9910 else => unreachable,13086 else => unreachable,
9911 .single => .single,13087 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9912 .double => .double,13088 .frinti = .{
9913 .half => .half,13089 .Rd = d.alias.encode(.{ .V = true }),
9914 },13090 .Rn = n.alias.encode(.{ .V = true }),
13091 .Q = arrangement.size(),
13092 },
13093 } } },
13094 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13095 .frinti = .{
13096 .Rd = d.alias.encode(.{ .V = true }),
13097 .Rn = n.alias.encode(.{ .V = true }),
13098 .sz = arrangement.elemSz(),
13099 .Q = arrangement.size(),
13100 },
13101 } } },
13102 }
9915 },13103 },
9916 } } };13104 .scalar => |ftype| {
13105 assert(n.format.scalar == ftype);
13106 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13107 .frinti = .{
13108 .Rd = d.alias.encode(.{ .V = true }),
13109 .Rn = n.alias.encode(.{ .V = true }),
13110 .ftype = .fromVectorSize(ftype),
13111 },
13112 } } };
13113 },
13114 }
9917 }13115 }
13116 /// C7.2.159 FRINTM (vector)
9918 /// C7.2.160 FRINTM (scalar)13117 /// C7.2.160 FRINTM (scalar)
9919 pub fn frintm(d: Register, n: Register) Instruction {13118 pub fn frintm(d: Register, n: Register) Instruction {
9920 const ftype = d.format.scalar;13119 switch (d.format) {
9921 assert(n.format.scalar == ftype);13120 else => unreachable,
9922 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13121 .vector => |arrangement| {
9923 .frintm = .{13122 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9924 .Rd = d.alias.encode(.{ .V = true }),13123 switch (arrangement.elemSize()) {
9925 .Rn = n.alias.encode(.{ .V = true }),
9926 .ftype = switch (ftype) {
9927 else => unreachable,13124 else => unreachable,
9928 .single => .single,13125 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9929 .double => .double,13126 .frintm = .{
9930 .half => .half,13127 .Rd = d.alias.encode(.{ .V = true }),
9931 },13128 .Rn = n.alias.encode(.{ .V = true }),
13129 .Q = arrangement.size(),
13130 },
13131 } } },
13132 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13133 .frintm = .{
13134 .Rd = d.alias.encode(.{ .V = true }),
13135 .Rn = n.alias.encode(.{ .V = true }),
13136 .sz = arrangement.elemSz(),
13137 .Q = arrangement.size(),
13138 },
13139 } } },
13140 }
9932 },13141 },
9933 } } };13142 .scalar => |ftype| {
13143 assert(n.format.scalar == ftype);
13144 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13145 .frintm = .{
13146 .Rd = d.alias.encode(.{ .V = true }),
13147 .Rn = n.alias.encode(.{ .V = true }),
13148 .ftype = .fromVectorSize(ftype),
13149 },
13150 } } };
13151 },
13152 }
9934 }13153 }
13154 /// C7.2.161 FRINTN (vector)
9935 /// C7.2.162 FRINTN (scalar)13155 /// C7.2.162 FRINTN (scalar)
9936 pub fn frintn(d: Register, n: Register) Instruction {13156 pub fn frintn(d: Register, n: Register) Instruction {
9937 const ftype = d.format.scalar;13157 switch (d.format) {
9938 assert(n.format.scalar == ftype);13158 else => unreachable,
9939 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13159 .vector => |arrangement| {
9940 .frintn = .{13160 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9941 .Rd = d.alias.encode(.{ .V = true }),13161 switch (arrangement.elemSize()) {
9942 .Rn = n.alias.encode(.{ .V = true }),
9943 .ftype = switch (ftype) {
9944 else => unreachable,13162 else => unreachable,
9945 .single => .single,13163 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9946 .double => .double,13164 .frintn = .{
9947 .half => .half,13165 .Rd = d.alias.encode(.{ .V = true }),
9948 },13166 .Rn = n.alias.encode(.{ .V = true }),
13167 .Q = arrangement.size(),
13168 },
13169 } } },
13170 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13171 .frintn = .{
13172 .Rd = d.alias.encode(.{ .V = true }),
13173 .Rn = n.alias.encode(.{ .V = true }),
13174 .sz = arrangement.elemSz(),
13175 .Q = arrangement.size(),
13176 },
13177 } } },
13178 }
9949 },13179 },
9950 } } };13180 .scalar => |ftype| {
13181 assert(n.format.scalar == ftype);
13182 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13183 .frintn = .{
13184 .Rd = d.alias.encode(.{ .V = true }),
13185 .Rn = n.alias.encode(.{ .V = true }),
13186 .ftype = .fromVectorSize(ftype),
13187 },
13188 } } };
13189 },
13190 }
9951 }13191 }
13192 /// C7.2.163 FRINTP (vector)
9952 /// C7.2.164 FRINTP (scalar)13193 /// C7.2.164 FRINTP (scalar)
9953 pub fn frintp(d: Register, n: Register) Instruction {13194 pub fn frintp(d: Register, n: Register) Instruction {
9954 const ftype = d.format.scalar;13195 switch (d.format) {
9955 assert(n.format.scalar == ftype);13196 else => unreachable,
9956 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13197 .vector => |arrangement| {
9957 .frintp = .{13198 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9958 .Rd = d.alias.encode(.{ .V = true }),13199 switch (arrangement.elemSize()) {
9959 .Rn = n.alias.encode(.{ .V = true }),
9960 .ftype = switch (ftype) {
9961 else => unreachable,13200 else => unreachable,
9962 .single => .single,13201 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9963 .double => .double,13202 .frintp = .{
9964 .half => .half,13203 .Rd = d.alias.encode(.{ .V = true }),
9965 },13204 .Rn = n.alias.encode(.{ .V = true }),
13205 .Q = arrangement.size(),
13206 },
13207 } } },
13208 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13209 .frintp = .{
13210 .Rd = d.alias.encode(.{ .V = true }),
13211 .Rn = n.alias.encode(.{ .V = true }),
13212 .sz = arrangement.elemSz(),
13213 .Q = arrangement.size(),
13214 },
13215 } } },
13216 }
9966 },13217 },
9967 } } };13218 .scalar => |ftype| {
13219 assert(n.format.scalar == ftype);
13220 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13221 .frintp = .{
13222 .Rd = d.alias.encode(.{ .V = true }),
13223 .Rn = n.alias.encode(.{ .V = true }),
13224 .ftype = .fromVectorSize(ftype),
13225 },
13226 } } };
13227 },
13228 }
9968 }13229 }
13230 /// C7.2.165 FRINTX (vector)
9969 /// C7.2.166 FRINTX (scalar)13231 /// C7.2.166 FRINTX (scalar)
9970 pub fn frintx(d: Register, n: Register) Instruction {13232 pub fn frintx(d: Register, n: Register) Instruction {
9971 const ftype = d.format.scalar;13233 switch (d.format) {
9972 assert(n.format.scalar == ftype);13234 else => unreachable,
9973 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13235 .vector => |arrangement| {
9974 .frintx = .{13236 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9975 .Rd = d.alias.encode(.{ .V = true }),13237 switch (arrangement.elemSize()) {
9976 .Rn = n.alias.encode(.{ .V = true }),
9977 .ftype = switch (ftype) {
9978 else => unreachable,13238 else => unreachable,
9979 .single => .single,13239 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9980 .double => .double,13240 .frintx = .{
9981 .half => .half,13241 .Rd = d.alias.encode(.{ .V = true }),
9982 },13242 .Rn = n.alias.encode(.{ .V = true }),
13243 .Q = arrangement.size(),
13244 },
13245 } } },
13246 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13247 .frintx = .{
13248 .Rd = d.alias.encode(.{ .V = true }),
13249 .Rn = n.alias.encode(.{ .V = true }),
13250 .sz = arrangement.elemSz(),
13251 .Q = arrangement.size(),
13252 },
13253 } } },
13254 }
9983 },13255 },
9984 } } };13256 .scalar => |ftype| {
13257 assert(n.format.scalar == ftype);
13258 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13259 .frintx = .{
13260 .Rd = d.alias.encode(.{ .V = true }),
13261 .Rn = n.alias.encode(.{ .V = true }),
13262 .ftype = .fromVectorSize(ftype),
13263 },
13264 } } };
13265 },
13266 }
9985 }13267 }
13268 /// C7.2.167 FRINTZ (vector)
9986 /// C7.2.168 FRINTZ (scalar)13269 /// C7.2.168 FRINTZ (scalar)
9987 pub fn frintz(d: Register, n: Register) Instruction {13270 pub fn frintz(d: Register, n: Register) Instruction {
9988 const ftype = d.format.scalar;13271 switch (d.format) {
9989 assert(n.format.scalar == ftype);13272 else => unreachable,
9990 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13273 .vector => |arrangement| {
9991 .frintz = .{13274 assert(arrangement != .@"1d" and n.format.vector == arrangement);
9992 .Rd = d.alias.encode(.{ .V = true }),13275 switch (arrangement.elemSize()) {
9993 .Rn = n.alias.encode(.{ .V = true }),
9994 .ftype = switch (ftype) {
9995 else => unreachable,13276 else => unreachable,
9996 .single => .single,13277 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
9997 .double => .double,13278 .frintz = .{
9998 .half => .half,13279 .Rd = d.alias.encode(.{ .V = true }),
9999 },13280 .Rn = n.alias.encode(.{ .V = true }),
13281 .Q = arrangement.size(),
13282 },
13283 } } },
13284 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13285 .frintz = .{
13286 .Rd = d.alias.encode(.{ .V = true }),
13287 .Rn = n.alias.encode(.{ .V = true }),
13288 .sz = arrangement.elemSz(),
13289 .Q = arrangement.size(),
13290 },
13291 } } },
13292 }
10000 },13293 },
10001 } } };13294 .scalar => |ftype| {
13295 assert(n.format.scalar == ftype);
13296 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13297 .frintz = .{
13298 .Rd = d.alias.encode(.{ .V = true }),
13299 .Rn = n.alias.encode(.{ .V = true }),
13300 .ftype = .fromVectorSize(ftype),
13301 },
13302 } } };
13303 },
13304 }
10002 }13305 }
13306 /// C7.2.171 FSQRT (vector)
10003 /// C7.2.172 FSQRT (scalar)13307 /// C7.2.172 FSQRT (scalar)
10004 pub fn fsqrt(d: Register, n: Register) Instruction {13308 pub fn fsqrt(d: Register, n: Register) Instruction {
10005 const ftype = d.format.scalar;13309 switch (d.format) {
10006 assert(n.format.scalar == ftype);13310 else => unreachable,
10007 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{13311 .vector => |arrangement| {
10008 .fsqrt = .{13312 assert(n.format.vector == arrangement);
10009 .Rd = d.alias.encode(.{ .V = true }),13313 switch (arrangement.elemSize()) {
10010 .Rn = n.alias.encode(.{ .V = true }),
10011 .ftype = switch (ftype) {
10012 else => unreachable,13314 else => unreachable,
10013 .single => .single,13315 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
10014 .double => .double,13316 .fsqrt = .{
10015 .half => .half,13317 .Rd = d.alias.encode(.{ .V = true }),
10016 },13318 .Rn = n.alias.encode(.{ .V = true }),
13319 .Q = arrangement.size(),
13320 },
13321 } } },
13322 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
13323 .fsqrt = .{
13324 .Rd = d.alias.encode(.{ .V = true }),
13325 .Rn = n.alias.encode(.{ .V = true }),
13326 .sz = arrangement.elemSz(),
13327 .Q = arrangement.size(),
13328 },
13329 } } },
13330 }
10017 },13331 },
10018 } } };13332 .scalar => |ftype| {
13333 assert(n.format.scalar == ftype);
13334 return .{ .data_processing_vector = .{ .float_data_processing_one_source = .{
13335 .fsqrt = .{
13336 .Rd = d.alias.encode(.{ .V = true }),
13337 .Rn = n.alias.encode(.{ .V = true }),
13338 .ftype = .fromVectorSize(ftype),
13339 },
13340 } } };
13341 },
13342 }
10019 }13343 }
10020 /// C7.2.174 FSUB (scalar)13344 /// C7.2.174 FSUB (scalar)
10021 pub fn fsub(d: Register, n: Register, m: Register) Instruction {13345 pub fn fsub(d: Register, n: Register, m: Register) Instruction {
...@@ -10026,12 +13350,7 @@ pub const Instruction = packed union {...@@ -10026,12 +13350,7 @@ pub const Instruction = packed union {
10026 .Rd = d.alias.encode(.{ .V = true }),13350 .Rd = d.alias.encode(.{ .V = true }),
10027 .Rn = n.alias.encode(.{ .V = true }),13351 .Rn = n.alias.encode(.{ .V = true }),
10028 .Rm = m.alias.encode(.{ .V = true }),13352 .Rm = m.alias.encode(.{ .V = true }),
10029 .ftype = switch (ftype) {13353 .ftype = .fromVectorSize(ftype),
10030 else => unreachable,
10031 .single => .single,
10032 .double => .double,
10033 .half => .half,
10034 },
10035 },13354 },
10036 } } };13355 } } };
10037 }13356 }
...@@ -11021,12 +14340,52 @@ pub const Instruction = packed union {...@@ -11021,12 +14340,52 @@ pub const Instruction = packed union {
11021 },14340 },
11022 } } };14341 } } };
11023 }14342 }
14343 /// C7.2.209 NEG (vector)
14344 pub fn neg(d: Register, n: Register) Instruction {
14345 switch (d.format) {
14346 else => unreachable,
14347 .scalar => |elem_size| {
14348 assert(elem_size == .double and elem_size == n.format.scalar);
14349 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
14350 .neg = .{
14351 .Rd = d.alias.encode(.{ .V = true }),
14352 .Rn = n.alias.encode(.{ .V = true }),
14353 .size = .fromVectorSize(elem_size),
14354 },
14355 } } };
14356 },
14357 .vector => |arrangement| {
14358 assert(arrangement != .@"1d" and n.format.vector == arrangement);
14359 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
14360 .neg = .{
14361 .Rd = d.alias.encode(.{ .V = true }),
14362 .Rn = n.alias.encode(.{ .V = true }),
14363 .size = arrangement.elemSize(),
14364 .Q = arrangement.size(),
14365 },
14366 } } };
14367 },
14368 }
14369 }
11024 /// C6.2.238 NOP14370 /// C6.2.238 NOP
11025 pub fn nop() Instruction {14371 pub fn nop() Instruction {
11026 return .{ .branch_exception_generating_system = .{ .hints = .{14372 return .{ .branch_exception_generating_system = .{ .hints = .{
11027 .nop = .{},14373 .nop = .{},
11028 } } };14374 } } };
11029 }14375 }
14376 /// C7.2.210 NOT
14377 pub fn not(d: Register, n: Register) Instruction {
14378 const arrangement = d.format.vector;
14379 assert(arrangement.elemSize() == .byte and n.format.vector == arrangement);
14380 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
14381 .not = .{
14382 .Rd = d.alias.encode(.{ .V = true }),
14383 .Rn = n.alias.encode(.{ .V = true }),
14384 .size = arrangement.elemSize(),
14385 .Q = arrangement.size(),
14386 },
14387 } } };
14388 }
11030 /// C6.2.239 ORN (shifted register)14389 /// C6.2.239 ORN (shifted register)
11031 /// C7.2.211 ORN (vector)14390 /// C7.2.211 ORN (vector)
11032 pub fn orn(d: Register, n: Register, form: union(enum) {14391 pub fn orn(d: Register, n: Register, form: union(enum) {
...@@ -11343,21 +14702,63 @@ pub const Instruction = packed union {...@@ -11343,21 +14702,63 @@ pub const Instruction = packed union {
11343 },14702 },
11344 } } };14703 } } };
11345 }14704 }
14705 /// C7.2.234 SCVTF (vector, integer)
11346 /// C7.2.236 SCVTF (scalar, integer)14706 /// C7.2.236 SCVTF (scalar, integer)
11347 pub fn scvtf(d: Register, n: Register) Instruction {14707 pub fn scvtf(d: Register, n: Register) Instruction {
11348 return .{ .data_processing_vector = .{ .convert_float_integer = .{14708 switch (d.format) {
11349 .scvtf = .{14709 else => unreachable,
11350 .Rd = d.alias.encode(.{ .V = true }),14710 .scalar => |ftype| switch (n.format) {
11351 .Rn = n.alias.encode(.{}),14711 else => unreachable,
11352 .ftype = switch (d.format.scalar) {14712 .scalar => |elem_size| {
11353 else => unreachable,14713 assert(ftype == elem_size);
11354 .single => .single,14714 switch (ftype) {
11355 .double => .double,14715 else => unreachable,
11356 .half => .half,14716 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
14717 .scvtf = .{
14718 .Rd = d.alias.encode(.{ .V = true }),
14719 .Rn = n.alias.encode(.{ .V = true }),
14720 },
14721 } } },
14722 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
14723 .scvtf = .{
14724 .Rd = d.alias.encode(.{ .V = true }),
14725 .Rn = n.alias.encode(.{ .V = true }),
14726 .sz = .fromVectorSize(ftype),
14727 },
14728 } } },
14729 }
11357 },14730 },
11358 .sf = n.format.integer,14731 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
14732 .scvtf = .{
14733 .Rd = d.alias.encode(.{ .V = true }),
14734 .Rn = n.alias.encode(.{}),
14735 .ftype = .fromVectorSize(ftype),
14736 .sf = sf,
14737 },
14738 } } },
11359 },14739 },
11360 } } };14740 .vector => |arrangement| {
14741 assert(arrangement != .@"1d" and n.format.vector == arrangement);
14742 switch (arrangement.elemSize()) {
14743 else => unreachable,
14744 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
14745 .scvtf = .{
14746 .Rd = d.alias.encode(.{ .V = true }),
14747 .Rn = n.alias.encode(.{ .V = true }),
14748 .Q = arrangement.size(),
14749 },
14750 } } },
14751 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
14752 .scvtf = .{
14753 .Rd = d.alias.encode(.{ .V = true }),
14754 .Rn = n.alias.encode(.{ .V = true }),
14755 .sz = arrangement.elemSz(),
14756 .Q = arrangement.size(),
14757 },
14758 } } },
14759 }
14760 },
14761 }
11361 }14762 }
11362 /// C6.2.270 SDIV14763 /// C6.2.270 SDIV
11363 pub fn sdiv(d: Register, n: Register, m: Register) Instruction {14764 pub fn sdiv(d: Register, n: Register, m: Register) Instruction {
...@@ -11448,6 +14849,60 @@ pub const Instruction = packed union {...@@ -11448,6 +14849,60 @@ pub const Instruction = packed union {
11448 },14849 },
11449 } } };14850 } } };
11450 }14851 }
14852 /// C7.2.282 SQABS
14853 pub fn sqabs(d: Register, n: Register) Instruction {
14854 switch (d.format) {
14855 else => unreachable,
14856 .scalar => |elem_size| {
14857 assert(elem_size == n.format.scalar);
14858 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
14859 .sqabs = .{
14860 .Rd = d.alias.encode(.{ .V = true }),
14861 .Rn = n.alias.encode(.{ .V = true }),
14862 .size = .fromVectorSize(elem_size),
14863 },
14864 } } };
14865 },
14866 .vector => |arrangement| {
14867 assert(arrangement != .@"1d" and n.format.vector == arrangement);
14868 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
14869 .sqabs = .{
14870 .Rd = d.alias.encode(.{ .V = true }),
14871 .Rn = n.alias.encode(.{ .V = true }),
14872 .size = arrangement.elemSize(),
14873 .Q = arrangement.size(),
14874 },
14875 } } };
14876 },
14877 }
14878 }
14879 /// C7.2.308 SQXTN
14880 pub fn sqxtn(d: Register, n: Register) Instruction {
14881 switch (d.format) {
14882 else => unreachable,
14883 .scalar => |elem_size| {
14884 assert(elem_size == n.format.scalar);
14885 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
14886 .sqxtn = .{
14887 .Rd = d.alias.encode(.{ .V = true }),
14888 .Rn = n.alias.encode(.{ .V = true }),
14889 .size = .fromVectorSize(elem_size),
14890 },
14891 } } };
14892 },
14893 .vector => |arrangement| {
14894 assert(arrangement != .@"1d" and n.format.vector == arrangement);
14895 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
14896 .sqxtn = .{
14897 .Rd = d.alias.encode(.{ .V = true }),
14898 .Rn = n.alias.encode(.{ .V = true }),
14899 .size = arrangement.elemSize(),
14900 .Q = arrangement.size(),
14901 },
14902 } } };
14903 },
14904 }
14905 }
11451 /// C6.2.321 STP14906 /// C6.2.321 STP
11452 /// C7.2.330 STP (SIMD&FP)14907 /// C7.2.330 STP (SIMD&FP)
11453 pub fn stp(t1: Register, t2: Register, form: union(enum) {14908 pub fn stp(t1: Register, t2: Register, form: union(enum) {
...@@ -11942,6 +15397,33 @@ pub const Instruction = packed union {...@@ -11942,6 +15397,33 @@ pub const Instruction = packed union {
11942 } },15397 } },
11943 }15398 }
11944 }15399 }
15400 /// C7.2.337 SUQADD
15401 pub fn suqadd(d: Register, n: Register) Instruction {
15402 switch (d.format) {
15403 else => unreachable,
15404 .scalar => |elem_size| {
15405 assert(elem_size == n.format.scalar);
15406 return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
15407 .suqadd = .{
15408 .Rd = d.alias.encode(.{ .V = true }),
15409 .Rn = n.alias.encode(.{ .V = true }),
15410 .size = .fromVectorSize(elem_size),
15411 },
15412 } } };
15413 },
15414 .vector => |arrangement| {
15415 assert(arrangement != .@"1d" and n.format.vector == arrangement);
15416 return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
15417 .suqadd = .{
15418 .Rd = d.alias.encode(.{ .V = true }),
15419 .Rn = n.alias.encode(.{ .V = true }),
15420 .size = arrangement.elemSize(),
15421 .Q = arrangement.size(),
15422 },
15423 } } };
15424 },
15425 }
15426 }
11945 /// C6.2.365 SVC15427 /// C6.2.365 SVC
11946 pub fn svc(imm: u16) Instruction {15428 pub fn svc(imm: u16) Instruction {
11947 return .{ .branch_exception_generating_system = .{ .exception_generating = .{15429 return .{ .branch_exception_generating_system = .{ .exception_generating = .{
...@@ -12021,21 +15503,63 @@ pub const Instruction = packed union {...@@ -12021,21 +15503,63 @@ pub const Instruction = packed union {
12021 },15503 },
12022 } } };15504 } } };
12023 }15505 }
15506 /// C7.2.353 UCVTF (vector, integer)
12024 /// C7.2.355 UCVTF (scalar, integer)15507 /// C7.2.355 UCVTF (scalar, integer)
12025 pub fn ucvtf(d: Register, n: Register) Instruction {15508 pub fn ucvtf(d: Register, n: Register) Instruction {
12026 return .{ .data_processing_vector = .{ .convert_float_integer = .{15509 switch (d.format) {
12027 .ucvtf = .{15510 else => unreachable,
12028 .Rd = d.alias.encode(.{ .V = true }),15511 .scalar => |ftype| switch (n.format) {
12029 .Rn = n.alias.encode(.{}),15512 else => unreachable,
12030 .ftype = switch (d.format.scalar) {15513 .scalar => |elem_size| {
12031 else => unreachable,15514 assert(ftype == elem_size);
12032 .single => .single,15515 switch (ftype) {
12033 .double => .double,15516 else => unreachable,
12034 .half => .half,15517 .half => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous_fp16 = .{
15518 .ucvtf = .{
15519 .Rd = d.alias.encode(.{ .V = true }),
15520 .Rn = n.alias.encode(.{ .V = true }),
15521 },
15522 } } },
15523 .single, .double => return .{ .data_processing_vector = .{ .simd_scalar_two_register_miscellaneous = .{
15524 .ucvtf = .{
15525 .Rd = d.alias.encode(.{ .V = true }),
15526 .Rn = n.alias.encode(.{ .V = true }),
15527 .sz = .fromVectorSize(ftype),
15528 },
15529 } } },
15530 }
12035 },15531 },
12036 .sf = n.format.integer,15532 .integer => |sf| return .{ .data_processing_vector = .{ .convert_float_integer = .{
15533 .ucvtf = .{
15534 .Rd = d.alias.encode(.{ .V = true }),
15535 .Rn = n.alias.encode(.{}),
15536 .ftype = .fromVectorSize(ftype),
15537 .sf = sf,
15538 },
15539 } } },
12037 },15540 },
12038 } } };15541 .vector => |arrangement| {
15542 assert(arrangement != .@"1d" and n.format.vector == arrangement);
15543 switch (arrangement.elemSize()) {
15544 else => unreachable,
15545 .half => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous_fp16 = .{
15546 .ucvtf = .{
15547 .Rd = d.alias.encode(.{ .V = true }),
15548 .Rn = n.alias.encode(.{ .V = true }),
15549 .Q = arrangement.size(),
15550 },
15551 } } },
15552 .single, .double => return .{ .data_processing_vector = .{ .simd_two_register_miscellaneous = .{
15553 .ucvtf = .{
15554 .Rd = d.alias.encode(.{ .V = true }),
15555 .Rn = n.alias.encode(.{ .V = true }),
15556 .sz = arrangement.elemSz(),
15557 .Q = arrangement.size(),
15558 },
15559 } } },
15560 }
15561 },
15562 }
12039 }15563 }
12040 /// C6.2.387 UDF15564 /// C6.2.387 UDF
12041 pub fn udf(imm: u16) Instruction {15565 pub fn udf(imm: u16) Instruction {
...@@ -12149,7 +15673,7 @@ pub const Instruction = packed union {...@@ -12149,7 +15673,7 @@ pub const Instruction = packed union {
12149 }15673 }
1215015674
12151 comptime {15675 comptime {
12152 @setEvalBranchQuota(68_000);15676 @setEvalBranchQuota(110_000);
12153 verify(@typeName(Instruction), Instruction);15677 verify(@typeName(Instruction), Instruction);
12154 }15678 }
12155 fn verify(name: []const u8, Type: type) void {15679 fn verify(name: []const u8, Type: type) void {
test/behavior/math.zig-3
...@@ -168,7 +168,6 @@ fn testOneCtz(comptime T: type, x: T) u32 {...@@ -168,7 +168,6 @@ fn testOneCtz(comptime T: type, x: T) u32 {
168}168}
169169
170test "@ctz 128-bit integers" {170test "@ctz 128-bit integers" {
171 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
172 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO171 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
173 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO172 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
174 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;173 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
...@@ -463,7 +462,6 @@ test "binary not big int <= 128 bits" {...@@ -463,7 +462,6 @@ test "binary not big int <= 128 bits" {
463}462}
464463
465test "division" {464test "division" {
466 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
467 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO465 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
468 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO466 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
469 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;467 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
...@@ -1819,7 +1817,6 @@ test "runtime int comparison to inf is comptime-known" {...@@ -1819,7 +1817,6 @@ test "runtime int comparison to inf is comptime-known" {
1819}1817}
18201818
1821test "float divide by zero" {1819test "float divide by zero" {
1822 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1823 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO1820 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1824 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1821 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1825 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1822 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO