extract scratch registers to builder

Author: hellerve

docs/builder.md

@@ -16,6 +16,9 @@ around abi registers, stack setup, and label plumbing, and it looks less scary.
 - `cj_builder_arg_int(cj, index)`: returns the platform-specific argument
   register.
 - `cj_builder_scratch_reg(index)`: picks a caller-saved temporary.
+- `cj_builder_scratch_init`, `cj_builder_scratch_acquire`,
+  `cj_builder_scratch_release`: managed stack of scratch registers for balanced
+  temporaries.
 - `cj_builder_zero_operand()` + `cj_builder_clear(cj, dst)`: easy zeroing.
 - `cj_builder_assign`, `cj_builder_add_assign`, `cj_builder_sub_assign`:
   assignment sugar.

examples/README.md

@@ -31,6 +31,9 @@ cc -std=c11 -O2 -Isrc examples/hl_fibonacci.c src/ctx.c -o hl_fibonacci_example
 
 cc -std=c11 -O2 -Isrc examples/simd.c src/ctx.c -o simd_example
 ./simd_example
+
+cc -std=c11 -O2 -Isrc examples/minilang.c src/ctx.c -o minilang
+./minilang
 ```
 
 alternatively build the library and then add `-lcj -Lbin/` instead of the c file.

examples/minilang.c

@@ -289,43 +289,22 @@ typedef struct
 {
   cj_ctx *cj;
   function *functions;
-  int scratch_depth;
+  cj_builder_scratch scratch;
 } codegen;
 
-static cj_operand acquire_scratch(codegen *cg)
-{
-  if (cg->scratch_depth >= 6)
-  {
-    fprintf(stderr, "scratch register exhausted\n");
-    exit(1);
-  }
-  int idx = cg->scratch_depth++;
-  return cj_builder_scratch_reg((unsigned)idx);
-}
-
-static void release_scratch(codegen *cg)
-{
-  if (cg->scratch_depth <= 0)
-  {
-    fprintf(stderr, "release underflow\n");
-    exit(1);
-  }
-  cg->scratch_depth--;
-}
-
 static cj_operand emit_expr(codegen *cg, node *n)
 {
   switch (n->kind)
   {
   case NODE_NUM:
   {
-    cj_operand dst = acquire_scratch(cg);
+    cj_operand dst = cj_builder_scratch_acquire(&cg->scratch);
     cj_builder_assign(cg->cj, dst, cj_make_constant((uint64_t)(uint32_t)n->value));
     return dst;
   }
   case NODE_PARAM:
   {
-    cj_operand dst = acquire_scratch(cg);
+    cj_operand dst = cj_builder_scratch_acquire(&cg->scratch);
     cj_builder_assign(cg->cj, dst, cj_builder_arg_int(cg->cj, 0));
     return dst;
   }
@@ -338,20 +317,20 @@ static cj_operand emit_expr(codegen *cg, node *n)
       cj_add(cg->cj, lhs, rhs);
     else
       cj_sub(cg->cj, lhs, rhs);
-    release_scratch(cg);
+    cj_builder_scratch_release(&cg->scratch);
     return lhs;
   }
   case NODE_CALL:
   {
     cj_operand arg = emit_expr(cg, n->arg);
     cj_builder_assign(cg->cj, cj_builder_arg_int(cg->cj, 0), arg);
-    release_scratch(cg);
+    cj_builder_scratch_release(&cg->scratch);
 #if defined(__aarch64__) || defined(_M_ARM64)
     cj_bl(cg->cj, cg->functions[n->target].entry);
 #else
     cj_call(cg->cj, cg->functions[n->target].entry);
 #endif
-    cj_operand dst = acquire_scratch(cg);
+    cj_operand dst = cj_builder_scratch_acquire(&cg->scratch);
     cj_builder_assign(cg->cj, dst, cj_builder_return_reg());
     return dst;
   }
@@ -362,7 +341,7 @@ static cj_operand emit_expr(codegen *cg, node *n)
 
 static void emit_function(codegen *cg, function *fn)
 {
-  cg->scratch_depth = 0;
+  cj_builder_scratch_init(&cg->scratch);
   cj_mark_label(cg->cj, fn->entry);
 #if defined(__aarch64__) || defined(_M_ARM64)
   cj_operand sp = cj_make_register("sp");
@@ -382,7 +361,7 @@ static void emit_function(codegen *cg, function *fn)
   cj_operand result = emit_expr(cg, fn->body);
   cj_builder_return_value(cg->cj, &frame, result);
 #endif
-  release_scratch(cg);
+  cj_builder_scratch_release(&cg->scratch);
 }
 
 static const char *program_source = "(def main (x) (sub (call inc x) 3))\n"
@@ -426,7 +405,7 @@ int main(void)
   for (int i = 0; i < function_count; i++)
     functions[i].entry = cj_create_label(cj);
 
-  codegen cg = {.cj = cj, .functions = functions, .scratch_depth = 0};
+  codegen cg = {.cj = cj, .functions = functions};
   emit_function(&cg, &functions[main_idx]);
   for (int i = 0; i < function_count; i++)
     if (i != main_idx)

src/builder.h

@@ -32,6 +32,11 @@ typedef struct
   cj_condition exit_cond;
 } cj_builder_for_loop;
 
+typedef struct
+{
+  unsigned depth;
+} cj_builder_scratch;
+
 static inline void cj_builder_fn_prologue(cj_ctx *ctx, size_t requested_stack_bytes,
                                           cj_builder_frame *frame);
 static inline void cj_builder_fn_epilogue(cj_ctx *ctx, const cj_builder_frame *frame);
@@ -67,6 +72,10 @@ static inline void cj_builder_return_value(cj_ctx *ctx, const cj_builder_frame *
 static inline cj_operand cj_builder_zero_operand(void);
 static inline void cj_builder_clear(cj_ctx *ctx, cj_operand dst);
 static inline cj_operand cj_builder_scratch_reg(unsigned index);
+static inline unsigned cj_builder_scratch_capacity(void);
+static inline void cj_builder_scratch_init(cj_builder_scratch *scratch);
+static inline cj_operand cj_builder_scratch_acquire(cj_builder_scratch *scratch);
+static inline void cj_builder_scratch_release(cj_builder_scratch *scratch);
 
 #include <assert.h>
 #include <stdint.h>
@@ -568,3 +577,34 @@ static inline cj_operand cj_builder_scratch_reg(unsigned index)
   return cj_make_register(regs[index]);
 #endif
 }
+
+static inline unsigned cj_builder_scratch_capacity(void)
+{
+#if defined(__x86_64__) || defined(_M_X64)
+  return 6;
+#elif defined(__aarch64__) || defined(_M_ARM64)
+  return 6;
+#endif
+}
+
+static inline void cj_builder_scratch_init(cj_builder_scratch *scratch)
+{
+  if (!scratch)
+    return;
+  scratch->depth = 0;
+}
+
+static inline cj_operand cj_builder_scratch_acquire(cj_builder_scratch *scratch)
+{
+  assert(scratch);
+  assert(scratch->depth < cj_builder_scratch_capacity());
+  unsigned index = scratch->depth++;
+  return cj_builder_scratch_reg(index);
+}
+
+static inline void cj_builder_scratch_release(cj_builder_scratch *scratch)
+{
+  assert(scratch);
+  assert(scratch->depth > 0);
+  scratch->depth--;
+}