Reformat the instruction table

src/asm_tables.cpp

@@ -31,6 +31,7 @@ enum AsmOperandKind : u8 {
 	AsmOperand_Register_Or_Memory,
 	AsmOperand_Immediate,
 	AsmOperand_Label,
+	AsmOperand_RegisterGroup,
 
 	AsmOperand_COUNT
 };

src/parser.cpp

@@ -558,6 +558,10 @@ gb_internal Ast *clone_ast(Ast *node, AstFile *f) {
 		n->AsmMemoryOperand.disp  = clone_ast(n->AsmMemoryOperand.disp,  f);
 		n->AsmMemoryOperand.type  = clone_ast(n->AsmMemoryOperand.type,  f);
 		break;
+	case Ast_AsmRegisterGroup:
+		n->AsmRegisterGroup.registers = clone_ast_array(n->AsmRegisterGroup.registers, f);
+		n->AsmRegisterGroup.type      = clone_ast(n->AsmRegisterGroup.type, f);
+		break;
 	case Ast_AsmDirective:
 		n->AsmDirective.operands = clone_ast_array(n->AsmDirective.operands, f);
 		break;
@@ -2573,6 +2577,61 @@ gb_internal Ast *parse_asm_operand(AstFile *f, bool allow_memory_operand) {
 			return mem;
 		}
 		break;
+	case Token_OpenBrace:
+		if (allow_memory_operand) {
+			Token open  = expect_token(f, Token_OpenBrace);
+
+			Array<Ast *> registers = {};
+			registers.allocator = heap_allocator();
+			Ast *type = nullptr;
+
+			Ast *first_reg = parse_asm_operand(f, false);
+			Token range_token = {};
+			switch (f->curr_token.kind) {
+			case Token_RangeHalf:
+			case Token_RangeFull:
+				{
+					range_token = advance_token(f);
+					Ast *second_reg = parse_asm_operand(f, false);
+					array_reserve(&registers, 2);
+					array_add(&registers, first_reg);
+					array_add(&registers, second_reg);
+
+					if (allow_token(f, Token_Comma)) {
+						// allow for trailing comma
+					}
+				}
+				break;
+			default:
+				if (allow_token(f, Token_Comma)) {
+					// allow for trailing comma
+				}
+				while (f->curr_token.kind != Token_CloseBrace &&
+				       f->curr_token.kind != Token_EOF) {
+					Ast *reg = parse_asm_operand(f, false);
+					array_add(&registers, reg);
+
+					if (!allow_token(f, Token_Comma)) {
+						break;
+					}
+				}
+				break;
+			}
+			Token close = expect_token(f, Token_CloseBrace);
+			if (allow_token(f, Token_Colon)) {
+				type = parse_type(f);
+			}
+
+			Ast *rg = alloc_ast_node(f, Ast_AsmRegisterGroup);
+			rg->AsmRegisterGroup.open        = open;
+			rg->AsmRegisterGroup.registers   = registers;
+			rg->AsmRegisterGroup.range_token = range_token;
+			rg->AsmRegisterGroup.close       = close;
+			rg->AsmRegisterGroup.type        = type;
+
+			return rg;
+		}
+		break;
 	}
 
 	if (operand == nullptr) {

src/parser.hpp

@@ -525,6 +525,13 @@ struct AstSplitArgs {
 		Ast * type;     \
 		Token close;    \
 	}) \
+	AST_KIND(AsmRegisterGroup, "asm register group", struct { \
+		Token        open;        \
+		Array<Ast *> registers;   \
+		Token        range_token; \
+		Token        close;       \
+		Ast *        type;        \
+	}) \
 	AST_KIND(AsmDirective, "asm directive", struct { \
 		Token        token;    \
 		Token        name;     \

src/parser_pos.cpp

@@ -28,6 +28,8 @@ gb_internal Token ast_token(Ast *node) {
 		return ast_token(node->AsmInstruction.name);
 	case Ast_AsmMemoryOperand:
 		return node->AsmMemoryOperand.open;
+	case Ast_AsmRegisterGroup:
+		return node->AsmRegisterGroup.open;
 	case Ast_AsmDirective:
 		return node->AsmDirective.token;
 
@@ -211,6 +213,11 @@ Token ast_end_token(Ast *node) {
 			return ast_end_token(node->AsmMemoryOperand.type);
 		}
 		return node->AsmMemoryOperand.close;
+	case Ast_AsmRegisterGroup:
+		if (node->AsmRegisterGroup.type) {
+			return ast_end_token(node->AsmRegisterGroup.type);
+		}
+		return node->AsmRegisterGroup.close;
 
 	case Ast_BadExpr:       return node->BadExpr.end;
 	case Ast_TagExpr: