authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-08-12 20:43:56-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-08-15 06:12:45-04:00
log56d62395d146a6622d8b751bfed353bdd86e1421
treed03b39e14ee7cefa413bdc9426749f78313edc57
parente9eee8dace5af05f0c47f29443542783ed5fa080

aarch64: more assembler instructions

Closes #24848

4 files changed, 1463 insertions(+), 179 deletions(-)

src/codegen/aarch64/Assemble.zig+669-157
...@@ -6,11 +6,9 @@ pub const Operand = union(enum) {...@@ -6,11 +6,9 @@ pub const Operand = union(enum) {
6};6};
77
8pub fn nextInstruction(as: *Assemble) !?Instruction {8pub fn nextInstruction(as: *Assemble) !?Instruction {
9 @setEvalBranchQuota(140_000);
10 comptime var ct_token_buf: [token_buf_len]u8 = undefined;
11 var token_buf: [token_buf_len]u8 = undefined;
12 const original_source = while (true) {9 const original_source = while (true) {
13 const original_source = as.source;10 const original_source = as.source;
11 var token_buf: [token_buf_len]u8 = undefined;
14 const source_token = try as.nextToken(&token_buf, .{});12 const source_token = try as.nextToken(&token_buf, .{});
15 switch (source_token.len) {13 switch (source_token.len) {
16 0 => return null,14 0 => return null,
...@@ -27,73 +25,9 @@ pub fn nextInstruction(as: *Assemble) !?Instruction {...@@ -27,73 +25,9 @@ pub fn nextInstruction(as: *Assemble) !?Instruction {
27 \\=========================25 \\=========================
28 \\26 \\
29 , .{std.zig.fmtString(std.mem.span(original_source))});27 , .{std.zig.fmtString(std.mem.span(original_source))});
30 inline for (instructions) |instruction| {28 for (matchers) |matcher| {
31 next_pattern: {29 as.source = original_source;
32 as.source = original_source;30 if (try matcher(as)) |result| return result;
33 const Symbols = @TypeOf(instruction.symbols);
34 var symbols: Symbols: {
35 const symbols = @typeInfo(Symbols).@"struct".fields;
36 var symbol_fields: [symbols.len]std.builtin.Type.StructField = undefined;
37 for (&symbol_fields, symbols) |*symbol_field, symbol| {
38 const Storage = zonCast(SymbolSpec, @field(instruction.symbols, symbol.name), .{}).Storage();
39 symbol_field.* = .{
40 .name = symbol.name,
41 .type = Storage,
42 .default_value_ptr = null,
43 .is_comptime = false,
44 .alignment = @alignOf(Storage),
45 };
46 }
47 break :Symbols @Type(.{ .@"struct" = .{
48 .layout = .auto,
49 .fields = &symbol_fields,
50 .decls = &.{},
51 .is_tuple = false,
52 } });
53 } = undefined;
54 const Symbol = std.meta.FieldEnum(Symbols);
55 comptime var unused_symbols: std.enums.EnumSet(Symbol) = .initFull();
56 comptime var pattern_as: Assemble = .{ .source = instruction.pattern, .operands = undefined };
57 inline while (true) {
58 const pattern_token = comptime pattern_as.nextToken(&ct_token_buf, .{ .placeholders = true }) catch |err|
59 @compileError(@errorName(err) ++ " while parsing '" ++ instruction.pattern ++ "'");
60 const source_token = try as.nextToken(&token_buf, .{ .operands = true });
61 log.debug("\"{f}\" -> \"{f}\"", .{
62 std.zig.fmtString(pattern_token),
63 std.zig.fmtString(source_token),
64 });
65 if (pattern_token.len == 0) {
66 comptime var unused_symbol_it = unused_symbols.iterator();
67 inline while (comptime unused_symbol_it.next()) |unused_symbol|
68 @compileError(@tagName(unused_symbol) ++ " unused while parsing '" ++ instruction.pattern ++ "'");
69 switch (source_token.len) {
70 0 => {},
71 else => switch (source_token[0]) {
72 else => break :next_pattern,
73 '\n', ';' => {},
74 },
75 }
76 const encode = @field(Instruction, @tagName(instruction.encode[0]));
77 const Encode = @TypeOf(encode);
78 var args: std.meta.ArgsTuple(Encode) = undefined;
79 inline for (&args, @typeInfo(Encode).@"fn".params, 1..instruction.encode.len) |*arg, param, encode_index|
80 arg.* = zonCast(param.type.?, instruction.encode[encode_index], symbols);
81 return @call(.auto, encode, args);
82 } else if (pattern_token[0] == '<') {
83 const symbol_name = comptime pattern_token[1 .. std.mem.indexOfScalarPos(u8, pattern_token, 1, '|') orelse
84 pattern_token.len - 1];
85 const symbol = @field(Symbol, symbol_name);
86 const symbol_ptr = &@field(symbols, symbol_name);
87 const symbol_value = zonCast(SymbolSpec, @field(instruction.symbols, symbol_name), .{}).parse(source_token) orelse break :next_pattern;
88 if (comptime unused_symbols.contains(symbol)) {
89 log.debug("{s} = {any}", .{ symbol_name, symbol_value });
90 symbol_ptr.* = symbol_value;
91 comptime unused_symbols.remove(symbol);
92 } else if (symbol_ptr.* != symbol_value) break :next_pattern;
93 } else if (!toUpperEqlAssertUpper(source_token, pattern_token)) break :next_pattern;
94 }
95 }
96 log.debug("'{s}' not matched...", .{instruction.pattern});
97 }31 }
98 as.source = original_source;32 as.source = original_source;
99 log.debug("Nothing matched!\n", .{});33 log.debug("Nothing matched!\n", .{});
...@@ -106,6 +40,12 @@ fn zonCast(comptime Result: type, zon_value: anytype, symbols: anytype) Result {...@@ -106,6 +40,12 @@ fn zonCast(comptime Result: type, zon_value: anytype, symbols: anytype) Result {
106 switch (@typeInfo(ZonValue)) {40 switch (@typeInfo(ZonValue)) {
107 .void, .bool, .int, .float, .pointer, .comptime_float, .comptime_int, .@"enum" => return zon_value,41 .void, .bool, .int, .float, .pointer, .comptime_float, .comptime_int, .@"enum" => return zon_value,
108 .@"struct" => |zon_struct| switch (@typeInfo(Result)) {42 .@"struct" => |zon_struct| switch (@typeInfo(Result)) {
43 .pointer => |result_pointer| {
44 comptime assert(result_pointer.size == .slice and result_pointer.is_const);
45 var elems: [zon_value.len]result_pointer.child = undefined;
46 inline for (&elems, zon_value) |*elem, zon_elem| elem.* = zonCast(result_pointer.child, zon_elem, symbols);
47 return &elems;
48 },
109 .@"struct" => |result_struct| {49 .@"struct" => |result_struct| {
110 comptime var used_zon_fields = 0;50 comptime var used_zon_fields = 0;
111 var result: Result = undefined;51 var result: Result = undefined;
...@@ -158,6 +98,103 @@ fn zonCast(comptime Result: type, zon_value: anytype, symbols: anytype) Result {...@@ -158,6 +98,103 @@ fn zonCast(comptime Result: type, zon_value: anytype, symbols: anytype) Result {
158 }98 }
159}99}
160100
101const matchers = matchers: {
102 const instructions = @import("instructions.zon");
103 var mut_matchers: [instructions.len]*const fn (as: *Assemble) error{InvalidSyntax}!?Instruction = undefined;
104 for (instructions, &mut_matchers) |instruction, *matcher| matcher.* = struct {
105 fn match(as: *Assemble) !?Instruction {
106 comptime for (@typeInfo(@TypeOf(instruction)).@"struct".fields) |field| {
107 if (std.mem.eql(u8, field.name, "requires")) continue;
108 if (std.mem.eql(u8, field.name, "pattern")) continue;
109 if (std.mem.eql(u8, field.name, "symbols")) continue;
110 if (std.mem.eql(u8, field.name, "encode")) continue;
111 @compileError("unexpected field '" ++ field.name ++ "'");
112 };
113 if (@hasField(@TypeOf(instruction), "requires")) _ = zonCast(
114 []const std.Target.aarch64.Feature,
115 instruction.requires,
116 .{},
117 );
118 var symbols: Symbols: {
119 const symbols = @typeInfo(@TypeOf(instruction.symbols)).@"struct".fields;
120 var symbol_fields: [symbols.len]std.builtin.Type.StructField = undefined;
121 for (&symbol_fields, symbols) |*symbol_field, symbol| {
122 const Storage = zonCast(SymbolSpec, @field(instruction.symbols, symbol.name), .{}).Storage();
123 symbol_field.* = .{
124 .name = symbol.name,
125 .type = Storage,
126 .default_value_ptr = null,
127 .is_comptime = false,
128 .alignment = @alignOf(Storage),
129 };
130 }
131 break :Symbols @Type(.{ .@"struct" = .{
132 .layout = .auto,
133 .fields = &symbol_fields,
134 .decls = &.{},
135 .is_tuple = false,
136 } });
137 } = undefined;
138 const Symbol = std.meta.FieldEnum(@TypeOf(instruction.symbols));
139 comptime var unused_symbols: std.enums.EnumSet(Symbol) = .initFull();
140 comptime var pattern_as: Assemble = .{ .source = instruction.pattern, .operands = undefined };
141 inline while (true) {
142 comptime var ct_token_buf: [token_buf_len]u8 = undefined;
143 var token_buf: [token_buf_len]u8 = undefined;
144 const pattern_token = comptime pattern_as.nextToken(&ct_token_buf, .{ .placeholders = true }) catch |err|
145 @compileError(@errorName(err) ++ " while parsing '" ++ instruction.pattern ++ "'");
146 const source_token = try as.nextToken(&token_buf, .{ .operands = true });
147 log.debug("\"{f}\" -> \"{f}\"", .{
148 std.zig.fmtString(pattern_token),
149 std.zig.fmtString(source_token),
150 });
151 if (pattern_token.len == 0) {
152 comptime var unused_symbol_it = unused_symbols.iterator();
153 inline while (comptime unused_symbol_it.next()) |unused_symbol|
154 @compileError(@tagName(unused_symbol) ++ " unused while parsing '" ++ instruction.pattern ++ "'");
155 switch (source_token.len) {
156 0 => {},
157 else => switch (source_token[0]) {
158 else => {
159 log.debug("'{s}' not matched...", .{instruction.pattern});
160 return null;
161 },
162 '\n', ';' => {},
163 },
164 }
165 const encode = @field(Instruction, @tagName(instruction.encode[0]));
166 const Encode = @TypeOf(encode);
167 var args: std.meta.ArgsTuple(Encode) = undefined;
168 inline for (&args, @typeInfo(Encode).@"fn".params, 1..instruction.encode.len) |*arg, param, encode_index|
169 arg.* = zonCast(param.type.?, instruction.encode[encode_index], symbols);
170 return @call(.auto, encode, args);
171 } else if (pattern_token[0] == '<') {
172 const symbol_name = comptime pattern_token[1 .. std.mem.indexOfScalarPos(u8, pattern_token, 1, '|') orelse
173 pattern_token.len - 1];
174 const symbol = @field(Symbol, symbol_name);
175 const symbol_ptr = &@field(symbols, symbol_name);
176 const symbol_value = zonCast(SymbolSpec, @field(instruction.symbols, symbol_name), .{}).parse(source_token) orelse {
177 log.debug("'{s}' not matched...", .{instruction.pattern});
178 return null;
179 };
180 if (comptime unused_symbols.contains(symbol)) {
181 log.debug("{s} = {any}", .{ symbol_name, symbol_value });
182 symbol_ptr.* = symbol_value;
183 comptime unused_symbols.remove(symbol);
184 } else if (symbol_ptr.* != symbol_value) {
185 log.debug("'{s}' not matched...", .{instruction.pattern});
186 return null;
187 }
188 } else if (!toUpperEqlAssertUpper(source_token, pattern_token)) {
189 log.debug("'{s}' not matched...", .{instruction.pattern});
190 return null;
191 }
192 }
193 }
194 }.match;
195 break :matchers mut_matchers;
196};
197
161fn toUpperEqlAssertUpper(lhs: []const u8, rhs: []const u8) bool {198fn toUpperEqlAssertUpper(lhs: []const u8, rhs: []const u8) bool {
162 if (lhs.len != rhs.len) return false;199 if (lhs.len != rhs.len) return false;
163 for (lhs, rhs) |l, r| {200 for (lhs, rhs) |l, r| {
...@@ -281,9 +318,10 @@ const SymbolSpec = union(enum) {...@@ -281,9 +318,10 @@ const SymbolSpec = union(enum) {
281 multiple_of: ?comptime_int = null,318 multiple_of: ?comptime_int = null,
282 min_valid: ?comptime_int = null,319 min_valid: ?comptime_int = null,
283 max_valid: ?comptime_int = null,320 max_valid: ?comptime_int = null,
321 adjust: enum { none, neg_wrap, dec } = .none,
284 },322 },
285 fimm: struct { only_valid: ?f16 = null },323 fimm: struct { only_valid: ?f16 = null },
286 extend: struct { size: aarch64.encoding.Register.GeneralSize },324 extend: struct { size: ?aarch64.encoding.Register.GeneralSize = null },
287 shift: struct { allow_ror: bool = true },325 shift: struct { allow_ror: bool = true },
288 barrier: struct { only_sy: bool = false },326 barrier: struct { only_sy: bool = false },
289327
...@@ -293,7 +331,7 @@ const SymbolSpec = union(enum) {...@@ -293,7 +331,7 @@ const SymbolSpec = union(enum) {
293 .reg => aarch64.encoding.Register,331 .reg => aarch64.encoding.Register,
294 .arrangement => aarch64.encoding.Register.Arrangement,332 .arrangement => aarch64.encoding.Register.Arrangement,
295 .systemreg => aarch64.encoding.Register.System,333 .systemreg => aarch64.encoding.Register.System,
296 .imm => |imm| @Type(.{ .int = imm.type }),334 .imm => |imm_spec| @Type(.{ .int = imm_spec.type }),
297 .fimm => f16,335 .fimm => f16,
298 .extend => Instruction.DataProcessingRegister.AddSubtractExtendedRegister.Option,336 .extend => Instruction.DataProcessingRegister.AddSubtractExtendedRegister.Option,
299 .shift => Instruction.DataProcessingRegister.Shift.Op,337 .shift => Instruction.DataProcessingRegister.Shift.Op,
...@@ -372,7 +410,13 @@ const SymbolSpec = union(enum) {...@@ -372,7 +410,13 @@ const SymbolSpec = union(enum) {
372 return systemreg;410 return systemreg;
373 },411 },
374 .imm => |imm_spec| {412 .imm => |imm_spec| {
375 const imm = std.fmt.parseInt(Result, token, 0) catch {413 const imm = std.fmt.parseInt(@Type(.{ .int = .{
414 .signedness = imm_spec.type.signedness,
415 .bits = switch (imm_spec.adjust) {
416 .none, .neg_wrap => imm_spec.type.bits,
417 .dec => imm_spec.type.bits + 1,
418 },
419 } }), token, 0) catch {
376 log.debug("invalid immediate: \"{f}\"", .{std.zig.fmtString(token)});420 log.debug("invalid immediate: \"{f}\"", .{std.zig.fmtString(token)});
377 return null;421 return null;
378 };422 };
...@@ -388,7 +432,14 @@ const SymbolSpec = union(enum) {...@@ -388,7 +432,14 @@ const SymbolSpec = union(enum) {
388 log.debug("out of range immediate: \"{f}\"", .{std.zig.fmtString(token)});432 log.debug("out of range immediate: \"{f}\"", .{std.zig.fmtString(token)});
389 return null;433 return null;
390 };434 };
391 return imm;435 return switch (imm_spec.adjust) {
436 .none => imm,
437 .neg_wrap => -%imm,
438 .dec => std.math.cast(Result, imm - 1) orelse {
439 log.debug("out of range immediate: \"{f}\"", .{std.zig.fmtString(token)});
440 return null;
441 },
442 };
392 },443 },
393 .fimm => |fimm_spec| {444 .fimm => |fimm_spec| {
394 const full_fimm = std.fmt.parseFloat(f128, token) catch {445 const full_fimm = std.fmt.parseFloat(f128, token) catch {
...@@ -433,10 +484,10 @@ const SymbolSpec = union(enum) {...@@ -433,10 +484,10 @@ const SymbolSpec = union(enum) {
433 log.debug("invalid extend: \"{f}\"", .{std.zig.fmtString(token)});484 log.debug("invalid extend: \"{f}\"", .{std.zig.fmtString(token)});
434 return null;485 return null;
435 };486 };
436 if (extend.sf() != extend_spec.size) {487 if (extend_spec.size) |size| if (extend.sf() != size) {
437 log.debug("invalid extend: \"{f}\"", .{std.zig.fmtString(token)});488 log.debug("invalid extend: \"{f}\"", .{std.zig.fmtString(token)});
438 return null;489 return null;
439 }490 };
440 return extend;491 return extend;
441 },492 },
442 .shift => |shift_spec| {493 .shift => |shift_spec| {
...@@ -488,6 +539,16 @@ const SymbolSpec = union(enum) {...@@ -488,6 +539,16 @@ const SymbolSpec = union(enum) {
488test "add sub" {539test "add sub" {
489 var as: Assemble = .{540 var as: Assemble = .{
490 .source =541 .source =
542 \\ adc w0, w0, w1
543 \\ adc w2, w3, w4
544 \\ adc w5, w5, wzr
545 \\ adc w6, w7, wzr
546 \\
547 \\ adcs w0, w0, w1
548 \\ adcs w2, w3, w4
549 \\ adcs w5, w5, wzr
550 \\ adcs w6, w7, wzr
551 \\
491 \\ add w0, w0, w1552 \\ add w0, w0, w1
492 \\ add w2, w3, w4553 \\ add w2, w3, w4
493 \\ add wsp, w5, w6554 \\ add wsp, w5, w6
...@@ -513,13 +574,13 @@ test "add sub" {...@@ -513,13 +574,13 @@ test "add sub" {
513 \\ add w0, w0, w1574 \\ add w0, w0, w1
514 \\ add w2, w3, w4, uxtb #0575 \\ add w2, w3, w4, uxtb #0
515 \\ add wsp, w5, w6, uxth #1576 \\ add wsp, w5, w6, uxth #1
516 \\ add w7, wsp, w8, uxtw #0577 \\ add w7, wsp, w8, uxtw #2
517 \\ add wsp, wsp, w9, uxtw #2578 \\ add wsp, wsp, w9, uxtx #0
518 \\ add w10, w10, wzr, uxtw #3579 \\ add w10, w10, wzr, uxtx #3
519 \\ add w11, w12, wzr, sxtb #4580 \\ add w11, w12, wzr, sxtb #4
520 \\ add wsp, w13, wzr, sxth #0581 \\ add wsp, w13, wzr, sxth #0
521 \\ add w14, wsp, wzr, sxtw #1582 \\ add w14, wsp, wzr, sxtw #1
522 \\ add wsp, wsp, wzr, sxtw #2583 \\ add wsp, wsp, wzr, sxtx #2
523 \\584 \\
524 \\ add x0, x0, x1585 \\ add x0, x0, x1
525 \\ add x2, x3, w4, uxtb #0586 \\ add x2, x3, w4, uxtb #0
...@@ -582,6 +643,125 @@ test "add sub" {...@@ -582,6 +643,125 @@ test "add sub" {
582 \\ add xzr, xzr, x13, asr #0x1F643 \\ add xzr, xzr, x13, asr #0x1F
583 \\ add xzr, xzr, xzr, asr #0x3f644 \\ add xzr, xzr, xzr, asr #0x3f
584 \\645 \\
646 \\ addg x0, sp, #0, #0xf
647 \\ addg sp, x1, #0x3f0, #0
648 \\
649 \\ adds w0, w0, w1
650 \\ adds w2, w3, w4
651 \\ adds w5, w5, w6
652 \\ adds w7, wsp, w8
653 \\ adds w9, wsp, w9
654 \\ adds w10, w10, wzr
655 \\ adds w11, w12, wzr
656 \\ adds wzr, w13, wzr
657 \\ adds w14, wsp, wzr
658 \\ adds wzr, wsp, wzr
659 \\
660 \\ adds x0, x0, x1
661 \\ adds x2, x3, x4
662 \\ adds x5, x5, x6
663 \\ adds x7, sp, x8
664 \\ adds x9, sp, x9
665 \\ adds x10, x10, xzr
666 \\ adds x11, x12, xzr
667 \\ adds xzr, x13, xzr
668 \\ adds x14, sp, xzr
669 \\ adds xzr, sp, xzr
670 \\
671 \\ adds w0, w0, w1
672 \\ adds w2, w3, w4, uxtb #0
673 \\ adds wzr, w5, w6, uxth #1
674 \\ adds w7, wsp, w8, uxtw #2
675 \\ adds w9, wsp, w9, uxtx #0
676 \\ adds w10, w10, wzr, uxtx #3
677 \\ adds w11, w12, wzr, sxtb #4
678 \\ adds wzr, w13, wzr, sxth #0
679 \\ adds w14, wsp, wzr, sxtw #1
680 \\ adds wzr, wsp, wzr, sxtx #2
681 \\
682 \\ adds x0, x0, x1
683 \\ adds x2, x3, w4, uxtb #0
684 \\ adds xzr, x5, w6, uxth #1
685 \\ adds x7, sp, w8, uxtw #2
686 \\ adds xzr, sp, x9, uxtx #0
687 \\ adds x10, x10, xzr, uxtx #3
688 \\ adds x11, x12, wzr, sxtb #4
689 \\ adds xzr, x13, wzr, sxth #0
690 \\ adds x14, sp, wzr, sxtw #1
691 \\ adds xzr, sp, xzr, sxtx #2
692 \\
693 \\ adds w0, w0, #0
694 \\ adds w0, w1, #1, lsl #0
695 \\ adds wzr, w2, #2, lsl #12
696 \\ adds w3, wsp, #3, lsl #0
697 \\ adds wzr, wsp, #4095, lsl #12
698 \\ adds w0, w1, #0
699 \\ adds w2, w3, #0, lsl #0
700 \\ adds w4, wsp, #0
701 \\ adds w5, wsp, #0, lsl #0
702 \\ adds wzr, w6, #0
703 \\ adds wzr, w7, #0, lsl #0
704 \\ adds wzr, wsp, #0
705 \\ adds wzr, wsp, #0, lsl #0
706 \\
707 \\ adds x0, x0, #0
708 \\ adds x0, x1, #1, lsl #0
709 \\ adds xzr, x2, #2, lsl #12
710 \\ adds x3, sp, #3, lsl #0
711 \\ adds xzr, sp, #4095, lsl #12
712 \\ adds x0, x1, #0
713 \\ adds x2, x3, #0, lsl #0
714 \\ adds x4, sp, #0
715 \\ adds x5, sp, #0, lsl #0
716 \\ adds xzr, x6, #0
717 \\ adds xzr, x7, #0, lsl #0
718 \\ adds xzr, sp, #0
719 \\ adds xzr, sp, #0, lsl #0
720 \\
721 \\ adds w0, w0, w0
722 \\ adds w1, w1, w2, lsl #0
723 \\ adds w3, w4, w5, lsl #1
724 \\ adds w6, w6, wzr, lsl #31
725 \\ adds w7, wzr, w8, lsr #0
726 \\ adds w9, wzr, wzr, lsr #30
727 \\ adds wzr, w10, w11, lsr #31
728 \\ adds wzr, w12, wzr, asr #0x0
729 \\ adds wzr, wzr, w13, asr #0x10
730 \\ adds wzr, wzr, wzr, asr #0x1f
731 \\
732 \\ adds x0, x0, x0
733 \\ adds x1, x1, x2, lsl #0
734 \\ adds x3, x4, x5, lsl #1
735 \\ adds x6, x6, xzr, lsl #63
736 \\ adds x7, xzr, x8, lsr #0
737 \\ adds x9, xzr, xzr, lsr #62
738 \\ adds xzr, x10, x11, lsr #63
739 \\ adds xzr, x12, xzr, asr #0x0
740 \\ adds xzr, xzr, x13, asr #0x1F
741 \\ adds xzr, xzr, xzr, asr #0x3f
742 \\
743 \\ neg w0, w0
744 \\ neg w1, w2, lsl #0
745 \\ neg w3, wzr, lsl #7
746 \\ neg wzr, w4, lsr #14
747 \\ neg wzr, wzr, asr #21
748 \\
749 \\ neg x0, x0
750 \\ neg x1, x2, lsl #0
751 \\ neg x3, xzr, lsl #11
752 \\ neg xzr, x4, lsr #22
753 \\ neg xzr, xzr, asr #33
754 \\
755 \\ sbc w0, w0, w1
756 \\ sbc w2, w3, w4
757 \\ sbc w5, w5, wzr
758 \\ sbc w6, w7, wzr
759 \\
760 \\ sbcs w0, w0, w1
761 \\ sbcs w2, w3, w4
762 \\ sbcs w5, w5, wzr
763 \\ sbcs w6, w7, wzr
764 \\
585 \\ sub w0, w0, w1765 \\ sub w0, w0, w1
586 \\ sub w2, w3, w4766 \\ sub w2, w3, w4
587 \\ sub wsp, w5, w6767 \\ sub wsp, w5, w6
...@@ -607,13 +787,13 @@ test "add sub" {...@@ -607,13 +787,13 @@ test "add sub" {
607 \\ sub w0, w0, w1787 \\ sub w0, w0, w1
608 \\ sub w2, w3, w4, uxtb #0788 \\ sub w2, w3, w4, uxtb #0
609 \\ sub wsp, w5, w6, uxth #1789 \\ sub wsp, w5, w6, uxth #1
610 \\ sub w7, wsp, w8, uxtw #0790 \\ sub w7, wsp, w8, uxtw #2
611 \\ sub wsp, wsp, w9, uxtw #2791 \\ sub wsp, wsp, w9, uxtx #0
612 \\ sub w10, w10, wzr, uxtw #3792 \\ sub w10, w10, wzr, uxtx #3
613 \\ sub w11, w12, wzr, sxtb #4793 \\ sub w11, w12, wzr, sxtb #4
614 \\ sub wsp, w13, wzr, sxth #0794 \\ sub wsp, w13, wzr, sxth #0
615 \\ sub w14, wsp, wzr, sxtw #1795 \\ sub w14, wsp, wzr, sxtw #1
616 \\ sub wsp, wsp, wzr, sxtw #2796 \\ sub wsp, wsp, wzr, sxtx #2
617 \\797 \\
618 \\ sub x0, x0, x1798 \\ sub x0, x0, x1
619 \\ sub x2, x3, w4, uxtb #0799 \\ sub x2, x3, w4, uxtb #0
...@@ -676,21 +856,116 @@ test "add sub" {...@@ -676,21 +856,116 @@ test "add sub" {
676 \\ sub xzr, xzr, x13, asr #0x1F856 \\ sub xzr, xzr, x13, asr #0x1F
677 \\ sub xzr, xzr, xzr, asr #0x3f857 \\ sub xzr, xzr, xzr, asr #0x3f
678 \\858 \\
679 \\ neg w0, w0859 \\ subg x0, sp, #0, #0xf
680 \\ neg w1, w2, lsl #0860 \\ subg sp, x1, #0x3f0, #0
681 \\ neg w3, wzr, lsl #7861 \\
682 \\ neg wzr, w4, lsr #14862 \\ subs w0, w0, w1
683 \\ neg wzr, wzr, asr #21863 \\ subs w2, w3, w4
684 \\864 \\ subs w5, w5, w6
685 \\ neg x0, x0865 \\ subs w7, wsp, w8
686 \\ neg x1, x2, lsl #0866 \\ subs w9, wsp, w9
687 \\ neg x3, xzr, lsl #11867 \\ subs w10, w10, wzr
688 \\ neg xzr, x4, lsr #22868 \\ subs w11, w12, wzr
689 \\ neg xzr, xzr, asr #33869 \\ subs wzr, w13, wzr
870 \\ subs w14, wsp, wzr
871 \\ subs wzr, wsp, wzr
872 \\
873 \\ subs x0, x0, x1
874 \\ subs x2, x3, x4
875 \\ subs x5, x5, x6
876 \\ subs x7, sp, x8
877 \\ subs x9, sp, x9
878 \\ subs x10, x10, xzr
879 \\ subs x11, x12, xzr
880 \\ subs xzr, x13, xzr
881 \\ subs x14, sp, xzr
882 \\ subs xzr, sp, xzr
883 \\
884 \\ subs w0, w0, w1
885 \\ subs w2, w3, w4, uxtb #0
886 \\ subs wzr, w5, w6, uxth #1
887 \\ subs w7, wsp, w8, uxtw #2
888 \\ subs w9, wsp, w9, uxtx #0
889 \\ subs w10, w10, wzr, uxtx #3
890 \\ subs w11, w12, wzr, sxtb #4
891 \\ subs wzr, w13, wzr, sxth #0
892 \\ subs w14, wsp, wzr, sxtw #1
893 \\ subs wzr, wsp, wzr, sxtx #2
894 \\
895 \\ subs x0, x0, x1
896 \\ subs x2, x3, w4, uxtb #0
897 \\ subs xzr, x5, w6, uxth #1
898 \\ subs x7, sp, w8, uxtw #2
899 \\ subs xzr, sp, x9, uxtx #0
900 \\ subs x10, x10, xzr, uxtx #3
901 \\ subs x11, x12, wzr, sxtb #4
902 \\ subs xzr, x13, wzr, sxth #0
903 \\ subs x14, sp, wzr, sxtw #1
904 \\ subs xzr, sp, xzr, sxtx #2
905 \\
906 \\ subs w0, w0, #0
907 \\ subs w0, w1, #1, lsl #0
908 \\ subs wzr, w2, #2, lsl #12
909 \\ subs w3, wsp, #3, lsl #0
910 \\ subs wzr, wsp, #4095, lsl #12
911 \\ subs w0, w1, #0
912 \\ subs w2, w3, #0, lsl #0
913 \\ subs w4, wsp, #0
914 \\ subs w5, wsp, #0, lsl #0
915 \\ subs wzr, w6, #0
916 \\ subs wzr, w7, #0, lsl #0
917 \\ subs wzr, wsp, #0
918 \\ subs wzr, wsp, #0, lsl #0
919 \\
920 \\ subs x0, x0, #0
921 \\ subs x0, x1, #1, lsl #0
922 \\ subs xzr, x2, #2, lsl #12
923 \\ subs x3, sp, #3, lsl #0
924 \\ subs xzr, sp, #4095, lsl #12
925 \\ subs x0, x1, #0
926 \\ subs x2, x3, #0, lsl #0
927 \\ subs x4, sp, #0
928 \\ subs x5, sp, #0, lsl #0
929 \\ subs xzr, x6, #0
930 \\ subs xzr, x7, #0, lsl #0
931 \\ subs xzr, sp, #0
932 \\ subs xzr, sp, #0, lsl #0
933 \\
934 \\ subs w0, w0, w0
935 \\ subs w1, w1, w2, lsl #0
936 \\ subs w3, w4, w5, lsl #1
937 \\ subs w6, w6, wzr, lsl #31
938 \\ subs w7, wzr, w8, lsr #0
939 \\ subs w9, wzr, wzr, lsr #30
940 \\ subs wzr, w10, w11, lsr #31
941 \\ subs wzr, w12, wzr, asr #0x0
942 \\ subs wzr, wzr, w13, asr #0x10
943 \\ subs wzr, wzr, wzr, asr #0x1f
944 \\
945 \\ subs x0, x0, x0
946 \\ subs x1, x1, x2, lsl #0
947 \\ subs x3, x4, x5, lsl #1
948 \\ subs x6, x6, xzr, lsl #63
949 \\ subs x7, xzr, x8, lsr #0
950 \\ subs x9, xzr, xzr, lsr #62
951 \\ subs xzr, x10, x11, lsr #63
952 \\ subs xzr, x12, xzr, asr #0x0
953 \\ subs xzr, xzr, x13, asr #0x1F
954 \\ subs xzr, xzr, xzr, asr #0x3f
690 ,955 ,
691 .operands = .empty,956 .operands = .empty,
692 };957 };
693958
959 try std.testing.expectFmt("adc w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
960 try std.testing.expectFmt("adc w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
961 try std.testing.expectFmt("adc w5, w5, wzr", "{f}", .{(try as.nextInstruction()).?});
962 try std.testing.expectFmt("adc w6, w7, wzr", "{f}", .{(try as.nextInstruction()).?});
963
964 try std.testing.expectFmt("adcs w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
965 try std.testing.expectFmt("adcs w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
966 try std.testing.expectFmt("adcs w5, w5, wzr", "{f}", .{(try as.nextInstruction()).?});
967 try std.testing.expectFmt("adcs w6, w7, wzr", "{f}", .{(try as.nextInstruction()).?});
968
694 try std.testing.expectFmt("add w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});969 try std.testing.expectFmt("add w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
695 try std.testing.expectFmt("add w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});970 try std.testing.expectFmt("add w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
696 try std.testing.expectFmt("add wsp, w5, w6", "{f}", .{(try as.nextInstruction()).?});971 try std.testing.expectFmt("add wsp, w5, w6", "{f}", .{(try as.nextInstruction()).?});
...@@ -714,24 +989,24 @@ test "add sub" {...@@ -714,24 +989,24 @@ test "add sub" {
714 try std.testing.expectFmt("add sp, sp, xzr", "{f}", .{(try as.nextInstruction()).?});989 try std.testing.expectFmt("add sp, sp, xzr", "{f}", .{(try as.nextInstruction()).?});
715990
716 try std.testing.expectFmt("add w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});991 try std.testing.expectFmt("add w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
717 try std.testing.expectFmt("add w2, w3, w4, uxtb #0", "{f}", .{(try as.nextInstruction()).?});992 try std.testing.expectFmt("add w2, w3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
718 try std.testing.expectFmt("add wsp, w5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});993 try std.testing.expectFmt("add wsp, w5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
719 try std.testing.expectFmt("add w7, wsp, w8", "{f}", .{(try as.nextInstruction()).?});994 try std.testing.expectFmt("add w7, wsp, w8, lsl #2", "{f}", .{(try as.nextInstruction()).?});
720 try std.testing.expectFmt("add wsp, wsp, w9, uxtw #2", "{f}", .{(try as.nextInstruction()).?});995 try std.testing.expectFmt("add wsp, wsp, w9, uxtx", "{f}", .{(try as.nextInstruction()).?});
721 try std.testing.expectFmt("add w10, w10, wzr, uxtw #3", "{f}", .{(try as.nextInstruction()).?});996 try std.testing.expectFmt("add w10, w10, wzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
722 try std.testing.expectFmt("add w11, w12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});997 try std.testing.expectFmt("add w11, w12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
723 try std.testing.expectFmt("add wsp, w13, wzr, sxth #0", "{f}", .{(try as.nextInstruction()).?});998 try std.testing.expectFmt("add wsp, w13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
724 try std.testing.expectFmt("add w14, wsp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});999 try std.testing.expectFmt("add w14, wsp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
725 try std.testing.expectFmt("add wsp, wsp, wzr, sxtw #2", "{f}", .{(try as.nextInstruction()).?});1000 try std.testing.expectFmt("add wsp, wsp, wzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
7261001
727 try std.testing.expectFmt("add x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});1002 try std.testing.expectFmt("add x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});
728 try std.testing.expectFmt("add x2, x3, w4, uxtb #0", "{f}", .{(try as.nextInstruction()).?});1003 try std.testing.expectFmt("add x2, x3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
729 try std.testing.expectFmt("add sp, x5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});1004 try std.testing.expectFmt("add sp, x5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
730 try std.testing.expectFmt("add x7, sp, w8, uxtw #2", "{f}", .{(try as.nextInstruction()).?});1005 try std.testing.expectFmt("add x7, sp, w8, uxtw #2", "{f}", .{(try as.nextInstruction()).?});
731 try std.testing.expectFmt("add sp, sp, x9", "{f}", .{(try as.nextInstruction()).?});1006 try std.testing.expectFmt("add sp, sp, x9", "{f}", .{(try as.nextInstruction()).?});
732 try std.testing.expectFmt("add x10, x10, xzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});1007 try std.testing.expectFmt("add x10, x10, xzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
733 try std.testing.expectFmt("add x11, x12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});1008 try std.testing.expectFmt("add x11, x12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
734 try std.testing.expectFmt("add sp, x13, wzr, sxth #0", "{f}", .{(try as.nextInstruction()).?});1009 try std.testing.expectFmt("add sp, x13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
735 try std.testing.expectFmt("add x14, sp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});1010 try std.testing.expectFmt("add x14, sp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
736 try std.testing.expectFmt("add sp, sp, xzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});1011 try std.testing.expectFmt("add sp, sp, xzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
7371012
...@@ -785,6 +1060,125 @@ test "add sub" {...@@ -785,6 +1060,125 @@ test "add sub" {
785 try std.testing.expectFmt("add xzr, xzr, x13, asr #31", "{f}", .{(try as.nextInstruction()).?});1060 try std.testing.expectFmt("add xzr, xzr, x13, asr #31", "{f}", .{(try as.nextInstruction()).?});
786 try std.testing.expectFmt("add xzr, xzr, xzr, asr #63", "{f}", .{(try as.nextInstruction()).?});1061 try std.testing.expectFmt("add xzr, xzr, xzr, asr #63", "{f}", .{(try as.nextInstruction()).?});
7871062
1063 try std.testing.expectFmt("addg x0, sp, #0x0, #0xf", "{f}", .{(try as.nextInstruction()).?});
1064 try std.testing.expectFmt("addg sp, x1, #0x3f0, #0x0", "{f}", .{(try as.nextInstruction()).?});
1065
1066 try std.testing.expectFmt("adds w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
1067 try std.testing.expectFmt("adds w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
1068 try std.testing.expectFmt("adds w5, w5, w6", "{f}", .{(try as.nextInstruction()).?});
1069 try std.testing.expectFmt("adds w7, wsp, w8", "{f}", .{(try as.nextInstruction()).?});
1070 try std.testing.expectFmt("adds w9, wsp, w9", "{f}", .{(try as.nextInstruction()).?});
1071 try std.testing.expectFmt("adds w10, w10, wzr", "{f}", .{(try as.nextInstruction()).?});
1072 try std.testing.expectFmt("adds w11, w12, wzr", "{f}", .{(try as.nextInstruction()).?});
1073 try std.testing.expectFmt("cmn w13, wzr", "{f}", .{(try as.nextInstruction()).?});
1074 try std.testing.expectFmt("adds w14, wsp, wzr", "{f}", .{(try as.nextInstruction()).?});
1075 try std.testing.expectFmt("cmn wsp, wzr", "{f}", .{(try as.nextInstruction()).?});
1076
1077 try std.testing.expectFmt("adds x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});
1078 try std.testing.expectFmt("adds x2, x3, x4", "{f}", .{(try as.nextInstruction()).?});
1079 try std.testing.expectFmt("adds x5, x5, x6", "{f}", .{(try as.nextInstruction()).?});
1080 try std.testing.expectFmt("adds x7, sp, x8", "{f}", .{(try as.nextInstruction()).?});
1081 try std.testing.expectFmt("adds x9, sp, x9", "{f}", .{(try as.nextInstruction()).?});
1082 try std.testing.expectFmt("adds x10, x10, xzr", "{f}", .{(try as.nextInstruction()).?});
1083 try std.testing.expectFmt("adds x11, x12, xzr", "{f}", .{(try as.nextInstruction()).?});
1084 try std.testing.expectFmt("cmn x13, xzr", "{f}", .{(try as.nextInstruction()).?});
1085 try std.testing.expectFmt("adds x14, sp, xzr", "{f}", .{(try as.nextInstruction()).?});
1086 try std.testing.expectFmt("cmn sp, xzr", "{f}", .{(try as.nextInstruction()).?});
1087
1088 try std.testing.expectFmt("adds w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
1089 try std.testing.expectFmt("adds w2, w3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
1090 try std.testing.expectFmt("cmn w5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
1091 try std.testing.expectFmt("adds w7, wsp, w8, lsl #2", "{f}", .{(try as.nextInstruction()).?});
1092 try std.testing.expectFmt("adds w9, wsp, w9, uxtx", "{f}", .{(try as.nextInstruction()).?});
1093 try std.testing.expectFmt("adds w10, w10, wzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
1094 try std.testing.expectFmt("adds w11, w12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
1095 try std.testing.expectFmt("cmn w13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
1096 try std.testing.expectFmt("adds w14, wsp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
1097 try std.testing.expectFmt("cmn wsp, wzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
1098
1099 try std.testing.expectFmt("adds x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});
1100 try std.testing.expectFmt("adds x2, x3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
1101 try std.testing.expectFmt("cmn x5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
1102 try std.testing.expectFmt("adds x7, sp, w8, uxtw #2", "{f}", .{(try as.nextInstruction()).?});
1103 try std.testing.expectFmt("cmn sp, x9", "{f}", .{(try as.nextInstruction()).?});
1104 try std.testing.expectFmt("adds x10, x10, xzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
1105 try std.testing.expectFmt("adds x11, x12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
1106 try std.testing.expectFmt("cmn x13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
1107 try std.testing.expectFmt("adds x14, sp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
1108 try std.testing.expectFmt("cmn sp, xzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
1109
1110 try std.testing.expectFmt("adds w0, w0, #0x0", "{f}", .{(try as.nextInstruction()).?});
1111 try std.testing.expectFmt("adds w0, w1, #0x1", "{f}", .{(try as.nextInstruction()).?});
1112 try std.testing.expectFmt("adds wzr, w2, #0x2, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1113 try std.testing.expectFmt("adds w3, wsp, #0x3", "{f}", .{(try as.nextInstruction()).?});
1114 try std.testing.expectFmt("adds wzr, wsp, #0xfff, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1115 try std.testing.expectFmt("adds w0, w1, #0x0", "{f}", .{(try as.nextInstruction()).?});
1116 try std.testing.expectFmt("adds w2, w3, #0x0", "{f}", .{(try as.nextInstruction()).?});
1117 try std.testing.expectFmt("adds w4, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1118 try std.testing.expectFmt("adds w5, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1119 try std.testing.expectFmt("adds wzr, w6, #0x0", "{f}", .{(try as.nextInstruction()).?});
1120 try std.testing.expectFmt("adds wzr, w7, #0x0", "{f}", .{(try as.nextInstruction()).?});
1121 try std.testing.expectFmt("adds wzr, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1122 try std.testing.expectFmt("adds wzr, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1123
1124 try std.testing.expectFmt("adds x0, x0, #0x0", "{f}", .{(try as.nextInstruction()).?});
1125 try std.testing.expectFmt("adds x0, x1, #0x1", "{f}", .{(try as.nextInstruction()).?});
1126 try std.testing.expectFmt("adds xzr, x2, #0x2, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1127 try std.testing.expectFmt("adds x3, sp, #0x3", "{f}", .{(try as.nextInstruction()).?});
1128 try std.testing.expectFmt("adds xzr, sp, #0xfff, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1129 try std.testing.expectFmt("adds x0, x1, #0x0", "{f}", .{(try as.nextInstruction()).?});
1130 try std.testing.expectFmt("adds x2, x3, #0x0", "{f}", .{(try as.nextInstruction()).?});
1131 try std.testing.expectFmt("adds x4, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1132 try std.testing.expectFmt("adds x5, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1133 try std.testing.expectFmt("adds xzr, x6, #0x0", "{f}", .{(try as.nextInstruction()).?});
1134 try std.testing.expectFmt("adds xzr, x7, #0x0", "{f}", .{(try as.nextInstruction()).?});
1135 try std.testing.expectFmt("adds xzr, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1136 try std.testing.expectFmt("adds xzr, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1137
1138 try std.testing.expectFmt("adds w0, w0, w0", "{f}", .{(try as.nextInstruction()).?});
1139 try std.testing.expectFmt("adds w1, w1, w2", "{f}", .{(try as.nextInstruction()).?});
1140 try std.testing.expectFmt("adds w3, w4, w5, lsl #1", "{f}", .{(try as.nextInstruction()).?});
1141 try std.testing.expectFmt("adds w6, w6, wzr, lsl #31", "{f}", .{(try as.nextInstruction()).?});
1142 try std.testing.expectFmt("adds w7, wzr, w8, lsr #0", "{f}", .{(try as.nextInstruction()).?});
1143 try std.testing.expectFmt("adds w9, wzr, wzr, lsr #30", "{f}", .{(try as.nextInstruction()).?});
1144 try std.testing.expectFmt("cmn w10, w11, lsr #31", "{f}", .{(try as.nextInstruction()).?});
1145 try std.testing.expectFmt("cmn w12, wzr, asr #0", "{f}", .{(try as.nextInstruction()).?});
1146 try std.testing.expectFmt("cmn wzr, w13, asr #16", "{f}", .{(try as.nextInstruction()).?});
1147 try std.testing.expectFmt("cmn wzr, wzr, asr #31", "{f}", .{(try as.nextInstruction()).?});
1148
1149 try std.testing.expectFmt("adds x0, x0, x0", "{f}", .{(try as.nextInstruction()).?});
1150 try std.testing.expectFmt("adds x1, x1, x2", "{f}", .{(try as.nextInstruction()).?});
1151 try std.testing.expectFmt("adds x3, x4, x5, lsl #1", "{f}", .{(try as.nextInstruction()).?});
1152 try std.testing.expectFmt("adds x6, x6, xzr, lsl #63", "{f}", .{(try as.nextInstruction()).?});
1153 try std.testing.expectFmt("adds x7, xzr, x8, lsr #0", "{f}", .{(try as.nextInstruction()).?});
1154 try std.testing.expectFmt("adds x9, xzr, xzr, lsr #62", "{f}", .{(try as.nextInstruction()).?});
1155 try std.testing.expectFmt("cmn x10, x11, lsr #63", "{f}", .{(try as.nextInstruction()).?});
1156 try std.testing.expectFmt("cmn x12, xzr, asr #0", "{f}", .{(try as.nextInstruction()).?});
1157 try std.testing.expectFmt("cmn xzr, x13, asr #31", "{f}", .{(try as.nextInstruction()).?});
1158 try std.testing.expectFmt("cmn xzr, xzr, asr #63", "{f}", .{(try as.nextInstruction()).?});
1159
1160 try std.testing.expectFmt("neg w0, w0", "{f}", .{(try as.nextInstruction()).?});
1161 try std.testing.expectFmt("neg w1, w2", "{f}", .{(try as.nextInstruction()).?});
1162 try std.testing.expectFmt("neg w3, wzr, lsl #7", "{f}", .{(try as.nextInstruction()).?});
1163 try std.testing.expectFmt("neg wzr, w4, lsr #14", "{f}", .{(try as.nextInstruction()).?});
1164 try std.testing.expectFmt("neg wzr, wzr, asr #21", "{f}", .{(try as.nextInstruction()).?});
1165
1166 try std.testing.expectFmt("neg x0, x0", "{f}", .{(try as.nextInstruction()).?});
1167 try std.testing.expectFmt("neg x1, x2", "{f}", .{(try as.nextInstruction()).?});
1168 try std.testing.expectFmt("neg x3, xzr, lsl #11", "{f}", .{(try as.nextInstruction()).?});
1169 try std.testing.expectFmt("neg xzr, x4, lsr #22", "{f}", .{(try as.nextInstruction()).?});
1170 try std.testing.expectFmt("neg xzr, xzr, asr #33", "{f}", .{(try as.nextInstruction()).?});
1171
1172 try std.testing.expectFmt("sbc w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
1173 try std.testing.expectFmt("sbc w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
1174 try std.testing.expectFmt("sbc w5, w5, wzr", "{f}", .{(try as.nextInstruction()).?});
1175 try std.testing.expectFmt("sbc w6, w7, wzr", "{f}", .{(try as.nextInstruction()).?});
1176
1177 try std.testing.expectFmt("sbcs w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
1178 try std.testing.expectFmt("sbcs w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
1179 try std.testing.expectFmt("sbcs w5, w5, wzr", "{f}", .{(try as.nextInstruction()).?});
1180 try std.testing.expectFmt("sbcs w6, w7, wzr", "{f}", .{(try as.nextInstruction()).?});
1181
788 try std.testing.expectFmt("sub w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});1182 try std.testing.expectFmt("sub w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
789 try std.testing.expectFmt("sub w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});1183 try std.testing.expectFmt("sub w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
790 try std.testing.expectFmt("sub wsp, w5, w6", "{f}", .{(try as.nextInstruction()).?});1184 try std.testing.expectFmt("sub wsp, w5, w6", "{f}", .{(try as.nextInstruction()).?});
...@@ -808,24 +1202,24 @@ test "add sub" {...@@ -808,24 +1202,24 @@ test "add sub" {
808 try std.testing.expectFmt("sub sp, sp, xzr", "{f}", .{(try as.nextInstruction()).?});1202 try std.testing.expectFmt("sub sp, sp, xzr", "{f}", .{(try as.nextInstruction()).?});
8091203
810 try std.testing.expectFmt("sub w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});1204 try std.testing.expectFmt("sub w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
811 try std.testing.expectFmt("sub w2, w3, w4, uxtb #0", "{f}", .{(try as.nextInstruction()).?});1205 try std.testing.expectFmt("sub w2, w3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
812 try std.testing.expectFmt("sub wsp, w5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});1206 try std.testing.expectFmt("sub wsp, w5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
813 try std.testing.expectFmt("sub w7, wsp, w8", "{f}", .{(try as.nextInstruction()).?});1207 try std.testing.expectFmt("sub w7, wsp, w8, lsl #2", "{f}", .{(try as.nextInstruction()).?});
814 try std.testing.expectFmt("sub wsp, wsp, w9, uxtw #2", "{f}", .{(try as.nextInstruction()).?});1208 try std.testing.expectFmt("sub wsp, wsp, w9, uxtx", "{f}", .{(try as.nextInstruction()).?});
815 try std.testing.expectFmt("sub w10, w10, wzr, uxtw #3", "{f}", .{(try as.nextInstruction()).?});1209 try std.testing.expectFmt("sub w10, w10, wzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
816 try std.testing.expectFmt("sub w11, w12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});1210 try std.testing.expectFmt("sub w11, w12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
817 try std.testing.expectFmt("sub wsp, w13, wzr, sxth #0", "{f}", .{(try as.nextInstruction()).?});1211 try std.testing.expectFmt("sub wsp, w13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
818 try std.testing.expectFmt("sub w14, wsp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});1212 try std.testing.expectFmt("sub w14, wsp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
819 try std.testing.expectFmt("sub wsp, wsp, wzr, sxtw #2", "{f}", .{(try as.nextInstruction()).?});1213 try std.testing.expectFmt("sub wsp, wsp, wzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
8201214
821 try std.testing.expectFmt("sub x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});1215 try std.testing.expectFmt("sub x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});
822 try std.testing.expectFmt("sub x2, x3, w4, uxtb #0", "{f}", .{(try as.nextInstruction()).?});1216 try std.testing.expectFmt("sub x2, x3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
823 try std.testing.expectFmt("sub sp, x5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});1217 try std.testing.expectFmt("sub sp, x5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
824 try std.testing.expectFmt("sub x7, sp, w8, uxtw #2", "{f}", .{(try as.nextInstruction()).?});1218 try std.testing.expectFmt("sub x7, sp, w8, uxtw #2", "{f}", .{(try as.nextInstruction()).?});
825 try std.testing.expectFmt("sub sp, sp, x9", "{f}", .{(try as.nextInstruction()).?});1219 try std.testing.expectFmt("sub sp, sp, x9", "{f}", .{(try as.nextInstruction()).?});
826 try std.testing.expectFmt("sub x10, x10, xzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});1220 try std.testing.expectFmt("sub x10, x10, xzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
827 try std.testing.expectFmt("sub x11, x12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});1221 try std.testing.expectFmt("sub x11, x12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
828 try std.testing.expectFmt("sub sp, x13, wzr, sxth #0", "{f}", .{(try as.nextInstruction()).?});1222 try std.testing.expectFmt("sub sp, x13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
829 try std.testing.expectFmt("sub x14, sp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});1223 try std.testing.expectFmt("sub x14, sp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
830 try std.testing.expectFmt("sub sp, sp, xzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});1224 try std.testing.expectFmt("sub sp, sp, xzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
8311225
...@@ -879,17 +1273,102 @@ test "add sub" {...@@ -879,17 +1273,102 @@ test "add sub" {
879 try std.testing.expectFmt("neg xzr, x13, asr #31", "{f}", .{(try as.nextInstruction()).?});1273 try std.testing.expectFmt("neg xzr, x13, asr #31", "{f}", .{(try as.nextInstruction()).?});
880 try std.testing.expectFmt("neg xzr, xzr, asr #63", "{f}", .{(try as.nextInstruction()).?});1274 try std.testing.expectFmt("neg xzr, xzr, asr #63", "{f}", .{(try as.nextInstruction()).?});
8811275
882 try std.testing.expectFmt("neg w0, w0", "{f}", .{(try as.nextInstruction()).?});1276 try std.testing.expectFmt("subg x0, sp, #0x0, #0xf", "{f}", .{(try as.nextInstruction()).?});
883 try std.testing.expectFmt("neg w1, w2", "{f}", .{(try as.nextInstruction()).?});1277 try std.testing.expectFmt("subg sp, x1, #0x3f0, #0x0", "{f}", .{(try as.nextInstruction()).?});
884 try std.testing.expectFmt("neg w3, wzr, lsl #7", "{f}", .{(try as.nextInstruction()).?});1278
885 try std.testing.expectFmt("neg wzr, w4, lsr #14", "{f}", .{(try as.nextInstruction()).?});1279 try std.testing.expectFmt("subs w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
886 try std.testing.expectFmt("neg wzr, wzr, asr #21", "{f}", .{(try as.nextInstruction()).?});1280 try std.testing.expectFmt("subs w2, w3, w4", "{f}", .{(try as.nextInstruction()).?});
8871281 try std.testing.expectFmt("subs w5, w5, w6", "{f}", .{(try as.nextInstruction()).?});
888 try std.testing.expectFmt("neg x0, x0", "{f}", .{(try as.nextInstruction()).?});1282 try std.testing.expectFmt("subs w7, wsp, w8", "{f}", .{(try as.nextInstruction()).?});
889 try std.testing.expectFmt("neg x1, x2", "{f}", .{(try as.nextInstruction()).?});1283 try std.testing.expectFmt("subs w9, wsp, w9", "{f}", .{(try as.nextInstruction()).?});
890 try std.testing.expectFmt("neg x3, xzr, lsl #11", "{f}", .{(try as.nextInstruction()).?});1284 try std.testing.expectFmt("subs w10, w10, wzr", "{f}", .{(try as.nextInstruction()).?});
891 try std.testing.expectFmt("neg xzr, x4, lsr #22", "{f}", .{(try as.nextInstruction()).?});1285 try std.testing.expectFmt("subs w11, w12, wzr", "{f}", .{(try as.nextInstruction()).?});
892 try std.testing.expectFmt("neg xzr, xzr, asr #33", "{f}", .{(try as.nextInstruction()).?});1286 try std.testing.expectFmt("cmp w13, wzr", "{f}", .{(try as.nextInstruction()).?});
1287 try std.testing.expectFmt("subs w14, wsp, wzr", "{f}", .{(try as.nextInstruction()).?});
1288 try std.testing.expectFmt("cmp wsp, wzr", "{f}", .{(try as.nextInstruction()).?});
1289
1290 try std.testing.expectFmt("subs x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});
1291 try std.testing.expectFmt("subs x2, x3, x4", "{f}", .{(try as.nextInstruction()).?});
1292 try std.testing.expectFmt("subs x5, x5, x6", "{f}", .{(try as.nextInstruction()).?});
1293 try std.testing.expectFmt("subs x7, sp, x8", "{f}", .{(try as.nextInstruction()).?});
1294 try std.testing.expectFmt("subs x9, sp, x9", "{f}", .{(try as.nextInstruction()).?});
1295 try std.testing.expectFmt("subs x10, x10, xzr", "{f}", .{(try as.nextInstruction()).?});
1296 try std.testing.expectFmt("subs x11, x12, xzr", "{f}", .{(try as.nextInstruction()).?});
1297 try std.testing.expectFmt("cmp x13, xzr", "{f}", .{(try as.nextInstruction()).?});
1298 try std.testing.expectFmt("subs x14, sp, xzr", "{f}", .{(try as.nextInstruction()).?});
1299 try std.testing.expectFmt("cmp sp, xzr", "{f}", .{(try as.nextInstruction()).?});
1300
1301 try std.testing.expectFmt("subs w0, w0, w1", "{f}", .{(try as.nextInstruction()).?});
1302 try std.testing.expectFmt("subs w2, w3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
1303 try std.testing.expectFmt("cmp w5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
1304 try std.testing.expectFmt("subs w7, wsp, w8, lsl #2", "{f}", .{(try as.nextInstruction()).?});
1305 try std.testing.expectFmt("subs w9, wsp, w9, uxtx", "{f}", .{(try as.nextInstruction()).?});
1306 try std.testing.expectFmt("subs w10, w10, wzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
1307 try std.testing.expectFmt("subs w11, w12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
1308 try std.testing.expectFmt("cmp w13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
1309 try std.testing.expectFmt("subs w14, wsp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
1310 try std.testing.expectFmt("cmp wsp, wzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
1311
1312 try std.testing.expectFmt("subs x0, x0, x1", "{f}", .{(try as.nextInstruction()).?});
1313 try std.testing.expectFmt("subs x2, x3, w4, uxtb", "{f}", .{(try as.nextInstruction()).?});
1314 try std.testing.expectFmt("cmp x5, w6, uxth #1", "{f}", .{(try as.nextInstruction()).?});
1315 try std.testing.expectFmt("subs x7, sp, w8, uxtw #2", "{f}", .{(try as.nextInstruction()).?});
1316 try std.testing.expectFmt("cmp sp, x9", "{f}", .{(try as.nextInstruction()).?});
1317 try std.testing.expectFmt("subs x10, x10, xzr, uxtx #3", "{f}", .{(try as.nextInstruction()).?});
1318 try std.testing.expectFmt("subs x11, x12, wzr, sxtb #4", "{f}", .{(try as.nextInstruction()).?});
1319 try std.testing.expectFmt("cmp x13, wzr, sxth", "{f}", .{(try as.nextInstruction()).?});
1320 try std.testing.expectFmt("subs x14, sp, wzr, sxtw #1", "{f}", .{(try as.nextInstruction()).?});
1321 try std.testing.expectFmt("cmp sp, xzr, sxtx #2", "{f}", .{(try as.nextInstruction()).?});
1322
1323 try std.testing.expectFmt("subs w0, w0, #0x0", "{f}", .{(try as.nextInstruction()).?});
1324 try std.testing.expectFmt("subs w0, w1, #0x1", "{f}", .{(try as.nextInstruction()).?});
1325 try std.testing.expectFmt("subs wzr, w2, #0x2, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1326 try std.testing.expectFmt("subs w3, wsp, #0x3", "{f}", .{(try as.nextInstruction()).?});
1327 try std.testing.expectFmt("subs wzr, wsp, #0xfff, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1328 try std.testing.expectFmt("subs w0, w1, #0x0", "{f}", .{(try as.nextInstruction()).?});
1329 try std.testing.expectFmt("subs w2, w3, #0x0", "{f}", .{(try as.nextInstruction()).?});
1330 try std.testing.expectFmt("subs w4, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1331 try std.testing.expectFmt("subs w5, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1332 try std.testing.expectFmt("subs wzr, w6, #0x0", "{f}", .{(try as.nextInstruction()).?});
1333 try std.testing.expectFmt("subs wzr, w7, #0x0", "{f}", .{(try as.nextInstruction()).?});
1334 try std.testing.expectFmt("subs wzr, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1335 try std.testing.expectFmt("subs wzr, wsp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1336
1337 try std.testing.expectFmt("subs x0, x0, #0x0", "{f}", .{(try as.nextInstruction()).?});
1338 try std.testing.expectFmt("subs x0, x1, #0x1", "{f}", .{(try as.nextInstruction()).?});
1339 try std.testing.expectFmt("subs xzr, x2, #0x2, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1340 try std.testing.expectFmt("subs x3, sp, #0x3", "{f}", .{(try as.nextInstruction()).?});
1341 try std.testing.expectFmt("subs xzr, sp, #0xfff, lsl #12", "{f}", .{(try as.nextInstruction()).?});
1342 try std.testing.expectFmt("subs x0, x1, #0x0", "{f}", .{(try as.nextInstruction()).?});
1343 try std.testing.expectFmt("subs x2, x3, #0x0", "{f}", .{(try as.nextInstruction()).?});
1344 try std.testing.expectFmt("subs x4, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1345 try std.testing.expectFmt("subs x5, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1346 try std.testing.expectFmt("subs xzr, x6, #0x0", "{f}", .{(try as.nextInstruction()).?});
1347 try std.testing.expectFmt("subs xzr, x7, #0x0", "{f}", .{(try as.nextInstruction()).?});
1348 try std.testing.expectFmt("subs xzr, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1349 try std.testing.expectFmt("subs xzr, sp, #0x0", "{f}", .{(try as.nextInstruction()).?});
1350
1351 try std.testing.expectFmt("subs w0, w0, w0", "{f}", .{(try as.nextInstruction()).?});
1352 try std.testing.expectFmt("subs w1, w1, w2", "{f}", .{(try as.nextInstruction()).?});
1353 try std.testing.expectFmt("subs w3, w4, w5, lsl #1", "{f}", .{(try as.nextInstruction()).?});
1354 try std.testing.expectFmt("subs w6, w6, wzr, lsl #31", "{f}", .{(try as.nextInstruction()).?});
1355 try std.testing.expectFmt("negs w7, w8, lsr #0", "{f}", .{(try as.nextInstruction()).?});
1356 try std.testing.expectFmt("negs w9, wzr, lsr #30", "{f}", .{(try as.nextInstruction()).?});
1357 try std.testing.expectFmt("cmp w10, w11, lsr #31", "{f}", .{(try as.nextInstruction()).?});
1358 try std.testing.expectFmt("cmp w12, wzr, asr #0", "{f}", .{(try as.nextInstruction()).?});
1359 try std.testing.expectFmt("cmp wzr, w13, asr #16", "{f}", .{(try as.nextInstruction()).?});
1360 try std.testing.expectFmt("cmp wzr, wzr, asr #31", "{f}", .{(try as.nextInstruction()).?});
1361
1362 try std.testing.expectFmt("subs x0, x0, x0", "{f}", .{(try as.nextInstruction()).?});
1363 try std.testing.expectFmt("subs x1, x1, x2", "{f}", .{(try as.nextInstruction()).?});
1364 try std.testing.expectFmt("subs x3, x4, x5, lsl #1", "{f}", .{(try as.nextInstruction()).?});
1365 try std.testing.expectFmt("subs x6, x6, xzr, lsl #63", "{f}", .{(try as.nextInstruction()).?});
1366 try std.testing.expectFmt("negs x7, x8, lsr #0", "{f}", .{(try as.nextInstruction()).?});
1367 try std.testing.expectFmt("negs x9, xzr, lsr #62", "{f}", .{(try as.nextInstruction()).?});
1368 try std.testing.expectFmt("cmp x10, x11, lsr #63", "{f}", .{(try as.nextInstruction()).?});
1369 try std.testing.expectFmt("cmp x12, xzr, asr #0", "{f}", .{(try as.nextInstruction()).?});
1370 try std.testing.expectFmt("cmp xzr, x13, asr #31", "{f}", .{(try as.nextInstruction()).?});
1371 try std.testing.expectFmt("cmp xzr, xzr, asr #63", "{f}", .{(try as.nextInstruction()).?});
8931372
894 try std.testing.expect(null == try as.nextInstruction());1373 try std.testing.expect(null == try as.nextInstruction());
895}1374}
...@@ -966,44 +1445,62 @@ test "bit manipulation" {...@@ -966,44 +1445,62 @@ test "bit manipulation" {
966test "bitfield" {1445test "bitfield" {
967 var as: Assemble = .{1446 var as: Assemble = .{
968 .source =1447 .source =
969 \\sbfm w0, w0, #0, #311448 \\bfc w0, #1, #31
970 \\sbfm w0, w0, #31, #01449 \\bfc w1, #31, #1
971 \\1450 \\bfc x2, #1, #63
972 \\sbfm x0, x0, #0, #631451 \\bfc x3, #63, #1
973 \\sbfm x0, x0, #63, #01452 \\
974 \\1453 \\bfi w0, w1, #1, #31
975 \\bfm w0, w0, #0, #311454 \\bfi w2, wzr, #31, #1
976 \\bfm w0, w0, #31, #01455 \\bfi x3, xzr, #1, #63
977 \\1456 \\bfi x4, x5, #63, #1
978 \\bfm x0, x0, #0, #631457 \\
979 \\bfm x0, x0, #63, #01458 \\bfm w0, wzr, #25, #5
980 \\1459 \\bfm w1, w2, #31, #1
981 \\ubfm w0, w0, #0, #311460 \\bfm w3, w4, #1, #31
982 \\ubfm w0, w0, #31, #01461 \\bfm x5, xzr, #57, #7
983 \\1462 \\bfm x6, x7, #63, #1
984 \\ubfm x0, x0, #0, #631463 \\bfm x8, x9, #1, #63
985 \\ubfm x0, x0, #63, #01464 \\
1465 \\sbfm w0, w1, #31, #1
1466 \\sbfm w2, w3, #1, #31
1467 \\sbfm x4, x5, #63, #1
1468 \\sbfm x6, x7, #1, #63
1469 \\
1470 \\ubfm w0, w1, #31, #1
1471 \\ubfm w2, w3, #1, #31
1472 \\ubfm x4, x5, #63, #1
1473 \\ubfm x6, x7, #1, #63
986 ,1474 ,
987 .operands = .empty,1475 .operands = .empty,
988 };1476 };
9891477
990 try std.testing.expectFmt("sbfm w0, w0, #0, #31", "{f}", .{(try as.nextInstruction()).?});1478 try std.testing.expectFmt("bfc w0, #1, #31", "{f}", .{(try as.nextInstruction()).?});
991 try std.testing.expectFmt("sbfm w0, w0, #31, #0", "{f}", .{(try as.nextInstruction()).?});1479 try std.testing.expectFmt("bfc w1, #31, #1", "{f}", .{(try as.nextInstruction()).?});
9921480 try std.testing.expectFmt("bfc x2, #1, #63", "{f}", .{(try as.nextInstruction()).?});
993 try std.testing.expectFmt("sbfm x0, x0, #0, #63", "{f}", .{(try as.nextInstruction()).?});1481 try std.testing.expectFmt("bfc x3, #63, #1", "{f}", .{(try as.nextInstruction()).?});
994 try std.testing.expectFmt("sbfm x0, x0, #63, #0", "{f}", .{(try as.nextInstruction()).?});1482
9951483 try std.testing.expectFmt("bfi w0, w1, #1, #31", "{f}", .{(try as.nextInstruction()).?});
996 try std.testing.expectFmt("bfm w0, w0, #0, #31", "{f}", .{(try as.nextInstruction()).?});1484 try std.testing.expectFmt("bfc w2, #31, #1", "{f}", .{(try as.nextInstruction()).?});
997 try std.testing.expectFmt("bfm w0, w0, #31, #0", "{f}", .{(try as.nextInstruction()).?});1485 try std.testing.expectFmt("bfc x3, #1, #63", "{f}", .{(try as.nextInstruction()).?});
9981486 try std.testing.expectFmt("bfi x4, x5, #63, #1", "{f}", .{(try as.nextInstruction()).?});
999 try std.testing.expectFmt("bfm x0, x0, #0, #63", "{f}", .{(try as.nextInstruction()).?});1487
1000 try std.testing.expectFmt("bfm x0, x0, #63, #0", "{f}", .{(try as.nextInstruction()).?});1488 try std.testing.expectFmt("bfc w0, #7, #6", "{f}", .{(try as.nextInstruction()).?});
10011489 try std.testing.expectFmt("bfi w1, w2, #1, #2", "{f}", .{(try as.nextInstruction()).?});
1002 try std.testing.expectFmt("ubfm w0, w0, #0, #31", "{f}", .{(try as.nextInstruction()).?});1490 try std.testing.expectFmt("bfxil w3, w4, #1, #31", "{f}", .{(try as.nextInstruction()).?});
1003 try std.testing.expectFmt("ubfm w0, w0, #31, #0", "{f}", .{(try as.nextInstruction()).?});1491 try std.testing.expectFmt("bfc x5, #7, #8", "{f}", .{(try as.nextInstruction()).?});
10041492 try std.testing.expectFmt("bfi x6, x7, #1, #2", "{f}", .{(try as.nextInstruction()).?});
1005 try std.testing.expectFmt("ubfm x0, x0, #0, #63", "{f}", .{(try as.nextInstruction()).?});1493 try std.testing.expectFmt("bfxil x8, x9, #1, #63", "{f}", .{(try as.nextInstruction()).?});
1006 try std.testing.expectFmt("ubfm x0, x0, #63, #0", "{f}", .{(try as.nextInstruction()).?});1494
1495 try std.testing.expectFmt("sbfiz w0, w1, #1, #2", "{f}", .{(try as.nextInstruction()).?});
1496 try std.testing.expectFmt("sbfx w2, w3, #1, #31", "{f}", .{(try as.nextInstruction()).?});
1497 try std.testing.expectFmt("sbfiz x4, x5, #1, #2", "{f}", .{(try as.nextInstruction()).?});
1498 try std.testing.expectFmt("sbfx x6, x7, #1, #63", "{f}", .{(try as.nextInstruction()).?});
1499
1500 try std.testing.expectFmt("ubfiz w0, w1, #1, #2", "{f}", .{(try as.nextInstruction()).?});
1501 try std.testing.expectFmt("ubfx w2, w3, #1, #31", "{f}", .{(try as.nextInstruction()).?});
1502 try std.testing.expectFmt("ubfiz x4, x5, #1, #2", "{f}", .{(try as.nextInstruction()).?});
1503 try std.testing.expectFmt("ubfx x6, x7, #1, #63", "{f}", .{(try as.nextInstruction()).?});
10071504
1008 try std.testing.expect(null == try as.nextInstruction());1505 try std.testing.expect(null == try as.nextInstruction());
1009}1506}
...@@ -1113,6 +1610,22 @@ test "extract" {...@@ -1113,6 +1610,22 @@ test "extract" {
11131610
1114 try std.testing.expect(null == try as.nextInstruction());1611 try std.testing.expect(null == try as.nextInstruction());
1115}1612}
1613test "flags" {
1614 var as: Assemble = .{
1615 .source =
1616 \\AXFLAG
1617 \\CFINV
1618 \\XAFLAG
1619 ,
1620 .operands = .empty,
1621 };
1622
1623 try std.testing.expectFmt("axflag", "{f}", .{(try as.nextInstruction()).?});
1624 try std.testing.expectFmt("cfinv", "{f}", .{(try as.nextInstruction()).?});
1625 try std.testing.expectFmt("xaflag", "{f}", .{(try as.nextInstruction()).?});
1626
1627 try std.testing.expect(null == try as.nextInstruction());
1628}
1116test "hints" {1629test "hints" {
1117 var as: Assemble = .{1630 var as: Assemble = .{
1118 .source =1631 .source =
...@@ -2935,6 +3448,5 @@ const aarch64 = @import("../aarch64.zig");...@@ -2935,6 +3448,5 @@ const aarch64 = @import("../aarch64.zig");
2935const Assemble = @This();3448const Assemble = @This();
2936const assert = std.debug.assert;3449const assert = std.debug.assert;
2937const Instruction = aarch64.encoding.Instruction;3450const Instruction = aarch64.encoding.Instruction;
2938const instructions = @import("instructions.zon");
2939const std = @import("std");3451const std = @import("std");
2940const log = std.log.scoped(.@"asm");3452const log = std.log.scoped(.@"asm");
src/codegen/aarch64/Disassemble.zig+96-16
...@@ -80,7 +80,22 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr...@@ -80,7 +80,22 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr
80 @tagName(sh),80 @tagName(sh),
81 });81 });
82 },82 },
83 .add_subtract_immediate_with_tags => {},83 .add_subtract_immediate_with_tags => |add_subtract_immediate_with_tags| {
84 const decoded = add_subtract_immediate_with_tags.decode();
85 if (decoded == .unallocated) break :unallocated;
86 const group = add_subtract_immediate_with_tags.group;
87 return writer.print("{f}{s}{f}{s}{f}{s}#0x{x}{s}#0x{x}", .{
88 fmtCase(decoded, dis.case),
89 dis.mnemonic_operands_separator,
90 group.Rd.decode(.{ .sp = true }).x().fmtCase(dis.case),
91 dis.operands_separator,
92 group.Rn.decode(.{ .sp = true }).x().fmtCase(dis.case),
93 dis.operands_separator,
94 @as(u10, group.uimm6) << 4,
95 dis.operands_separator,
96 group.uimm4,
97 });
98 },
84 .logical_immediate => |logical_immediate| {99 .logical_immediate => |logical_immediate| {
85 const decoded = logical_immediate.decode();100 const decoded = logical_immediate.decode();
86 if (decoded == .unallocated) break :unallocated;101 if (decoded == .unallocated) break :unallocated;
...@@ -172,17 +187,69 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr...@@ -172,17 +187,69 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr
172 if (decoded == .unallocated) break :unallocated;187 if (decoded == .unallocated) break :unallocated;
173 const group = bitfield.group;188 const group = bitfield.group;
174 const sf = group.sf;189 const sf = group.sf;
175 return writer.print("{f}{s}{f}{s}{f}{s}#{d}{s}#{d}", .{190 const Rd = group.Rd.decode(.{}).general(sf);
191 const Rn = group.Rn.decode(.{}).general(sf);
192 return if (!dis.enable_aliases) writer.print("{f}{s}{f}{s}{f}{s}#{d}{s}#{d}", .{
176 fmtCase(decoded, dis.case),193 fmtCase(decoded, dis.case),
177 dis.mnemonic_operands_separator,194 dis.mnemonic_operands_separator,
178 group.Rd.decode(.{}).general(sf).fmtCase(dis.case),195 Rd.fmtCase(dis.case),
179 dis.operands_separator,196 dis.operands_separator,
180 group.Rn.decode(.{}).general(sf).fmtCase(dis.case),197 Rn.fmtCase(dis.case),
181 dis.operands_separator,198 dis.operands_separator,
182 group.imm.immr,199 group.imm.immr,
183 dis.operands_separator,200 dis.operands_separator,
184 group.imm.imms,201 group.imm.imms,
185 });202 }) else if (group.imm.imms >= group.imm.immr) writer.print("{f}{s}{f}{s}{f}{s}#{d}{s}#{d}", .{
203 fmtCase(@as(enum { sbfx, bfxil, ubfx }, switch (decoded) {
204 .unallocated => unreachable,
205 .sbfm => .sbfx,
206 .bfm => .bfxil,
207 .ubfm => .ubfx,
208 }), dis.case),
209 dis.mnemonic_operands_separator,
210 Rd.fmtCase(dis.case),
211 dis.operands_separator,
212 Rn.fmtCase(dis.case),
213 dis.operands_separator,
214 group.imm.immr,
215 dis.operands_separator,
216 switch (sf) {
217 .word => @as(u6, group.imm.imms - group.imm.immr) + 1,
218 .doubleword => @as(u7, group.imm.imms - group.imm.immr) + 1,
219 },
220 }) else {
221 const prefer_bfc = switch (decoded) {
222 .unallocated => unreachable,
223 .sbfm, .ubfm => false,
224 .bfm => Rn.alias == .zr,
225 };
226 try writer.print("{f}{s}{f}", .{
227 fmtCase(@as(enum { sbfiz, bfc, bfi, ubfiz }, switch (decoded) {
228 .unallocated => unreachable,
229 .sbfm => .sbfiz,
230 .bfm => if (prefer_bfc) .bfc else .bfi,
231 .ubfm => .ubfiz,
232 }), dis.case),
233 dis.mnemonic_operands_separator,
234 Rd.fmtCase(dis.case),
235 });
236 if (!prefer_bfc) try writer.print("{s}{f}", .{
237 dis.operands_separator,
238 Rn.fmtCase(dis.case),
239 });
240 try writer.print("{s}#{d}{s}#{d}", .{
241 dis.operands_separator,
242 switch (sf) {
243 .word => -%@as(u5, @intCast(group.imm.immr)),
244 .doubleword => -%@as(u6, @intCast(group.imm.immr)),
245 },
246 dis.operands_separator,
247 switch (sf) {
248 .word => @as(u6, group.imm.imms) + 1,
249 .doubleword => @as(u7, group.imm.imms) + 1,
250 },
251 });
252 };
186 },253 },
187 .extract => |extract| {254 .extract => |extract| {
188 const decoded = extract.decode();255 const decoded = extract.decode();
...@@ -249,7 +316,11 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr...@@ -249,7 +316,11 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr
249 else => |decoded| return writer.print("{f}", .{fmtCase(decoded, dis.case)}),316 else => |decoded| return writer.print("{f}", .{fmtCase(decoded, dis.case)}),
250 },317 },
251 .barriers => {},318 .barriers => {},
252 .pstate => {},319 .pstate => |pstate| {
320 const decoded = pstate.decode();
321 if (decoded == .unallocated) break :unallocated;
322 return writer.print("{f}", .{fmtCase(decoded, dis.case)});
323 },
253 .system_result => {},324 .system_result => {},
254 .system => {},325 .system => {},
255 .system_register_move => {},326 .system_register_move => {},
...@@ -695,9 +766,19 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr...@@ -695,9 +766,19 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr
695 if (decoded == .unallocated) break :unallocated;766 if (decoded == .unallocated) break :unallocated;
696 const group = add_subtract_extended_register.group;767 const group = add_subtract_extended_register.group;
697 const sf = group.sf;768 const sf = group.sf;
698 const Rm = group.Rm.decode(.{}).general(group.option.sf());769 const Rm = group.Rm.decode(.{}).general(switch (sf) {
770 .word => .word,
771 .doubleword => group.option.sf(),
772 });
699 const Rn = group.Rn.decode(.{ .sp = true }).general(sf);773 const Rn = group.Rn.decode(.{ .sp = true }).general(sf);
700 const Rd = group.Rd.decode(.{ .sp = true }).general(sf);774 const Rd = group.Rd.decode(.{ .sp = !group.S }).general(sf);
775 const prefer_lsl = (Rd.alias == .sp or Rn.alias == .sp) and group.option == @as(
776 aarch64.encoding.Instruction.DataProcessingRegister.AddSubtractExtendedRegister.Option,
777 switch (sf) {
778 .word => .uxtw,
779 .doubleword => .uxtx,
780 },
781 );
701 if (dis.enable_aliases and group.S and Rd.alias == .zr) try writer.print("{f}{s}{f}{s}{f}", .{782 if (dis.enable_aliases and group.S and Rd.alias == .zr) try writer.print("{f}{s}{f}{s}{f}", .{
702 fmtCase(@as(enum { cmn, cmp }, switch (group.op) {783 fmtCase(@as(enum { cmn, cmp }, switch (group.op) {
703 .add => .cmn,784 .add => .cmn,
...@@ -716,14 +797,13 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr...@@ -716,14 +797,13 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr
716 dis.operands_separator,797 dis.operands_separator,
717 Rm.fmtCase(dis.case),798 Rm.fmtCase(dis.case),
718 });799 });
719 return if (group.option != @as(aarch64.encoding.Instruction.DataProcessingRegister.AddSubtractExtendedRegister.Option, switch (sf) {800 return if (!prefer_lsl or group.imm3 != 0) {
720 .word => .uxtw,801 try writer.print("{s}{f}", .{
721 .doubleword => .uxtx,802 dis.operands_separator,
722 }) or group.imm3 != 0) writer.print("{s}{f} #{d}", .{803 if (prefer_lsl) fmtCase(.lsl, dis.case) else fmtCase(group.option, dis.case),
723 dis.operands_separator,804 });
724 fmtCase(group.option, dis.case),805 if (group.imm3 != 0) try writer.print(" #{d}", .{group.imm3});
725 group.imm3,806 };
726 });
727 },807 },
728 .add_subtract_with_carry => |add_subtract_with_carry| {808 .add_subtract_with_carry => |add_subtract_with_carry| {
729 const decoded = add_subtract_with_carry.decode();809 const decoded = add_subtract_with_carry.decode();
src/codegen/aarch64/encoding.zig+63-4
...@@ -2563,6 +2563,10 @@ pub const Instruction = packed union {...@@ -2563,6 +2563,10 @@ pub const Instruction = packed union {
2563 /// PSTATE2563 /// PSTATE
2564 pub const Pstate = packed union {2564 pub const Pstate = packed union {
2565 group: @This().Group,2565 group: @This().Group,
2566 msr: Msr,
2567 cfinv: Cfinv,
2568 xaflag: Xaflag,
2569 axflag: Axflag,
25662570
2567 pub const Group = packed struct {2571 pub const Group = packed struct {
2568 Rt: Register.Encoded,2572 Rt: Register.Encoded,
...@@ -2615,6 +2619,7 @@ pub const Instruction = packed union {...@@ -2615,6 +2619,7 @@ pub const Instruction = packed union {
26152619
2616 pub const Decoded = union(enum) {2620 pub const Decoded = union(enum) {
2617 unallocated,2621 unallocated,
2622 msr: Msr,
2618 cfinv: Cfinv,2623 cfinv: Cfinv,
2619 xaflag: Xaflag,2624 xaflag: Xaflag,
2620 axflag: Axflag,2625 axflag: Axflag,
...@@ -11414,7 +11419,10 @@ pub const Instruction = packed union {...@@ -11414,7 +11419,10 @@ pub const Instruction = packed union {
11414 assert(n.format.general == sf);11419 assert(n.format.general == sf);
11415 form: switch (form) {11420 form: switch (form) {
11416 .extended_register_explicit => |extended_register_explicit| {11421 .extended_register_explicit => |extended_register_explicit| {
11417 assert(extended_register_explicit.register.format.general == extended_register_explicit.option.sf());11422 assert(extended_register_explicit.register.format.general == switch (sf) {
11423 .word => .word,
11424 .doubleword => extended_register_explicit.option.sf(),
11425 });
11418 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{11426 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{
11419 .add = .{11427 .add = .{
11420 .Rd = d.alias.encode(.{ .sp = true }),11428 .Rd = d.alias.encode(.{ .sp = true }),
...@@ -11484,6 +11492,18 @@ pub const Instruction = packed union {...@@ -11484,6 +11492,18 @@ pub const Instruction = packed union {
11484 } },11492 } },
11485 }11493 }
11486 }11494 }
11495 /// C7.2.6 ADDG
11496 pub fn addg(d: Register, n: Register, uimm6: u10, uimm4: u4) Instruction {
11497 assert(d.format.general == .doubleword and n.format.general == .doubleword);
11498 return .{ .data_processing_immediate = .{ .add_subtract_immediate_with_tags = .{
11499 .addg = .{
11500 .Xd = d.alias.encode(.{ .sp = true }),
11501 .Xn = n.alias.encode(.{ .sp = true }),
11502 .uimm4 = uimm4,
11503 .uimm6 = @intCast(@shrExact(uimm6, 4)),
11504 },
11505 } } };
11506 }
11487 /// C7.2.4 ADDP (scalar)11507 /// C7.2.4 ADDP (scalar)
11488 /// C7.2.5 ADDP (vector)11508 /// C7.2.5 ADDP (vector)
11489 pub fn addp(d: Register, n: Register, form: union(enum) {11509 pub fn addp(d: Register, n: Register, form: union(enum) {
...@@ -11536,7 +11556,10 @@ pub const Instruction = packed union {...@@ -11536,7 +11556,10 @@ pub const Instruction = packed union {
11536 assert(n.format.general == sf);11556 assert(n.format.general == sf);
11537 form: switch (form) {11557 form: switch (form) {
11538 .extended_register_explicit => |extended_register_explicit| {11558 .extended_register_explicit => |extended_register_explicit| {
11539 assert(extended_register_explicit.register.format.general == extended_register_explicit.option.sf());11559 assert(extended_register_explicit.register.format.general == switch (sf) {
11560 .word => .word,
11561 .doubleword => extended_register_explicit.option.sf(),
11562 });
11540 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{11563 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{
11541 .adds = .{11564 .adds = .{
11542 .Rd = d.alias.encode(.{}),11565 .Rd = d.alias.encode(.{}),
...@@ -11768,6 +11791,12 @@ pub const Instruction = packed union {...@@ -11768,6 +11791,12 @@ pub const Instruction = packed union {
11768 },11791 },
11769 } } };11792 } } };
11770 }11793 }
11794 /// C6.2.24 AXFLAG
11795 pub fn axflag() Instruction {
11796 return .{ .branch_exception_generating_system = .{ .pstate = .{
11797 .axflag = .{},
11798 } } };
11799 }
11771 /// C6.2.25 B11800 /// C6.2.25 B
11772 pub fn b(label: i28) Instruction {11801 pub fn b(label: i28) Instruction {
11773 return .{ .branch_exception_generating_system = .{ .unconditional_branch_immediate = .{11802 return .{ .branch_exception_generating_system = .{ .unconditional_branch_immediate = .{
...@@ -12066,6 +12095,12 @@ pub const Instruction = packed union {...@@ -12066,6 +12095,12 @@ pub const Instruction = packed union {
12066 } } },12095 } } },
12067 }12096 }
12068 }12097 }
12098 /// C6.2.52 CFINV
12099 pub fn cfinv() Instruction {
12100 return .{ .branch_exception_generating_system = .{ .pstate = .{
12101 .cfinv = .{},
12102 } } };
12103 }
12069 /// C6.2.56 CLREX12104 /// C6.2.56 CLREX
12070 pub fn clrex(imm: u4) Instruction {12105 pub fn clrex(imm: u4) Instruction {
12071 return .{ .branch_exception_generating_system = .{ .barriers = .{12106 return .{ .branch_exception_generating_system = .{ .barriers = .{
...@@ -16057,7 +16092,10 @@ pub const Instruction = packed union {...@@ -16057,7 +16092,10 @@ pub const Instruction = packed union {
16057 assert(n.format.general == sf);16092 assert(n.format.general == sf);
16058 form: switch (form) {16093 form: switch (form) {
16059 .extended_register_explicit => |extended_register_explicit| {16094 .extended_register_explicit => |extended_register_explicit| {
16060 assert(extended_register_explicit.register.format.general == extended_register_explicit.option.sf());16095 assert(extended_register_explicit.register.format.general == switch (sf) {
16096 .word => .word,
16097 .doubleword => extended_register_explicit.option.sf(),
16098 });
16061 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{16099 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{
16062 .sub = .{16100 .sub = .{
16063 .Rd = d.alias.encode(.{ .sp = true }),16101 .Rd = d.alias.encode(.{ .sp = true }),
...@@ -16127,6 +16165,18 @@ pub const Instruction = packed union {...@@ -16127,6 +16165,18 @@ pub const Instruction = packed union {
16127 } },16165 } },
16128 }16166 }
16129 }16167 }
16168 /// C7.2.359 SUBG
16169 pub fn subg(d: Register, n: Register, uimm6: u10, uimm4: u4) Instruction {
16170 assert(d.format.general == .doubleword and n.format.general == .doubleword);
16171 return .{ .data_processing_immediate = .{ .add_subtract_immediate_with_tags = .{
16172 .subg = .{
16173 .Xd = d.alias.encode(.{ .sp = true }),
16174 .Xn = n.alias.encode(.{ .sp = true }),
16175 .uimm4 = uimm4,
16176 .uimm6 = @intCast(@shrExact(uimm6, 4)),
16177 },
16178 } } };
16179 }
16130 /// C6.2.362 SUBS (extended register)16180 /// C6.2.362 SUBS (extended register)
16131 /// C6.2.363 SUBS (immediate)16181 /// C6.2.363 SUBS (immediate)
16132 /// C6.2.364 SUBS (shifted register)16182 /// C6.2.364 SUBS (shifted register)
...@@ -16147,7 +16197,10 @@ pub const Instruction = packed union {...@@ -16147,7 +16197,10 @@ pub const Instruction = packed union {
16147 assert(n.format.general == sf);16197 assert(n.format.general == sf);
16148 form: switch (form) {16198 form: switch (form) {
16149 .extended_register_explicit => |extended_register_explicit| {16199 .extended_register_explicit => |extended_register_explicit| {
16150 assert(extended_register_explicit.register.format.general == extended_register_explicit.option.sf());16200 assert(extended_register_explicit.register.format.general == switch (sf) {
16201 .word => .word,
16202 .doubleword => extended_register_explicit.option.sf(),
16203 });
16151 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{16204 return .{ .data_processing_register = .{ .add_subtract_extended_register = .{
16152 .subs = .{16205 .subs = .{
16153 .Rd = d.alias.encode(.{}),16206 .Rd = d.alias.encode(.{}),
...@@ -16471,6 +16524,12 @@ pub const Instruction = packed union {...@@ -16471,6 +16524,12 @@ pub const Instruction = packed union {
16471 .wfi = .{},16524 .wfi = .{},
16472 } } };16525 } } };
16473 }16526 }
16527 /// C6.2.400 XAFLAG
16528 pub fn xaflag() Instruction {
16529 return .{ .branch_exception_generating_system = .{ .pstate = .{
16530 .xaflag = .{},
16531 } } };
16532 }
16474 /// C6.2.402 YIELD16533 /// C6.2.402 YIELD
16475 pub fn yield() Instruction {16534 pub fn yield() Instruction {
16476 return .{ .branch_exception_generating_system = .{ .hints = .{16535 return .{ .branch_exception_generating_system = .{ .hints = .{
src/codegen/aarch64/instructions.zon+635-2
...@@ -1,4 +1,42 @@...@@ -1,4 +1,42 @@
1.{1.{
2 // C6.2.1 ADC
3 .{
4 .pattern = "ADC <Wd>, <Wn>, <Wm>",
5 .symbols = .{
6 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
7 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
8 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
9 },
10 .encode = .{ .adc, .Wd, .Wn, .Wm },
11 },
12 .{
13 .pattern = "ADC <Xd>, <Xn>, <Xm>",
14 .symbols = .{
15 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
16 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
17 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
18 },
19 .encode = .{ .adc, .Xd, .Xn, .Xm },
20 },
21 // C6.2.2 ADCS
22 .{
23 .pattern = "ADCS <Wd>, <Wn>, <Wm>",
24 .symbols = .{
25 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
26 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
27 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
28 },
29 .encode = .{ .adcs, .Wd, .Wn, .Wm },
30 },
31 .{
32 .pattern = "ADCS <Xd>, <Xn>, <Xm>",
33 .symbols = .{
34 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
35 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
36 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
37 },
38 .encode = .{ .adcs, .Xd, .Xn, .Xm },
39 },
2 // C6.2.3 ADD (extended register)40 // C6.2.3 ADD (extended register)
3 .{41 .{
4 .pattern = "ADD <Wd|WSP>, <Wn|WSP>, <Wm>",42 .pattern = "ADD <Wd|WSP>, <Wn|WSP>, <Wm>",
...@@ -9,13 +47,27 @@...@@ -9,13 +47,27 @@
9 },47 },
10 .encode = .{ .add, .Wd, .Wn, .{ .register = .Wm } },48 .encode = .{ .add, .Wd, .Wn, .{ .register = .Wm } },
11 },49 },
50 .{
51 .pattern = "ADD <Wd|WSP>, <Wn|WSP>, <Wm>, <extend>",
52 .symbols = .{
53 .Wd = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
54 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
55 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
56 .extend = .{ .extend = .{} },
57 },
58 .encode = .{ .add, .Wd, .Wn, .{ .extended_register_explicit = .{
59 .register = .Wm,
60 .option = .extend,
61 .amount = 0,
62 } } },
63 },
12 .{64 .{
13 .pattern = "ADD <Wd|WSP>, <Wn|WSP>, <Wm>, <extend> #<amount>",65 .pattern = "ADD <Wd|WSP>, <Wn|WSP>, <Wm>, <extend> #<amount>",
14 .symbols = .{66 .symbols = .{
15 .Wd = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },67 .Wd = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
16 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },68 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
17 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },69 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
18 .extend = .{ .extend = .{ .size = .word } },70 .extend = .{ .extend = .{} },
19 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },71 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
20 },72 },
21 .encode = .{ .add, .Wd, .Wn, .{ .extended_register_explicit = .{73 .encode = .{ .add, .Wd, .Wn, .{ .extended_register_explicit = .{
...@@ -33,6 +85,20 @@...@@ -33,6 +85,20 @@
33 },85 },
34 .encode = .{ .add, .Xd, .Xn, .{ .register = .Xm } },86 .encode = .{ .add, .Xd, .Xn, .{ .register = .Xm } },
35 },87 },
88 .{
89 .pattern = "ADD <Xd|SP>, <Xn|SP>, <Wm>, <extend>",
90 .symbols = .{
91 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
92 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
93 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
94 .extend = .{ .extend = .{ .size = .word } },
95 },
96 .encode = .{ .add, .Xd, .Xn, .{ .extended_register_explicit = .{
97 .register = .Wm,
98 .option = .extend,
99 .amount = 0,
100 } } },
101 },
36 .{102 .{
37 .pattern = "ADD <Xd|SP>, <Xn|SP>, <Wm>, <extend> #<amount>",103 .pattern = "ADD <Xd|SP>, <Xn|SP>, <Wm>, <extend> #<amount>",
38 .symbols = .{104 .symbols = .{
...@@ -48,6 +114,20 @@...@@ -48,6 +114,20 @@
48 .amount = .amount,114 .amount = .amount,
49 } } },115 } } },
50 },116 },
117 .{
118 .pattern = "ADD <Xd|SP>, <Xn|SP>, <Xm>, <extend>",
119 .symbols = .{
120 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
121 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
122 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
123 .extend = .{ .extend = .{ .size = .doubleword } },
124 },
125 .encode = .{ .add, .Xd, .Xn, .{ .extended_register_explicit = .{
126 .register = .Xm,
127 .option = .extend,
128 .amount = 0,
129 } } },
130 },
51 .{131 .{
52 .pattern = "ADD <Xd|SP>, <Xn|SP>, <Xm>, <extend> #<amount>",132 .pattern = "ADD <Xd|SP>, <Xn|SP>, <Xm>, <extend> #<amount>",
53 .symbols = .{133 .symbols = .{
...@@ -151,6 +231,212 @@...@@ -151,6 +231,212 @@
151 .amount = .amount,231 .amount = .amount,
152 } } },232 } } },
153 },233 },
234 // C6.2.6 ADDG
235 .{
236 .requires = .{.mte},
237 .pattern = "ADDG <Xd|SP>, <Xn|SP>, #<uimm6>, #<uimm4>",
238 .symbols = .{
239 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
240 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
241 .uimm6 = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 10 }, .multiple_of = 16 } },
242 .uimm4 = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 4 } } },
243 },
244 .encode = .{ .addg, .Xd, .Xn, .uimm6, .uimm4 },
245 },
246 // C6.2.7 ADDS (extended register)
247 .{
248 .pattern = "ADDS <Wd>, <Wn|WSP>, <Wm>",
249 .symbols = .{
250 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
251 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
252 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
253 },
254 .encode = .{ .adds, .Wd, .Wn, .{ .register = .Wm } },
255 },
256 .{
257 .pattern = "ADDS <Wd>, <Wn|WSP>, <Wm>, <extend>",
258 .symbols = .{
259 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
260 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
261 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
262 .extend = .{ .extend = .{} },
263 },
264 .encode = .{ .adds, .Wd, .Wn, .{ .extended_register_explicit = .{
265 .register = .Wm,
266 .option = .extend,
267 .amount = 0,
268 } } },
269 },
270 .{
271 .pattern = "ADDS <Wd>, <Wn|WSP>, <Wm>, <extend> #<amount>",
272 .symbols = .{
273 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
274 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
275 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
276 .extend = .{ .extend = .{} },
277 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
278 },
279 .encode = .{ .adds, .Wd, .Wn, .{ .extended_register_explicit = .{
280 .register = .Wm,
281 .option = .extend,
282 .amount = .amount,
283 } } },
284 },
285 .{
286 .pattern = "ADDS <Xd>, <Xn|SP>, <Xm>",
287 .symbols = .{
288 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
289 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
290 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
291 },
292 .encode = .{ .adds, .Xd, .Xn, .{ .register = .Xm } },
293 },
294 .{
295 .pattern = "ADDS <Xd>, <Xn|SP>, <Wm>, <extend>",
296 .symbols = .{
297 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
298 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
299 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
300 .extend = .{ .extend = .{ .size = .word } },
301 },
302 .encode = .{ .adds, .Xd, .Xn, .{ .extended_register_explicit = .{
303 .register = .Wm,
304 .option = .extend,
305 .amount = 0,
306 } } },
307 },
308 .{
309 .pattern = "ADDS <Xd>, <Xn|SP>, <Wm>, <extend> #<amount>",
310 .symbols = .{
311 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
312 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
313 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
314 .extend = .{ .extend = .{ .size = .word } },
315 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
316 },
317 .encode = .{ .adds, .Xd, .Xn, .{ .extended_register_explicit = .{
318 .register = .Wm,
319 .option = .extend,
320 .amount = .amount,
321 } } },
322 },
323 .{
324 .pattern = "ADDS <Xd>, <Xn|SP>, <Xm>, <extend>",
325 .symbols = .{
326 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
327 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
328 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
329 .extend = .{ .extend = .{ .size = .doubleword } },
330 },
331 .encode = .{ .adds, .Xd, .Xn, .{ .extended_register_explicit = .{
332 .register = .Xm,
333 .option = .extend,
334 .amount = 0,
335 } } },
336 },
337 .{
338 .pattern = "ADDS <Xd>, <Xn|SP>, <Xm>, <extend> #<amount>",
339 .symbols = .{
340 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
341 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
342 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
343 .extend = .{ .extend = .{ .size = .doubleword } },
344 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
345 },
346 .encode = .{ .adds, .Xd, .Xn, .{ .extended_register_explicit = .{
347 .register = .Xm,
348 .option = .extend,
349 .amount = .amount,
350 } } },
351 },
352 // C6.2.8 ADDS (immediate)
353 .{
354 .pattern = "ADDS <Wd>, <Wn|WSP>, #<imm>",
355 .symbols = .{
356 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
357 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
358 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
359 },
360 .encode = .{ .adds, .Wd, .Wn, .{ .immediate = .imm } },
361 },
362 .{
363 .pattern = "ADDS <Wd>, <Wn|WSP>, #<imm>, LSL #<shift>",
364 .symbols = .{
365 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
366 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
367 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
368 .shift = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 4 }, .multiple_of = 12 } },
369 },
370 .encode = .{ .adds, .Wd, .Wn, .{ .shifted_immediate = .{ .immediate = .imm, .lsl = .shift } } },
371 },
372 .{
373 .pattern = "ADDS <Xd>, <Xn|SP>, #<imm>",
374 .symbols = .{
375 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
376 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
377 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
378 },
379 .encode = .{ .adds, .Xd, .Xn, .{ .immediate = .imm } },
380 },
381 .{
382 .pattern = "ADDS <Xd>, <Xn|SP>, #<imm>, LSL #<shift>",
383 .symbols = .{
384 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
385 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
386 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
387 .shift = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 4 }, .multiple_of = 12 } },
388 },
389 .encode = .{ .adds, .Xd, .Xn, .{ .shifted_immediate = .{ .immediate = .imm, .lsl = .shift } } },
390 },
391 // C6.2.9 ADDS (shifted register)
392 .{
393 .pattern = "ADDS <Wd>, <Wn>, <Wm>",
394 .symbols = .{
395 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
396 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
397 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
398 },
399 .encode = .{ .adds, .Wd, .Wn, .{ .register = .Wm } },
400 },
401 .{
402 .pattern = "ADDS <Wd>, <Wn>, <Wm>, <shift> #<amount>",
403 .symbols = .{
404 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
405 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
406 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
407 .shift = .{ .shift = .{ .allow_ror = false } },
408 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 5 } } },
409 },
410 .encode = .{ .adds, .Wd, .Wn, .{ .shifted_register_explicit = .{
411 .register = .Wm,
412 .shift = .shift,
413 .amount = .amount,
414 } } },
415 },
416 .{
417 .pattern = "ADDS <Xd>, <Xn>, <Xm>",
418 .symbols = .{
419 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
420 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
421 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
422 },
423 .encode = .{ .adds, .Xd, .Xn, .{ .register = .Xm } },
424 },
425 .{
426 .pattern = "ADDS <Xd>, <Xn>, <Xm>, <shift> #<amount>",
427 .symbols = .{
428 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
429 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
430 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
431 .shift = .{ .shift = .{ .allow_ror = false } },
432 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 6 } } },
433 },
434 .encode = .{ .adds, .Xd, .Xn, .{ .shifted_register_explicit = .{
435 .register = .Xm,
436 .shift = .shift,
437 .amount = .amount,
438 } } },
439 },
154 // C6.2.13 AND (shifted register)440 // C6.2.13 AND (shifted register)
155 .{441 .{
156 .pattern = "AND <Wd>, <Wn>, <Wm>",442 .pattern = "AND <Wd>, <Wn>, <Wm>",
...@@ -306,6 +592,53 @@...@@ -306,6 +592,53 @@
306 },592 },
307 .encode = .{ .asrv, .Xd, .Xn, .Xm },593 .encode = .{ .asrv, .Xd, .Xn, .Xm },
308 },594 },
595 // C6.2.24 AXFLAG
596 .{
597 .requires = .{.altnzcv},
598 .pattern = "AXFLAG",
599 .symbols = .{},
600 .encode = .{.axflag},
601 },
602 // C6.2.28 BFC
603 .{
604 .pattern = "BFC <Wd>, #<lsb>, #<width>",
605 .symbols = .{
606 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
607 .lsb = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 5 }, .adjust = .neg_wrap } },
608 .width = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 5 }, .adjust = .dec } },
609 },
610 .encode = .{ .bfm, .Wd, .wzr, .{ .N = .word, .immr = .lsb, .imms = .width } },
611 },
612 .{
613 .pattern = "BFC <Xd>, #<lsb>, #<width>",
614 .symbols = .{
615 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
616 .lsb = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 6 }, .adjust = .neg_wrap } },
617 .width = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 6 }, .adjust = .dec } },
618 },
619 .encode = .{ .bfm, .Xd, .xzr, .{ .N = .doubleword, .immr = .lsb, .imms = .width } },
620 },
621 // C6.2.29 BFI
622 .{
623 .pattern = "BFI <Wd>, <Wn>, #<lsb>, #<width>",
624 .symbols = .{
625 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
626 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
627 .lsb = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 5 }, .adjust = .neg_wrap } },
628 .width = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 5 }, .adjust = .dec } },
629 },
630 .encode = .{ .bfm, .Wd, .Wn, .{ .N = .word, .immr = .lsb, .imms = .width } },
631 },
632 .{
633 .pattern = "BFI <Xd>, <Xn>, #<lsb>, #<width>",
634 .symbols = .{
635 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
636 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
637 .lsb = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 6 }, .adjust = .neg_wrap } },
638 .width = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 6 }, .adjust = .dec } },
639 },
640 .encode = .{ .bfm, .Xd, .Xn, .{ .N = .doubleword, .immr = .lsb, .imms = .width } },
641 },
309 // C6.2.30 BFM642 // C6.2.30 BFM
310 .{643 .{
311 .pattern = "BFM <Wd>, <Wn>, #<immr>, #<imms>",644 .pattern = "BFM <Wd>, <Wn>, #<immr>, #<imms>",
...@@ -351,6 +684,13 @@...@@ -351,6 +684,13 @@
351 },684 },
352 .encode = .{ .brk, .imm },685 .encode = .{ .brk, .imm },
353 },686 },
687 // C6.2.52 CFINV
688 .{
689 .requires = .{.flagm},
690 .pattern = "CFINV",
691 .symbols = .{},
692 .encode = .{.cfinv},
693 },
354 // C6.2.56 CLREX694 // C6.2.56 CLREX
355 .{695 .{
356 .pattern = "CLREX",696 .pattern = "CLREX",
...@@ -1391,6 +1731,44 @@...@@ -1391,6 +1731,44 @@
1391 },1731 },
1392 .encode = .{ .rorv, .Xd, .Xn, .Xm },1732 .encode = .{ .rorv, .Xd, .Xn, .Xm },
1393 },1733 },
1734 // C6.2.265 SBC
1735 .{
1736 .pattern = "SBC <Wd>, <Wn>, <Wm>",
1737 .symbols = .{
1738 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
1739 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
1740 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
1741 },
1742 .encode = .{ .sbc, .Wd, .Wn, .Wm },
1743 },
1744 .{
1745 .pattern = "SBC <Xd>, <Xn>, <Xm>",
1746 .symbols = .{
1747 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
1748 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
1749 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
1750 },
1751 .encode = .{ .sbc, .Xd, .Xn, .Xm },
1752 },
1753 // C6.2.266 SBCS
1754 .{
1755 .pattern = "SBCS <Wd>, <Wn>, <Wm>",
1756 .symbols = .{
1757 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
1758 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
1759 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
1760 },
1761 .encode = .{ .sbcs, .Wd, .Wn, .Wm },
1762 },
1763 .{
1764 .pattern = "SBCS <Xd>, <Xn>, <Xm>",
1765 .symbols = .{
1766 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
1767 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
1768 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
1769 },
1770 .encode = .{ .sbcs, .Xd, .Xn, .Xm },
1771 },
1394 // C6.2.268 SBFM1772 // C6.2.268 SBFM
1395 .{1773 .{
1396 .pattern = "SBFM <Wd>, <Wn>, #<immr>, #<imms>",1774 .pattern = "SBFM <Wd>, <Wn>, #<immr>, #<imms>",
...@@ -1663,13 +2041,27 @@...@@ -1663,13 +2041,27 @@
1663 },2041 },
1664 .encode = .{ .sub, .Wd, .Wn, .{ .register = .Wm } },2042 .encode = .{ .sub, .Wd, .Wn, .{ .register = .Wm } },
1665 },2043 },
2044 .{
2045 .pattern = "SUB <Wd|WSP>, <Wn|WSP>, <Wm>, <extend>",
2046 .symbols = .{
2047 .Wd = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2048 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2049 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2050 .extend = .{ .extend = .{} },
2051 },
2052 .encode = .{ .sub, .Wd, .Wn, .{ .extended_register_explicit = .{
2053 .register = .Wm,
2054 .option = .extend,
2055 .amount = 0,
2056 } } },
2057 },
1666 .{2058 .{
1667 .pattern = "SUB <Wd|WSP>, <Wn|WSP>, <Wm>, <extend> #<amount>",2059 .pattern = "SUB <Wd|WSP>, <Wn|WSP>, <Wm>, <extend> #<amount>",
1668 .symbols = .{2060 .symbols = .{
1669 .Wd = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },2061 .Wd = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
1670 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },2062 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
1671 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },2063 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
1672 .extend = .{ .extend = .{ .size = .word } },2064 .extend = .{ .extend = .{} },
1673 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },2065 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
1674 },2066 },
1675 .encode = .{ .sub, .Wd, .Wn, .{ .extended_register_explicit = .{2067 .encode = .{ .sub, .Wd, .Wn, .{ .extended_register_explicit = .{
...@@ -1687,6 +2079,20 @@...@@ -1687,6 +2079,20 @@
1687 },2079 },
1688 .encode = .{ .sub, .Xd, .Xn, .{ .register = .Xm } },2080 .encode = .{ .sub, .Xd, .Xn, .{ .register = .Xm } },
1689 },2081 },
2082 .{
2083 .pattern = "SUB <Xd|SP>, <Xn|SP>, <Wm>, <extend>",
2084 .symbols = .{
2085 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2086 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2087 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2088 .extend = .{ .extend = .{ .size = .word } },
2089 },
2090 .encode = .{ .sub, .Xd, .Xn, .{ .extended_register_explicit = .{
2091 .register = .Wm,
2092 .option = .extend,
2093 .amount = 0,
2094 } } },
2095 },
1690 .{2096 .{
1691 .pattern = "SUB <Xd|SP>, <Xn|SP>, <Wm>, <extend> #<amount>",2097 .pattern = "SUB <Xd|SP>, <Xn|SP>, <Wm>, <extend> #<amount>",
1692 .symbols = .{2098 .symbols = .{
...@@ -1702,6 +2108,20 @@...@@ -1702,6 +2108,20 @@
1702 .amount = .amount,2108 .amount = .amount,
1703 } } },2109 } } },
1704 },2110 },
2111 .{
2112 .pattern = "SUB <Xd|SP>, <Xn|SP>, <Xm>, <extend>",
2113 .symbols = .{
2114 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2115 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2116 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2117 .extend = .{ .extend = .{ .size = .doubleword } },
2118 },
2119 .encode = .{ .sub, .Xd, .Xn, .{ .extended_register_explicit = .{
2120 .register = .Xm,
2121 .option = .extend,
2122 .amount = 0,
2123 } } },
2124 },
1705 .{2125 .{
1706 .pattern = "SUB <Xd|SP>, <Xn|SP>, <Xm>, <extend> #<amount>",2126 .pattern = "SUB <Xd|SP>, <Xn|SP>, <Xm>, <extend> #<amount>",
1707 .symbols = .{2127 .symbols = .{
...@@ -1805,6 +2225,212 @@...@@ -1805,6 +2225,212 @@
1805 .amount = .amount,2225 .amount = .amount,
1806 } } },2226 } } },
1807 },2227 },
2228 // C6.2.359 SUBG
2229 .{
2230 .requires = .{.mte},
2231 .pattern = "SUBG <Xd|SP>, <Xn|SP>, #<uimm6>, #<uimm4>",
2232 .symbols = .{
2233 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2234 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2235 .uimm6 = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 10 }, .multiple_of = 16 } },
2236 .uimm4 = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 4 } } },
2237 },
2238 .encode = .{ .subg, .Xd, .Xn, .uimm6, .uimm4 },
2239 },
2240 // C6.2.362 SUBS (extended register)
2241 .{
2242 .pattern = "SUBS <Wd>, <Wn|WSP>, <Wm>",
2243 .symbols = .{
2244 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2245 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2246 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2247 },
2248 .encode = .{ .subs, .Wd, .Wn, .{ .register = .Wm } },
2249 },
2250 .{
2251 .pattern = "SUBS <Wd>, <Wn|WSP>, <Wm>, <extend>",
2252 .symbols = .{
2253 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2254 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2255 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2256 .extend = .{ .extend = .{} },
2257 },
2258 .encode = .{ .subs, .Wd, .Wn, .{ .extended_register_explicit = .{
2259 .register = .Wm,
2260 .option = .extend,
2261 .amount = 0,
2262 } } },
2263 },
2264 .{
2265 .pattern = "SUBS <Wd>, <Wn|WSP>, <Wm>, <extend> #<amount>",
2266 .symbols = .{
2267 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2268 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2269 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2270 .extend = .{ .extend = .{} },
2271 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
2272 },
2273 .encode = .{ .subs, .Wd, .Wn, .{ .extended_register_explicit = .{
2274 .register = .Wm,
2275 .option = .extend,
2276 .amount = .amount,
2277 } } },
2278 },
2279 .{
2280 .pattern = "SUBS <Xd>, <Xn|SP>, <Xm>",
2281 .symbols = .{
2282 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2283 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2284 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2285 },
2286 .encode = .{ .subs, .Xd, .Xn, .{ .register = .Xm } },
2287 },
2288 .{
2289 .pattern = "SUBS <Xd>, <Xn|SP>, <Wm>, <extend>",
2290 .symbols = .{
2291 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2292 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2293 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2294 .extend = .{ .extend = .{ .size = .word } },
2295 },
2296 .encode = .{ .subs, .Xd, .Xn, .{ .extended_register_explicit = .{
2297 .register = .Wm,
2298 .option = .extend,
2299 .amount = 0,
2300 } } },
2301 },
2302 .{
2303 .pattern = "SUBS <Xd>, <Xn|SP>, <Wm>, <extend> #<amount>",
2304 .symbols = .{
2305 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2306 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2307 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2308 .extend = .{ .extend = .{ .size = .word } },
2309 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
2310 },
2311 .encode = .{ .subs, .Xd, .Xn, .{ .extended_register_explicit = .{
2312 .register = .Wm,
2313 .option = .extend,
2314 .amount = .amount,
2315 } } },
2316 },
2317 .{
2318 .pattern = "SUBS <Xd>, <Xn|SP>, <Xm>, <extend>",
2319 .symbols = .{
2320 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2321 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2322 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2323 .extend = .{ .extend = .{ .size = .doubleword } },
2324 },
2325 .encode = .{ .subs, .Xd, .Xn, .{ .extended_register_explicit = .{
2326 .register = .Xm,
2327 .option = .extend,
2328 .amount = 0,
2329 } } },
2330 },
2331 .{
2332 .pattern = "SUBS <Xd>, <Xn|SP>, <Xm>, <extend> #<amount>",
2333 .symbols = .{
2334 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2335 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2336 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2337 .extend = .{ .extend = .{ .size = .doubleword } },
2338 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 3 }, .max_valid = 4 } },
2339 },
2340 .encode = .{ .subs, .Xd, .Xn, .{ .extended_register_explicit = .{
2341 .register = .Xm,
2342 .option = .extend,
2343 .amount = .amount,
2344 } } },
2345 },
2346 // C6.2.363 SUBS (immediate)
2347 .{
2348 .pattern = "SUBS <Wd>, <Wn|WSP>, #<imm>",
2349 .symbols = .{
2350 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2351 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2352 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
2353 },
2354 .encode = .{ .subs, .Wd, .Wn, .{ .immediate = .imm } },
2355 },
2356 .{
2357 .pattern = "SUBS <Wd>, <Wn|WSP>, #<imm>, LSL #<shift>",
2358 .symbols = .{
2359 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2360 .Wn = .{ .reg = .{ .format = .{ .general = .word }, .allow_sp = true } },
2361 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
2362 .shift = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 4 }, .multiple_of = 12 } },
2363 },
2364 .encode = .{ .subs, .Wd, .Wn, .{ .shifted_immediate = .{ .immediate = .imm, .lsl = .shift } } },
2365 },
2366 .{
2367 .pattern = "SUBS <Xd>, <Xn|SP>, #<imm>",
2368 .symbols = .{
2369 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2370 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2371 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
2372 },
2373 .encode = .{ .subs, .Xd, .Xn, .{ .immediate = .imm } },
2374 },
2375 .{
2376 .pattern = "SUBS <Xd>, <Xn|SP>, #<imm>, LSL #<shift>",
2377 .symbols = .{
2378 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2379 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword }, .allow_sp = true } },
2380 .imm = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 12 } } },
2381 .shift = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 4 }, .multiple_of = 12 } },
2382 },
2383 .encode = .{ .subs, .Xd, .Xn, .{ .shifted_immediate = .{ .immediate = .imm, .lsl = .shift } } },
2384 },
2385 // C6.2.364 SUBS (shifted register)
2386 .{
2387 .pattern = "SUBS <Wd>, <Wn>, <Wm>",
2388 .symbols = .{
2389 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2390 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
2391 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2392 },
2393 .encode = .{ .subs, .Wd, .Wn, .{ .register = .Wm } },
2394 },
2395 .{
2396 .pattern = "SUBS <Wd>, <Wn>, <Wm>, <shift> #<amount>",
2397 .symbols = .{
2398 .Wd = .{ .reg = .{ .format = .{ .general = .word } } },
2399 .Wn = .{ .reg = .{ .format = .{ .general = .word } } },
2400 .Wm = .{ .reg = .{ .format = .{ .general = .word } } },
2401 .shift = .{ .shift = .{ .allow_ror = false } },
2402 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 5 } } },
2403 },
2404 .encode = .{ .subs, .Wd, .Wn, .{ .shifted_register_explicit = .{
2405 .register = .Wm,
2406 .shift = .shift,
2407 .amount = .amount,
2408 } } },
2409 },
2410 .{
2411 .pattern = "SUBS <Xd>, <Xn>, <Xm>",
2412 .symbols = .{
2413 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2414 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2415 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2416 },
2417 .encode = .{ .subs, .Xd, .Xn, .{ .register = .Xm } },
2418 },
2419 .{
2420 .pattern = "SUBS <Xd>, <Xn>, <Xm>, <shift> #<amount>",
2421 .symbols = .{
2422 .Xd = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2423 .Xn = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2424 .Xm = .{ .reg = .{ .format = .{ .general = .doubleword } } },
2425 .shift = .{ .shift = .{ .allow_ror = false } },
2426 .amount = .{ .imm = .{ .type = .{ .signedness = .unsigned, .bits = 6 } } },
2427 },
2428 .encode = .{ .subs, .Xd, .Xn, .{ .shifted_register_explicit = .{
2429 .register = .Xm,
2430 .shift = .shift,
2431 .amount = .amount,
2432 } } },
2433 },
1808 // C6.2.365 SVC2434 // C6.2.365 SVC
1809 .{2435 .{
1810 .pattern = "SVC #<imm>",2436 .pattern = "SVC #<imm>",
...@@ -1933,6 +2559,13 @@...@@ -1933,6 +2559,13 @@
1933 .symbols = .{},2559 .symbols = .{},
1934 .encode = .{.wfi},2560 .encode = .{.wfi},
1935 },2561 },
2562 // C6.2.400 XAFLAG
2563 .{
2564 .requires = .{.altnzcv},
2565 .pattern = "XAFLAG",
2566 .symbols = .{},
2567 .encode = .{.xaflag},
2568 },
1936 // C6.2.402 YIELD2569 // C6.2.402 YIELD
1937 .{2570 .{
1938 .pattern = "YIELD",2571 .pattern = "YIELD",