lvalue is memory; expression parsing improvements; stack_alloc

ivanjermakov · ivanjermakov · commit 072bd8217044 · 2026-02-28T21:21:47.000+01:00
diff --git a/src/core.h b/src/core.h
@@ -6,6 +6,7 @@
 #include "stdio.h"
 #include "stdlib.h"
 #include "string.h"
+#include "sys/param.h"
 
 typedef struct {
     size_t start;
@@ -101,7 +102,7 @@ typedef struct {
 } OperandImmediate;
 
 typedef enum {
-    REL_RIP,
+    REL_RIP = 1,
     REL_RBP,
     SYMBOL_LOCAL,
     SYMBOL_GLOBAL,
@@ -115,7 +116,7 @@ typedef struct {
 typedef struct {
     OperandTag tag;
     // in case operand is used in lvalue context, use this instead of `o`
-    OperandRegister lvalue;
+    OperandMemory lvalue;
     union {
         OperandRegister reg;
         OperandImmediate immediate;
@@ -163,23 +164,54 @@ typedef struct {
     Operand operand;
 } Operator;
 
-uint8_t operator_precedence[] = {4, 4, 7, 7, 6, 6, 6, 6, 1, 2, 14, 3, 11, 12, 2};
+uint8_t operator_precedence[] = {
+    0,
+    4,  // OP_ADD
+    4,  // OP_SUB
+    7,  // OP_EQ
+    7,  // OP_NEQ
+    6,  // OP_GT
+    6,  // OP_GE
+    6,  // OP_LT
+    6,  // OP_LE
+    1,  // OP_INDEX
+    2,  // OP_INCREMENT
+    14, // OP_ASSIGN
+    3,  // OP_REMAINDER
+    11, // OP_AND
+    12, // OP_OR
+    2,  // OP_ADDRESS_OF
+};
 
 typedef enum {
     ASSOC_LEFT,
     ASSOC_RIGHT,
 } Associativity;
 
 uint8_t operator_associativity[] = {
-    ASSOC_LEFT,  ASSOC_LEFT, ASSOC_LEFT, ASSOC_LEFT, ASSOC_LEFT,
-    ASSOC_LEFT,  ASSOC_LEFT, ASSOC_LEFT, ASSOC_LEFT, ASSOC_RIGHT,
-    ASSOC_RIGHT, ASSOC_LEFT, ASSOC_LEFT, ASSOC_LEFT, ASSOC_RIGHT,
+    0,
+    ASSOC_LEFT,  // OP_ADD
+    ASSOC_LEFT,  // OP_SUB
+    ASSOC_LEFT,  // OP_EQ
+    ASSOC_LEFT,  // OP_NEQ
+    ASSOC_LEFT,  // OP_GT
+    ASSOC_LEFT,  // OP_GE
+    ASSOC_LEFT,  // OP_LT
+    ASSOC_LEFT,  // OP_LE
+    ASSOC_LEFT,  // OP_INDEX
+    ASSOC_RIGHT, // OP_INCREMENT
+    ASSOC_RIGHT, // OP_ASSIGN
+    ASSOC_LEFT,  // OP_REMAINDER
+    ASSOC_LEFT,  // OP_AND
+    ASSOC_LEFT,  // OP_OR
+    ASSOC_RIGHT, // OP_ADDRESS_OF
 };
 
 typedef struct {
     Span span;
     Operand operand;
     size_t size;
+    size_t count;
     size_t item_size;
     size_t index;
     ElfSymbolEntry entry;
@@ -203,14 +235,14 @@ size_t stack_size = 0;
 
 /**
  * RSP offset in a current function
- * push increments to keep it unsigned
  */
-size_t stack_offset = 0;
+int32_t stack_offset = 0;
 
 void stack_push() {
+    Scope last = stack[stack_size];
     stack[stack_size++] = (Scope){
         .symbols_start = symbols_size,
-        .bp_offset = 0,
+        .bp_offset = last.bp_offset,
     };
 }
 
diff --git a/src/emit.h b/src/emit.h
@@ -194,6 +194,12 @@ void asm_mov(Operand a, Operand b) {
         text_buf[text_size++] = (uint8_t)b.memory.offset;
         return;
     }
+    if (a.tag == MEMORY && b.tag == MEMORY) {
+        Operand tmp = expr_registers[expr_registers_busy];
+        asm_mov(tmp, b);
+        asm_mov(a, tmp);
+        return;
+    }
     fprintf(stderr, "TODO asm_mov %d %d\n", a.tag, b.tag);
     asm_nop();
 }
@@ -291,7 +297,7 @@ void asm_push(Operand a) {
             text_buf[text_size++] = rex(false, false, false, true);
         }
         text_buf[text_size++] = 0x50 + (a.reg.i & 0b111);
-        stack_offset += 8;
+        stack_offset -= 8;
         return;
     }
     fprintf(stderr, "TODO asm_push\n");
@@ -304,7 +310,7 @@ void asm_pop(Operand a) {
             text_buf[text_size++] = rex(false, false, false, true);
         }
         text_buf[text_size++] = 0x58 + (a.reg.i & 0b111);
-        stack_offset -= 8;
+        stack_offset += 8;
         return;
     }
     fprintf(stderr, "TODO asm_pop\n");
@@ -377,7 +383,7 @@ void asm_sete(Operand a) {
     if (a.tag == REGISTER) {
         text_buf[text_size++] = 0x0F;
         text_buf[text_size++] = 0x94;
-        text_buf[text_size++] = modrm(MOD_REGISTER, a.reg.i, 0);
+        text_buf[text_size++] = modrm(MOD_REGISTER, 0, a.reg.i);
         return;
     }
     if (a.tag == MEMORY && a.memory.mode == REL_RBP) {
diff --git a/src/expr.h b/src/expr.h
@@ -1,6 +1,7 @@
 #include "core.h"
 #include "emit.h"
 
+Operand stack_alloc(size_t size);
 Expr visit_operand();
 Operator visit_op_infix();
 Operator visit_op_prefix();
@@ -23,7 +24,7 @@ typedef struct {
  *
  * @see https://en.wikipedia.org/wiki/Shunting_yard_algorithm
  */
-bool shunting_yard(ExprToken expr_stack[], size_t* expr_stack_size) {
+bool shunting_yard(ExprToken out_queue[], size_t* out_queue_size) {
     Operator op_stack[1 << 10];
     size_t op_stack_size = 0;
 
@@ -49,7 +50,7 @@ bool shunting_yard(ExprToken expr_stack[], size_t* expr_stack_size) {
                 Expr operand = visit_operand();
                 if (!operand.ok) return false;
                 expr_token.operand = operand.operand;
-                expr_stack[(*expr_stack_size)++] = expr_token;
+                out_queue[(*out_queue_size)++] = expr_token;
                 infix_postfix_time = true;
             }
         }
@@ -58,19 +59,20 @@ bool shunting_yard(ExprToken expr_stack[], size_t* expr_stack_size) {
             Operator op = expr_token.op;
             while (op_stack_size > 0 && (operator_precedence[op_stack[op_stack_size - 1].tag] <
                                              operator_precedence[op.tag] ||
-                                         (operator_associativity[op.tag] == ASSOC_LEFT &&
-                                          operator_precedence[op_stack[op_stack_size - 1].tag] ==
-                                              operator_precedence[op.tag]))) {
-                expr_stack[(*expr_stack_size)++] = (ExprToken){
+                                         (operator_precedence[op_stack[op_stack_size - 1].tag] ==
+                                              operator_precedence[op.tag] &&
+                                          operator_associativity[op.tag] == ASSOC_LEFT))) {
+                out_queue[(*out_queue_size)++] = (ExprToken){
                     .is_operator = true,
                     .op = op_stack[--op_stack_size],
                 };
             }
             op_stack[op_stack_size++] = op;
         }
     }
+
     while (op_stack_size > 0) {
-        expr_stack[(*expr_stack_size)++] = (ExprToken){
+        out_queue[(*out_queue_size)++] = (ExprToken){
             .is_operator = true,
             .op = op_stack[--op_stack_size],
         };
@@ -139,13 +141,15 @@ Expr visit_expr() {
                         asm_push(RDX);
 
                         asm_mov(RAX, *o1);
+                        asm_mov(RDX, immediate(0));
                         asm_idiv(o2);
-                        asm_mov(tmp, RDX);
+                        Operand tmp_stack = stack_alloc(8);
+                        asm_mov(tmp_stack, RDX);
 
                         asm_pop(RDX);
                         asm_pop(RAX);
 
-                        *o1 = tmp;
+                        *o1 = tmp_stack;
                         break;
                     }
                     case OP_AND: {
@@ -175,7 +179,7 @@ Expr visit_expr() {
                     case OP_EQ: {
                         asm_cmp(*o1, o2);
                         asm_mov(tmp, immediate(0));
-                        asm_setne(tmp);
+                        asm_sete(tmp);
                         *o1 = tmp;
                         break;
                     }
@@ -184,11 +188,12 @@ Expr visit_expr() {
                         break;
                     }
                     case OP_ASSIGN: {
-                        if (o1->lvalue.size == 0) {
+                        if (o1->lvalue.mode == 0) {
                             fprintf(stderr, "not an lvalue\n");
+                            assert(false);
                             return (Expr){};
                         }
-                        asm_mov((Operand){.tag = REGISTER, .reg = o1->lvalue}, o2);
+                        asm_mov((Operand){.tag = MEMORY, .memory = o1->lvalue}, o2);
                         break;
                     }
                     default: {
@@ -205,16 +210,15 @@ Expr visit_expr() {
                     case OP_INDEX: {
                         Operand idx = op.operand;
                         {
-                            Operand ptr = expr_registers[expr_registers_busy++];
+                            Operand ptr = stack_alloc(8);
                             asm_mov(ptr, idx);
                             asm_add(ptr, *o);
 
                             Operand res = expr_registers[expr_registers_busy++];
-                            ptr.reg.indirect = true;
+                            res.lvalue = ptr.lvalue;
                             asm_mov(res, ptr);
 
                             *o = res;
-                            o->lvalue = ptr.reg;
                         }
                         goto c;
                     }
diff --git a/src/parse.h b/src/parse.h
@@ -3,6 +3,17 @@
 #include "emit.h"
 #include "expr.h"
 
+Operand stack_alloc(size_t size) {
+    Scope* scope = &stack[stack_size];
+    Operand operand = {
+        .tag = MEMORY,
+        .memory = {.mode = REL_RBP, .offset = scope->bp_offset},
+    };
+    operand.lvalue = operand.memory;
+    scope->bp_offset -= size;
+    return operand;
+}
+
 Symbol* symbol_find(Span span) {
     if (stack_size == 0) return NULL;
     for (int64_t scope = stack_size - 1; scope >= 0; scope--) {
@@ -36,16 +47,14 @@ Symbol* symbol_add_global(Span name, size_t pos, bool impl) {
 }
 
 Symbol* symbol_add_stack(Span name_span, size_t size, size_t count) {
-    Scope* scope = &stack[stack_size];
-    scope->bp_offset -= size;
-    Operand operand = {
-        .tag = MEMORY,
-        .memory = {.mode = REL_RBP, .offset = scope->bp_offset},
-    };
+    size_t s = size * MAX(count, 1);
+    Operand operand = stack_alloc(s);
+    operand.lvalue = operand.memory;
     symbols_buf[symbols_size++] = (Symbol){
         .span = name_span,
-        .operand = operand,
-        .size = size * count,
+        .operand = stack_alloc(s),
+        .size = s,
+        .count = count,
         .item_size = size,
     };
     return &symbols_buf[symbols_size - 1];
@@ -295,8 +304,9 @@ Expr visit_operand() {
         if (!ident.ok) return expr;
         Symbol* symbol = symbol_find(ident.span);
         if (symbol == NULL) return expr;
-        if (symbol->size > 0) {
+        if (symbol->count > 0) {
             Operand tmp = expr_registers[expr_registers_busy++];
+            tmp.lvalue = symbol->operand.lvalue;
             asm_lea(tmp, symbol->operand);
             expr.operand = tmp;
         } else {
@@ -318,8 +328,11 @@ Expr visit_operand() {
         fprintf(stderr, "TODO %s\n", token_name[t.type]);
         return expr;
     } else if (t.type == O_PAREN) {
-        fprintf(stderr, "TODO %s\n", token_name[t.type]);
-        return expr;
+        token_pos++;
+        Expr sub_expr = visit_expr();
+        if (!sub_expr.ok) return expr;
+        token_pos++;
+        expr.operand = sub_expr.operand;
     } else {
         fprintf(stderr, "TODO %s\n", token_name[t.type]);
         return expr;
@@ -423,7 +436,7 @@ Expr visit_call() {
     }
 
     size_t misalign = stack_offset % 16;
-    if (misalign > 0) asm_sub(RSP, immediate(misalign));
+    if (misalign != 0) asm_sub(RSP, immediate(misalign));
 
     if (symbol->entry.name != 0) {
         asm_call_global(symbol);
@@ -561,7 +574,7 @@ bool visit_func_def() {
         symbol_add_global(name.span, symbol_pos, true);
         stack_push();
 
-        stack_offset = stack_prealloc;
+        stack_offset = -stack_prealloc;
 
         // TODO: only preserve used registers
         for (size_t i = 0; i < non_volatile_registers_size; i++) {

Original file line number	Diff line number	Diff line change
`@@ -194,6 +194,12 @@ void asm_mov(Operand a, Operand b) {`
`194`	`194`	`text_buf[text_size++] = (uint8_t)b.memory.offset;`
`195`	`195`	`return;`
`196`	`196`	`}`
	`197`	`+ if (a.tag == MEMORY && b.tag == MEMORY) {`
	`198`	`+ Operand tmp = expr_registers[expr_registers_busy];`
	`199`	`+ asm_mov(tmp, b);`
	`200`	`+ asm_mov(a, tmp);`
	`201`	`+ return;`
	`202`	`+ }`
`197`	`203`	`fprintf(stderr, "TODO asm_mov %d %d\n", a.tag, b.tag);`
`198`	`204`	`asm_nop();`
`199`	`205`	`}`
`@@ -291,7 +297,7 @@ void asm_push(Operand a) {`
`291`	`297`	`text_buf[text_size++] = rex(false, false, false, true);`
`292`	`298`	`}`
`293`	`299`	`text_buf[text_size++] = 0x50 + (a.reg.i & 0b111);`
`294`		`- stack_offset += 8;`
	`300`	`+ stack_offset -= 8;`
`295`	`301`	`return;`
`296`	`302`	`}`
`297`	`303`	`fprintf(stderr, "TODO asm_push\n");`
`@@ -304,7 +310,7 @@ void asm_pop(Operand a) {`
`304`	`310`	`text_buf[text_size++] = rex(false, false, false, true);`
`305`	`311`	`}`
`306`	`312`	`text_buf[text_size++] = 0x58 + (a.reg.i & 0b111);`
`307`		`- stack_offset -= 8;`
	`313`	`+ stack_offset += 8;`
`308`	`314`	`return;`
`309`	`315`	`}`
`310`	`316`	`fprintf(stderr, "TODO asm_pop\n");`
`@@ -377,7 +383,7 @@ void asm_sete(Operand a) {`
`377`	`383`	`if (a.tag == REGISTER) {`
`378`	`384`	`text_buf[text_size++] = 0x0F;`
`379`	`385`	`text_buf[text_size++] = 0x94;`
`380`		`- text_buf[text_size++] = modrm(MOD_REGISTER, a.reg.i, 0);`
	`386`	`+ text_buf[text_size++] = modrm(MOD_REGISTER, 0, a.reg.i);`
`381`	`387`	`return;`
`382`	`388`	`}`
`383`	`389`	`if (a.tag == MEMORY && a.memory.mode == REL_RBP) {`