try to fix pendanticity errors

hellerve · hellerve · commit 41ca09cf2dbe · 2025-10-22T12:58:06.000-05:00
diff --git a/src/builder.h b/src/builder.h
@@ -96,8 +96,8 @@ static inline cj_operand cj_builder_call_unary(cj_ctx *ctx, cj_builder_scratch *
 static inline size_t align_stack_size(size_t size)
 {
   const size_t alignment = 16;
-  if (size == 0)
-    return 0;
+  if (size == 0) return 0;
+
   size_t mask = alignment - 1;
   return (size + mask) & ~mask;
 }
@@ -116,8 +116,7 @@ static inline void cj_builder_fn_prologue_with_link_save(cj_ctx *ctx, size_t req
 
 static inline void cj_builder_fn_epilogue(cj_ctx *ctx, const cj_builder_frame *frame)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   size_t aligned = frame ? frame->stack_size : 0;
   int save_lr = (frame && frame->save_lr);
 
@@ -157,8 +156,7 @@ static inline void cj_builder_fn_epilogue(cj_ctx *ctx, const cj_builder_frame *f
 
 static inline void cj_builder_return(cj_ctx *ctx, const cj_builder_frame *frame)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   cj_builder_fn_epilogue(ctx, frame);
   cj_ret(ctx);
 }
@@ -333,30 +331,26 @@ static inline cj_builder_block cj_builder_loop_begin(cj_ctx *ctx)
 static inline void cj_builder_loop_condition(cj_ctx *ctx, cj_builder_block block, cj_operand lhs,
                                              cj_operand rhs, cj_condition exit_cond)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   cj_cmp(ctx, lhs, rhs);
   branch_on_condition(ctx, exit_cond, block.exit);
 }
 
 static inline void cj_builder_loop_continue(cj_ctx *ctx, cj_builder_block block)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   branch_unconditional(ctx, block.entry);
 }
 
 static inline void cj_builder_loop_break(cj_ctx *ctx, cj_builder_block block)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   branch_unconditional(ctx, block.exit);
 }
 
 static inline void cj_builder_loop_end(cj_ctx *ctx, cj_builder_block block)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   branch_unconditional(ctx, block.entry);
   cj_mark_label(ctx, block.exit);
 }
@@ -375,17 +369,15 @@ cj_builder_if_block cj_builder_if(cj_ctx *ctx, cj_operand lhs, cj_operand rhs, c
 
 void cj_builder_else(cj_ctx *ctx, cj_builder_if_block *block)
 {
-  if (!ctx || !block)
-    return;
+  if (!ctx || !block) return;
   branch_unconditional(ctx, block->end_label);
   cj_mark_label(ctx, block->else_label);
   block->has_else = 1;
 }
 
 void cj_builder_endif(cj_ctx *ctx, cj_builder_if_block *block)
 {
-  if (!ctx || !block)
-    return;
+  if (!ctx || !block) return;
   if (!block->has_else)
   {
     cj_mark_label(ctx, block->else_label);
@@ -404,10 +396,7 @@ static inline cj_builder_for_loop cj_builder_for_begin(cj_ctx *ctx, cj_operand c
       .exit_cond = exit_cond,
   };
 
-  if (counter.type == CJ_REGISTER)
-  {
-    cj_mov(ctx, counter, start);
-  }
+  if (counter.type == CJ_REGISTER) cj_mov(ctx, counter, start);
 
   loop.block = cj_builder_loop_begin(ctx);
   cj_builder_loop_condition(ctx, loop.block, counter, limit, exit_cond);
@@ -416,23 +405,20 @@ static inline cj_builder_for_loop cj_builder_for_begin(cj_ctx *ctx, cj_operand c
 
 static inline void cj_builder_for_continue(cj_ctx *ctx, cj_builder_for_loop *loop)
 {
-  if (!ctx || !loop)
-    return;
+  if (!ctx || !loop) return;
   cj_add(ctx, loop->counter, loop->step);
   cj_builder_loop_continue(ctx, loop->block);
 }
 
 static inline void cj_builder_for_break(cj_ctx *ctx, cj_builder_for_loop *loop)
 {
-  if (!ctx || !loop)
-    return;
+  if (!ctx || !loop) return;
   cj_builder_loop_break(ctx, loop->block);
 }
 
 static inline void cj_builder_for_end(cj_ctx *ctx, cj_builder_for_loop *loop)
 {
-  if (!ctx || !loop)
-    return;
+  if (!ctx || !loop) return;
   cj_add(ctx, loop->counter, loop->step);
   cj_builder_loop_end(ctx, loop->block);
 }
@@ -456,8 +442,8 @@ static inline cj_operand cj_builder_assign(cj_ctx *ctx, cj_operand dst, cj_opera
     for (int shift = 16; shift < (is64 ? 64 : 32); shift += 16)
     {
       uint16_t part = (uint16_t)((value >> shift) & 0xFFFFu);
-      if (!part)
-        continue;
+      if (!part) continue;
+
       uint64_t encoded = (uint64_t)part | ((uint64_t)(shift / 16) << 16);
       cj_operand next = cj_make_constant(encoded);
       cj_movk(ctx, dst, next);
@@ -525,21 +511,15 @@ static inline cj_operand cj_builder_arg_int(cj_ctx *ctx, unsigned index)
 static inline void cj_builder_return_value(cj_ctx *ctx, const cj_builder_frame *frame,
                                            cj_operand value)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   cj_operand ret = get_return_operand();
   int needs_move = 1;
   if (value.type == CJ_REGISTER && value.reg && ret.reg)
   {
-    if (strcmp(value.reg, ret.reg) == 0)
-    {
-      needs_move = 0;
-    }
-  }
-  if (needs_move)
-  {
-    cj_mov(ctx, ret, value);
+    if (strcmp(value.reg, ret.reg) == 0) needs_move = 0;
   }
+  if (needs_move) cj_mov(ctx, ret, value);
+
   cj_builder_return(ctx, frame);
 }
 
@@ -554,8 +534,7 @@ static inline cj_operand cj_builder_zero_operand(void)
 
 static inline void cj_builder_clear(cj_ctx *ctx, cj_operand dst)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
 #if defined(__x86_64__) || defined(_M_X64)
   if (dst.type == CJ_REGISTER)
   {
@@ -603,8 +582,7 @@ static inline unsigned cj_builder_arg_int_capacity(void)
 
 static inline void cj_builder_scratch_init(cj_builder_scratch *scratch)
 {
-  if (!scratch)
-    return;
+  if (!scratch) return;
   scratch->depth = 0;
 }
 
@@ -642,8 +620,7 @@ static inline cj_operand cj_builder_call_unary(cj_ctx *ctx, cj_builder_scratch *
 static inline cj_operand cj_builder_call(cj_ctx *ctx, cj_builder_scratch *scratch, cj_label target,
                                          const cj_operand *args, size_t arg_count)
 {
-  if (!ctx)
-    return cj_builder_return_reg();
+  if (!ctx) return cj_builder_return_reg();
 
   unsigned capacity = cj_builder_arg_int_capacity();
   assert(arg_count <= capacity);
@@ -654,8 +631,7 @@ static inline cj_operand cj_builder_call(cj_ctx *ctx, cj_builder_scratch *scratc
     cj_builder_assign(ctx, reg, args[i]);
   }
 
-  if (scratch)
-    cj_builder_scratch_release(scratch);
+  if (scratch) cj_builder_scratch_release(scratch);
 
   cj_builder_call_label(ctx, target);
 
@@ -672,8 +648,7 @@ static inline cj_operand cj_builder_call(cj_ctx *ctx, cj_builder_scratch *scratc
 static inline void cj_builder_fn_prologue_ex(cj_ctx *ctx, size_t requested_stack_bytes,
                                              cj_builder_frame *frame, int save_lr)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
   assert(!save_lr || frame);
 
   size_t aligned = align_stack_size(requested_stack_bytes);
diff --git a/src/ctx.c b/src/ctx.c
@@ -22,21 +22,24 @@ cj_ctx *create_cj_ctx(void)
   res->num_fixups = 0;
   res->fixups = malloc(sizeof(cj_fixup) * res->fixup_capacity);
 
+  res->executable_base = NULL;
+  res->executable_raw = NULL;
+  res->executable_size = 0;
+  res->executable_code_size = 0;
+
   return res;
 }
 
 void grow_cj_ctx(cj_ctx *ctx)
 {
-  if (!ctx)
-    return;
+  if (!ctx) return;
 
   uint64_t old_size = ctx->size;
   uint64_t new_size = old_size * 2;
-  if (new_size < old_size)
-    return;
+  if (new_size < old_size) return;
+
   uint8_t *new_mem = realloc(ctx->mem, new_size);
-  if (!new_mem)
-    return;
+  if (!new_mem) return;
 
   ctx->mem = new_mem;
   memset(ctx->mem + old_size, 0, old_size);
@@ -53,17 +56,13 @@ void destroy_cj_ctx(cj_ctx *ctx)
 
 cj_fn create_cj_fn(cj_ctx *ctx)
 {
-  if (!ctx->len)
-    return NULL;
+  if (!ctx->len) return NULL;
 
   uint64_t code_size = ctx->len;
   size_t total_size = sizeof(uint64_t) + (size_t)code_size;
 
   uint8_t *raw = mmap(NULL, total_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  if (raw == MAP_FAILED)
-  {
-    return NULL;
-  }
+  if (raw == MAP_FAILED) return NULL;
 
   assert(ctx->mem);
   uint8_t *dest = raw + sizeof(uint64_t);
@@ -76,6 +75,11 @@ cj_fn create_cj_fn(cj_ctx *ctx)
     return NULL;
   }
 
+  ctx->executable_raw = raw;
+  ctx->executable_base = dest;
+  ctx->executable_size = total_size;
+  ctx->executable_code_size = code_size;
+
   // clear the I cache for ARM64
   __builtin___clear_cache((char *)raw, (char *)raw + total_size);
 
@@ -89,8 +93,7 @@ cj_fn create_cj_fn(cj_ctx *ctx)
 void destroy_cj_fn(cj_ctx *ctx, cj_fn mem)
 {
   (void)ctx;
-  if (!mem)
-    return;
+  if (!mem) return;
 
 // yes, yes. unsafe. boo-hoo.
 #pragma GCC diagnostic push
@@ -102,12 +105,19 @@ void destroy_cj_fn(cj_ctx *ctx, cj_fn mem)
   size_t total_size = sizeof(uint64_t) + (size_t)code_size;
 
   munmap(raw, total_size);
+
+  if (ctx)
+  {
+    ctx->executable_base = NULL;
+    ctx->executable_raw = NULL;
+    ctx->executable_size = 0;
+    ctx->executable_code_size = 0;
+  }
 }
 
 void cj_add_u8(cj_ctx *ctx, uint8_t byte)
 {
-  if (ctx->len >= ctx->size)
-    grow_cj_ctx(ctx);
+  if (ctx->len >= ctx->size) grow_cj_ctx(ctx);
 
   ctx->mem[ctx->len++] = byte;
 }
@@ -132,8 +142,7 @@ void cj_add_u64(cj_ctx *ctx, uint64_t b8)
 
 void cj_add_bytes(cj_ctx *ctx, uint8_t *bytes, uint64_t len)
 {
-  for (uint64_t i = 0; i < len; i++)
-    cj_add_u8(ctx, bytes[i]);
+  for (uint64_t i = 0; i < len; i++) cj_add_u8(ctx, bytes[i]);
 }
 
 cj_label cj_create_label(cj_ctx *ctx)
@@ -241,19 +250,12 @@ void cj_emit_branch(cj_ctx *ctx, uint32_t base_instr, cj_label label, uint8_t of
 void cj_emit_x86_rel(cj_ctx *ctx, const uint8_t *opcode, size_t opcode_len, uint8_t disp_width,
                      cj_label label)
 {
-  if (!ctx || !opcode || opcode_len == 0 || disp_width == 0)
-    return;
+  if (!ctx || !opcode || opcode_len == 0 || disp_width == 0) return;
 
-  for (size_t i = 0; i < opcode_len; i++)
-  {
-    cj_add_u8(ctx, opcode[i]);
-  }
+  for (size_t i = 0; i < opcode_len; i++) cj_add_u8(ctx, opcode[i]);
 
   uint64_t disp_pos = ctx->len;
-  for (uint8_t i = 0; i < disp_width; i++)
-  {
-    cj_add_u8(ctx, 0);
-  }
+  for (uint8_t i = 0; i < disp_width; i++) cj_add_u8(ctx, 0);
 
   int label_known =
       (label.id >= 0 && label.id < ctx->num_labels && ctx->label_positions[label.id] != UINT64_MAX);
@@ -266,10 +268,7 @@ void cj_emit_x86_rel(cj_ctx *ctx, const uint8_t *opcode, size_t opcode_len, uint
     if (rel < min || rel > max)
       return;
 
-    for (uint8_t b = 0; b < disp_width; b++)
-    {
-      ctx->mem[disp_pos + b] = (uint8_t)((rel >> (8 * b)) & 0xFF);
-    }
+    for (uint8_t b = 0; b < disp_width; b++) ctx->mem[disp_pos + b] = (uint8_t)((rel >> (8 * b)) & 0xFF);
   }
   else
   {
@@ -288,16 +287,16 @@ void cj_emit_x86_rel(cj_ctx *ctx, const uint8_t *opcode, size_t opcode_len, uint
 
 void *cj_resolve_label(const cj_ctx *ctx, cj_fn module, cj_label label)
 {
-  if (!ctx || !module)
-    return NULL;
+  if (!ctx || !module) return NULL;
 
-  if (label.id < 0 || label.id >= ctx->num_labels)
-    return NULL;
+  if (label.id < 0 || label.id >= ctx->num_labels) return NULL;
 
   uint64_t pos = ctx->label_positions[label.id];
-  if (pos == UINT64_MAX)
-    return NULL;
+  if (pos == UINT64_MAX) return NULL;
+
+  if (!ctx->executable_base) return NULL;
+
+  if (pos >= ctx->executable_code_size) return NULL;
 
-  uint8_t *base = (uint8_t *)(void *)module;
-  return (void *)(base + pos);
+  return (void *)(ctx->executable_base + pos);
 }
diff --git a/src/ctx.h b/src/ctx.h
@@ -48,6 +48,11 @@ typedef struct
   cj_fixup *fixups;
   int num_fixups;
   int fixup_capacity;
+
+  uint8_t *executable_base;
+  uint8_t *executable_raw;
+  size_t executable_size;
+  uint64_t executable_code_size;
 } cj_ctx;
 
 cj_ctx *create_cj_ctx(void);

Original file line number	Diff line number	Diff line change
`@@ -96,8 +96,8 @@ static inline cj_operand cj_builder_call_unary(cj_ctx ctx, cj_builder_scratch `
`96`	`96`	`static inline size_t align_stack_size(size_t size)`
`97`	`97`	`{`
`98`	`98`	`const size_t alignment = 16;`
`99`		`- if (size == 0)`
`100`		`- return 0;`
	`99`	`+ if (size == 0) return 0;`
	`100`	`+`
`101`	`101`	`size_t mask = alignment - 1;`
`102`	`102`	`return (size + mask) & ~mask;`
`103`	`103`	`}`
`@@ -116,8 +116,7 @@ static inline void cj_builder_fn_prologue_with_link_save(cj_ctx *ctx, size_t req`
`116`	`116`
`117`	`117`	`static inline void cj_builder_fn_epilogue(cj_ctx ctx, const cj_builder_frame frame)`
`118`	`118`	`{`
`119`		`- if (!ctx)`
`120`		`- return;`
	`119`	`+ if (!ctx) return;`
`121`	`120`	`size_t aligned = frame ? frame->stack_size : 0;`
`122`	`121`	`int save_lr = (frame && frame->save_lr);`
`123`	`122`
`@@ -157,8 +156,7 @@ static inline void cj_builder_fn_epilogue(cj_ctx ctx, const cj_builder_frame f`
`157`	`156`
`158`	`157`	`static inline void cj_builder_return(cj_ctx ctx, const cj_builder_frame frame)`
`159`	`158`	`{`
`160`		`- if (!ctx)`
`161`		`- return;`
	`159`	`+ if (!ctx) return;`
`162`	`160`	`cj_builder_fn_epilogue(ctx, frame);`
`163`	`161`	`cj_ret(ctx);`
`164`	`162`	`}`
`@@ -333,30 +331,26 @@ static inline cj_builder_block cj_builder_loop_begin(cj_ctx *ctx)`
`333`	`331`	`static inline void cj_builder_loop_condition(cj_ctx *ctx, cj_builder_block block, cj_operand lhs,`
`334`	`332`	`cj_operand rhs, cj_condition exit_cond)`
`335`	`333`	`{`
`336`		`- if (!ctx)`
`337`		`- return;`
	`334`	`+ if (!ctx) return;`
`338`	`335`	`cj_cmp(ctx, lhs, rhs);`
`339`	`336`	`branch_on_condition(ctx, exit_cond, block.exit);`
`340`	`337`	`}`
`341`	`338`
`342`	`339`	`static inline void cj_builder_loop_continue(cj_ctx *ctx, cj_builder_block block)`
`343`	`340`	`{`
`344`		`- if (!ctx)`
`345`		`- return;`
	`341`	`+ if (!ctx) return;`
`346`	`342`	`branch_unconditional(ctx, block.entry);`
`347`	`343`	`}`
`348`	`344`
`349`	`345`	`static inline void cj_builder_loop_break(cj_ctx *ctx, cj_builder_block block)`
`350`	`346`	`{`
`351`		`- if (!ctx)`
`352`		`- return;`
	`347`	`+ if (!ctx) return;`
`353`	`348`	`branch_unconditional(ctx, block.exit);`
`354`	`349`	`}`
`355`	`350`
`356`	`351`	`static inline void cj_builder_loop_end(cj_ctx *ctx, cj_builder_block block)`
`357`	`352`	`{`
`358`		`- if (!ctx)`
`359`		`- return;`
	`353`	`+ if (!ctx) return;`
`360`	`354`	`branch_unconditional(ctx, block.entry);`
`361`	`355`	`cj_mark_label(ctx, block.exit);`
`362`	`356`	`}`
`@@ -375,17 +369,15 @@ cj_builder_if_block cj_builder_if(cj_ctx *ctx, cj_operand lhs, cj_operand rhs, c`
`375`	`369`
`376`	`370`	`void cj_builder_else(cj_ctx ctx, cj_builder_if_block block)`
`377`	`371`	`{`
`378`		`- if (!ctx \|\| !block)`
`379`		`- return;`
	`372`	`+ if (!ctx \|\| !block) return;`
`380`	`373`	`branch_unconditional(ctx, block->end_label);`
`381`	`374`	`cj_mark_label(ctx, block->else_label);`
`382`	`375`	`block->has_else = 1;`
`383`	`376`	`}`
`384`	`377`
`385`	`378`	`void cj_builder_endif(cj_ctx ctx, cj_builder_if_block block)`
`386`	`379`	`{`
`387`		`- if (!ctx \|\| !block)`
`388`		`- return;`
	`380`	`+ if (!ctx \|\| !block) return;`
`389`	`381`	`if (!block->has_else)`
`390`	`382`	`{`
`391`	`383`	`cj_mark_label(ctx, block->else_label);`
`@@ -404,10 +396,7 @@ static inline cj_builder_for_loop cj_builder_for_begin(cj_ctx *ctx, cj_operand c`
`404`	`396`	`.exit_cond = exit_cond,`
`405`	`397`	`};`
`406`	`398`
`407`		`- if (counter.type == CJ_REGISTER)`
`408`		`- {`
`409`		`- cj_mov(ctx, counter, start);`
`410`		`- }`
	`399`	`+ if (counter.type == CJ_REGISTER) cj_mov(ctx, counter, start);`
`411`	`400`
`412`	`401`	`loop.block = cj_builder_loop_begin(ctx);`
`413`	`402`	`cj_builder_loop_condition(ctx, loop.block, counter, limit, exit_cond);`
`@@ -416,23 +405,20 @@ static inline cj_builder_for_loop cj_builder_for_begin(cj_ctx *ctx, cj_operand c`
`416`	`405`
`417`	`406`	`static inline void cj_builder_for_continue(cj_ctx ctx, cj_builder_for_loop loop)`
`418`	`407`	`{`
`419`		`- if (!ctx \|\| !loop)`
`420`		`- return;`
	`408`	`+ if (!ctx \|\| !loop) return;`
`421`	`409`	`cj_add(ctx, loop->counter, loop->step);`
`422`	`410`	`cj_builder_loop_continue(ctx, loop->block);`
`423`	`411`	`}`
`424`	`412`
`425`	`413`	`static inline void cj_builder_for_break(cj_ctx ctx, cj_builder_for_loop loop)`
`426`	`414`	`{`
`427`		`- if (!ctx \|\| !loop)`
`428`		`- return;`
	`415`	`+ if (!ctx \|\| !loop) return;`
`429`	`416`	`cj_builder_loop_break(ctx, loop->block);`
`430`	`417`	`}`
`431`	`418`
`432`	`419`	`static inline void cj_builder_for_end(cj_ctx ctx, cj_builder_for_loop loop)`
`433`	`420`	`{`
`434`		`- if (!ctx \|\| !loop)`
`435`		`- return;`
	`421`	`+ if (!ctx \|\| !loop) return;`
`436`	`422`	`cj_add(ctx, loop->counter, loop->step);`
`437`	`423`	`cj_builder_loop_end(ctx, loop->block);`
`438`	`424`	`}`
`@@ -456,8 +442,8 @@ static inline cj_operand cj_builder_assign(cj_ctx *ctx, cj_operand dst, cj_opera`
`456`	`442`	`for (int shift = 16; shift < (is64 ? 64 : 32); shift += 16)`
`457`	`443`	`{`
`458`	`444`	`uint16_t part = (uint16_t)((value >> shift) & 0xFFFFu);`
`459`		`- if (!part)`
`460`		`- continue;`
	`445`	`+ if (!part) continue;`
	`446`	`+`
`461`	`447`	`uint64_t encoded = (uint64_t)part \| ((uint64_t)(shift / 16) << 16);`
`462`	`448`	`cj_operand next = cj_make_constant(encoded);`
`463`	`449`	`cj_movk(ctx, dst, next);`
`@@ -525,21 +511,15 @@ static inline cj_operand cj_builder_arg_int(cj_ctx *ctx, unsigned index)`
`525`	`511`	`static inline void cj_builder_return_value(cj_ctx ctx, const cj_builder_frame frame,`
`526`	`512`	`cj_operand value)`
`527`	`513`	`{`
`528`		`- if (!ctx)`
`529`		`- return;`
	`514`	`+ if (!ctx) return;`
`530`	`515`	`cj_operand ret = get_return_operand();`
`531`	`516`	`int needs_move = 1;`
`532`	`517`	`if (value.type == CJ_REGISTER && value.reg && ret.reg)`
`533`	`518`	`{`
`534`		`- if (strcmp(value.reg, ret.reg) == 0)`
`535`		`- {`
`536`		`- needs_move = 0;`
`537`		`- }`
`538`		`- }`
`539`		`- if (needs_move)`
`540`		`- {`
`541`		`- cj_mov(ctx, ret, value);`
	`519`	`+ if (strcmp(value.reg, ret.reg) == 0) needs_move = 0;`
`542`	`520`	`}`
	`521`	`+ if (needs_move) cj_mov(ctx, ret, value);`
	`522`	`+`
`543`	`523`	`cj_builder_return(ctx, frame);`
`544`	`524`	`}`
`545`	`525`
`@@ -554,8 +534,7 @@ static inline cj_operand cj_builder_zero_operand(void)`
`554`	`534`
`555`	`535`	`static inline void cj_builder_clear(cj_ctx *ctx, cj_operand dst)`
`556`	`536`	`{`
`557`		`- if (!ctx)`
`558`		`- return;`
	`537`	`+ if (!ctx) return;`
`559`	`538`	`#if defined(__x86_64__) \|\| defined(_M_X64)`
`560`	`539`	`if (dst.type == CJ_REGISTER)`
`561`	`540`	`{`
`@@ -603,8 +582,7 @@ static inline unsigned cj_builder_arg_int_capacity(void)`
`603`	`582`
`604`	`583`	`static inline void cj_builder_scratch_init(cj_builder_scratch *scratch)`
`605`	`584`	`{`
`606`		`- if (!scratch)`
`607`		`- return;`
	`585`	`+ if (!scratch) return;`
`608`	`586`	`scratch->depth = 0;`
`609`	`587`	`}`
`610`	`588`
`@@ -642,8 +620,7 @@ static inline cj_operand cj_builder_call_unary(cj_ctx ctx, cj_builder_scratch `
`642`	`620`	`static inline cj_operand cj_builder_call(cj_ctx ctx, cj_builder_scratch scratch, cj_label target,`
`643`	`621`	`const cj_operand *args, size_t arg_count)`
`644`	`622`	`{`
`645`		`- if (!ctx)`
`646`		`- return cj_builder_return_reg();`
	`623`	`+ if (!ctx) return cj_builder_return_reg();`
`647`	`624`
`648`	`625`	`unsigned capacity = cj_builder_arg_int_capacity();`
`649`	`626`	`assert(arg_count <= capacity);`
`@@ -654,8 +631,7 @@ static inline cj_operand cj_builder_call(cj_ctx ctx, cj_builder_scratch scratc`
`654`	`631`	`cj_builder_assign(ctx, reg, args[i]);`
`655`	`632`	`}`
`656`	`633`
`657`		`- if (scratch)`
`658`		`- cj_builder_scratch_release(scratch);`
	`634`	`+ if (scratch) cj_builder_scratch_release(scratch);`
`659`	`635`
`660`	`636`	`cj_builder_call_label(ctx, target);`
`661`	`637`
`@@ -672,8 +648,7 @@ static inline cj_operand cj_builder_call(cj_ctx ctx, cj_builder_scratch scratc`
`672`	`648`	`static inline void cj_builder_fn_prologue_ex(cj_ctx *ctx, size_t requested_stack_bytes,`
`673`	`649`	`cj_builder_frame *frame, int save_lr)`
`674`	`650`	`{`
`675`		`- if (!ctx)`
`676`		`- return;`
	`651`	`+ if (!ctx) return;`
`677`	`652`	`assert(!save_lr \|\| frame);`
`678`	`653`
`679`	`654`	`size_t aligned = align_stack_size(requested_stack_bytes);`