@fraczak/k 6.4.0 → 6.6.0

package/backends/llvm/runtime/krt.c

@@ -5,13 +5,14 @@
 #include <string.h>
 
 enum {
-  K_ARENA_BLOCK_SIZE = 262144
+  K_ARENA_BLOCK_SIZE = 4194304
 };
 
 typedef enum {
   K_VALUE_UNIT,
   K_VALUE_PRODUCT,
-  K_VALUE_VARIANT
+  K_VALUE_VARIANT,
+  K_VALUE_FORWARDED = 99
 } k_value_kind;
 
 typedef struct {
@@ -221,6 +222,390 @@ void k_rt_rewind(k_rt *rt, k_rt_checkpoint mark) {
   rt->has_reusable_blocks = has_reusable;
 }
 
+typedef struct {
+  size_t *offsets;
+  size_t count;
+  size_t capacity;
+} k_fixup_list;
+
+static void fixup_add(k_fixup_list *list, size_t offset) {
+  if (list->count == list->capacity) {
+    size_t new_cap = list->capacity == 0 ? 1024 : list->capacity * 2;
+    size_t *new_offsets = (size_t *)realloc(list->offsets, new_cap * sizeof(size_t));
+    if (new_offsets == NULL) abort();
+    list->offsets = new_offsets;
+    list->capacity = new_cap;
+  }
+  list->offsets[list->count++] = offset;
+}
+
+static int is_after_mark(k_rt *rt, const void *ptr, k_rt_checkpoint mark) {
+  if (rt == NULL || ptr == NULL) return 0;
+  const unsigned char *p = (const unsigned char *)ptr;
+  k_arena_block *mb = (k_arena_block *)mark.block;
+  if (mb == NULL) {
+    for (k_arena_block *b = rt->blocks; b != NULL; b = b->next) {
+      if (p >= b->data && p < b->data + b->capacity) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+  if (rt->blocks == mb) {
+    return (p >= mb->data + mark.used && p < mb->data + mb->capacity);
+  }
+  for (k_arena_block *b = rt->blocks; b != NULL; b = b->next) {
+    if (b == mb) {
+      return (p >= b->data + mark.used && p < b->data + b->capacity);
+    }
+    if (p >= b->data && p < b->data + b->capacity) {
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static size_t bytes_since_mark(k_rt *rt, k_rt_checkpoint mark) {
+  if (rt == NULL || rt->blocks == NULL) return 0;
+  k_arena_block *mb = (k_arena_block *)mark.block;
+  if (rt->blocks == mb) {
+    return rt->blocks->used >= mark.used ? rt->blocks->used - mark.used : 0;
+  }
+  size_t total = 0;
+  if (mb == NULL) {
+    for (k_arena_block *b = rt->blocks; b != NULL; b = b->next) {
+      total += b->used;
+    }
+    return total;
+  }
+  for (k_arena_block *b = rt->blocks; b != NULL; b = b->next) {
+    if (b == mb) {
+      if (b->used > mark.used) {
+        total += (b->used - mark.used);
+      }
+      break;
+    }
+    total += b->used;
+  }
+  return total;
+}
+
+static void *staging_alloc(unsigned char **staging_ptr, size_t *used, size_t *capacity, size_t size, k_fixup_list *fixups) {
+  size = align_size(size == 0 ? 1 : size);
+  if (*used + size > *capacity) {
+    size_t old_cap = *capacity;
+    size_t new_cap = (old_cap + size) * 2;
+    unsigned char *old_buf = *staging_ptr;
+    unsigned char *new_buf = (unsigned char *)realloc(old_buf, new_cap);
+    if (new_buf == NULL) abort();
+    if (new_buf != old_buf) {
+      ptrdiff_t realloc_diff = new_buf - old_buf;
+      for (size_t i = 0; i < fixups->count; i++) {
+        size_t off = fixups->offsets[i];
+        unsigned char **p = (unsigned char **)(new_buf + off);
+        *p += realloc_diff;
+      }
+    }
+    *staging_ptr = new_buf;
+    *capacity = new_cap;
+  }
+  void *p = *staging_ptr + *used;
+  *used += size;
+  return p;
+}
+
+static k_value *copy_value(k_rt *rt, k_value *root, unsigned char **staging_ptr, size_t *staging_used, size_t *staging_cap, k_fixup_list *fixups, k_rt_checkpoint mark) {
+  if (root == NULL || !is_after_mark(rt, root, mark)) {
+    return root;
+  }
+  if ((int)root->kind == K_VALUE_FORWARDED) {
+    return root->as.variant.payload;
+  }
+
+  if (root->kind == K_VALUE_VARIANT) {
+    k_value *first_staged = NULL;
+    k_value *prev_staged = NULL;
+    k_value *curr = root;
+
+    while (curr != NULL) {
+      if (!is_after_mark(rt, curr, mark)) {
+        if (prev_staged != NULL) {
+          prev_staged->as.variant.payload = curr;
+        }
+        if (first_staged == NULL) {
+          first_staged = curr;
+        }
+        break;
+      }
+
+      if ((int)curr->kind == K_VALUE_FORWARDED) {
+        k_value *staged_target = curr->as.variant.payload;
+        if (prev_staged != NULL) {
+          prev_staged->as.variant.payload = staged_target;
+          fixup_add(fixups, (unsigned char *)&prev_staged->as.variant.payload - *staging_ptr);
+        }
+        if (first_staged == NULL) {
+          first_staged = staged_target;
+        }
+        break;
+      }
+
+      if (curr->as.variant.tag != NULL) {
+        if (bytes_equal(curr->as.variant.tag, curr->as.variant.tag_length, "Float64", 7)) {
+          k_value *staged_v = (k_value *)staging_alloc(staging_ptr, staging_used, staging_cap, sizeof(k_value), fixups);
+          staged_v->kind = K_VALUE_VARIANT;
+          staged_v->rt = rt;
+          staged_v->as.variant.tag = curr->as.variant.tag;
+          staged_v->as.variant.tag_length = curr->as.variant.tag_length;
+          staged_v->as.variant.payload = NULL;
+
+          if (is_after_mark(rt, curr->as.variant.tag, mark)) {
+            char *staged_tag = (char *)staging_alloc(staging_ptr, staging_used, staging_cap, curr->as.variant.tag_length + 1, fixups);
+            memcpy(staged_tag, curr->as.variant.tag, curr->as.variant.tag_length);
+            staged_tag[curr->as.variant.tag_length] = 0;
+            staged_v->as.variant.tag = staged_tag;
+            fixup_add(fixups, (unsigned char *)&staged_v->as.variant.tag - *staging_ptr);
+          }
+
+          if (curr->as.variant.payload != NULL && is_after_mark(rt, curr->as.variant.payload, mark)) {
+            void *raw = staging_alloc(staging_ptr, staging_used, staging_cap, sizeof(double), fixups);
+            memcpy(raw, curr->as.variant.payload, sizeof(double));
+            staged_v->as.variant.payload = (k_value *)raw;
+            fixup_add(fixups, (unsigned char *)&staged_v->as.variant.payload - *staging_ptr);
+          } else {
+            staged_v->as.variant.payload = curr->as.variant.payload;
+          }
+
+          if (prev_staged != NULL) {
+            prev_staged->as.variant.payload = staged_v;
+            fixup_add(fixups, (unsigned char *)&prev_staged->as.variant.payload - *staging_ptr);
+          }
+          if (first_staged == NULL) {
+            first_staged = staged_v;
+          }
+          curr->kind = (k_value_kind)K_VALUE_FORWARDED;
+          curr->as.variant.payload = staged_v;
+          break;
+        }
+
+        if (bytes_equal(curr->as.variant.tag, curr->as.variant.tag_length, "Int32", 5)) {
+          k_value *staged_v = (k_value *)staging_alloc(staging_ptr, staging_used, staging_cap, sizeof(k_value), fixups);
+          staged_v->kind = K_VALUE_VARIANT;
+          staged_v->rt = rt;
+          staged_v->as.variant.tag = curr->as.variant.tag;
+          staged_v->as.variant.tag_length = curr->as.variant.tag_length;
+          staged_v->as.variant.payload = NULL;
+
+          if (is_after_mark(rt, curr->as.variant.tag, mark)) {
+            char *staged_tag = (char *)staging_alloc(staging_ptr, staging_used, staging_cap, curr->as.variant.tag_length + 1, fixups);
+            memcpy(staged_tag, curr->as.variant.tag, curr->as.variant.tag_length);
+            staged_tag[curr->as.variant.tag_length] = 0;
+            staged_v->as.variant.tag = staged_tag;
+            fixup_add(fixups, (unsigned char *)&staged_v->as.variant.tag - *staging_ptr);
+          }
+
+          if (curr->as.variant.payload != NULL && is_after_mark(rt, curr->as.variant.payload, mark)) {
+            void *raw = staging_alloc(staging_ptr, staging_used, staging_cap, sizeof(int32_t), fixups);
+            memcpy(raw, curr->as.variant.payload, sizeof(int32_t));
+            staged_v->as.variant.payload = (k_value *)raw;
+            fixup_add(fixups, (unsigned char *)&staged_v->as.variant.payload - *staging_ptr);
+          } else {
+            staged_v->as.variant.payload = curr->as.variant.payload;
+          }
+
+          if (prev_staged != NULL) {
+            prev_staged->as.variant.payload = staged_v;
+            fixup_add(fixups, (unsigned char *)&prev_staged->as.variant.payload - *staging_ptr);
+          }
+          if (first_staged == NULL) {
+            first_staged = staged_v;
+          }
+          curr->kind = (k_value_kind)K_VALUE_FORWARDED;
+          curr->as.variant.payload = staged_v;
+          break;
+        }
+      }
+
+      if (curr->kind != K_VALUE_VARIANT) {
+        k_value *staged_child = copy_value(rt, curr, staging_ptr, staging_used, staging_cap, fixups, mark);
+        if (prev_staged != NULL) {
+          prev_staged->as.variant.payload = staged_child;
+          if (staged_child != NULL && (unsigned char *)staged_child >= *staging_ptr && (unsigned char *)staged_child < *staging_ptr + *staging_used) {
+            fixup_add(fixups, (unsigned char *)&prev_staged->as.variant.payload - *staging_ptr);
+          }
+        }
+        if (first_staged == NULL) {
+          first_staged = staged_child;
+        }
+        break;
+      }
+
+      k_value *staged_v = (k_value *)staging_alloc(staging_ptr, staging_used, staging_cap, sizeof(k_value), fixups);
+      staged_v->kind = K_VALUE_VARIANT;
+      staged_v->rt = rt;
+      staged_v->as.variant.tag = curr->as.variant.tag;
+      staged_v->as.variant.tag_length = curr->as.variant.tag_length;
+      staged_v->as.variant.payload = NULL;
+
+      if (curr->as.variant.tag != NULL && is_after_mark(rt, curr->as.variant.tag, mark)) {
+        char *staged_tag = (char *)staging_alloc(staging_ptr, staging_used, staging_cap, curr->as.variant.tag_length + 1, fixups);
+        memcpy(staged_tag, curr->as.variant.tag, curr->as.variant.tag_length);
+        staged_tag[curr->as.variant.tag_length] = 0;
+        staged_v->as.variant.tag = staged_tag;
+        fixup_add(fixups, (unsigned char *)&staged_v->as.variant.tag - *staging_ptr);
+      }
+
+      if (prev_staged != NULL) {
+        prev_staged->as.variant.payload = staged_v;
+        fixup_add(fixups, (unsigned char *)&prev_staged->as.variant.payload - *staging_ptr);
+      }
+      if (first_staged == NULL) {
+        first_staged = staged_v;
+      }
+
+      k_value *next = curr->as.variant.payload;
+      curr->kind = (k_value_kind)K_VALUE_FORWARDED;
+      curr->as.variant.payload = staged_v;
+
+      prev_staged = staged_v;
+      curr = next;
+    }
+
+    return first_staged;
+  }
+
+  size_t header_size = align_size(sizeof(k_value));
+  size_t fields_size = root->as.product.count * sizeof(k_field);
+  size_t total_size = header_size + fields_size;
+
+  k_value *staged_p = (k_value *)staging_alloc(staging_ptr, staging_used, staging_cap, total_size, fixups);
+  staged_p->kind = root->kind;
+  staged_p->rt = rt;
+  staged_p->as.product.count = root->as.product.count;
+  staged_p->as.product.capacity = root->as.product.count;
+
+  if (root->as.product.count > 0) {
+    k_field *staged_fields = (k_field *)((unsigned char *)staged_p + header_size);
+    staged_p->as.product.fields = staged_fields;
+    fixup_add(fixups, (unsigned char *)&staged_p->as.product.fields - *staging_ptr);
+
+    k_field *old_fields = root->as.product.fields;
+    size_t count = root->as.product.count;
+
+    root->kind = (k_value_kind)K_VALUE_FORWARDED;
+    root->as.variant.payload = staged_p;
+
+    for (size_t i = 0; i < count; i++) {
+      staged_fields[i].label_length = old_fields[i].label_length;
+      staged_fields[i].label = old_fields[i].label;
+      if (old_fields[i].label != NULL && is_after_mark(rt, old_fields[i].label, mark)) {
+        char *staged_label = (char *)staging_alloc(staging_ptr, staging_used, staging_cap, old_fields[i].label_length + 1, fixups);
+        memcpy(staged_label, old_fields[i].label, old_fields[i].label_length);
+        staged_label[old_fields[i].label_length] = 0;
+        staged_fields[i].label = staged_label;
+        fixup_add(fixups, (unsigned char *)&staged_fields[i].label - *staging_ptr);
+      }
+
+      k_value *child = copy_value(rt, old_fields[i].value, staging_ptr, staging_used, staging_cap, fixups, mark);
+      staged_fields[i].value = child;
+      if (child != NULL && (unsigned char *)child >= *staging_ptr && (unsigned char *)child < *staging_ptr + *staging_used) {
+        fixup_add(fixups, (unsigned char *)&staged_fields[i].value - *staging_ptr);
+      }
+    }
+  } else {
+    staged_p->as.product.fields = NULL;
+    root->kind = (k_value_kind)K_VALUE_FORWARDED;
+    root->as.variant.payload = staged_p;
+  }
+
+  return staged_p;
+}
+
+static void rt_rewind_and_free(k_rt *rt, k_rt_checkpoint mark) {
+  if (rt == NULL) return;
+  if (mark.block == NULL) {
+    k_arena_block *b = rt->blocks;
+    while (b != NULL) {
+      k_arena_block *next = b->next;
+      free(b);
+      b = next;
+    }
+    rt->blocks = NULL;
+    rt->unit_cache = NULL;
+    rt->bit0_cache = NULL;
+    rt->bit1_cache = NULL;
+    rt->has_reusable_blocks = 0;
+    return;
+  }
+  k_arena_block *b = rt->blocks;
+  while (b != NULL && b != (k_arena_block *)mark.block) {
+    k_arena_block *next = b->next;
+    free(b);
+    b = next;
+  }
+  rt->blocks = (k_arena_block *)mark.block;
+  if (rt->blocks != NULL) {
+    rt->blocks->used = mark.used;
+  }
+  rt->unit_cache = NULL;
+  rt->bit0_cache = NULL;
+  rt->bit1_cache = NULL;
+  rt->has_reusable_blocks = 0;
+}
+
+k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_checkpoint *mark_ptr) {
+  if (rt == NULL || root == NULL || mark_ptr == NULL) return root;
+
+  size_t bytes = bytes_since_mark(rt, *mark_ptr);
+  if (bytes < 4194304) {
+    return root;
+  }
+
+  if (!is_after_mark(rt, root, *mark_ptr)) {
+    rt_rewind_and_free(rt, *mark_ptr);
+    return root;
+  }
+
+  size_t staging_cap = bytes + 65536;
+  unsigned char *staging = (unsigned char *)malloc(staging_cap);
+  if (staging == NULL) abort();
+  size_t staging_used = 0;
+
+  k_fixup_list fixups = {NULL, 0, 0};
+
+  k_value *staged_root = copy_value(rt, root, &staging, &staging_used, &staging_cap, &fixups, *mark_ptr);
+
+  rt_rewind_and_free(rt, *mark_ptr);
+
+  if (staging_used == 0) {
+    free(staging);
+    if (fixups.offsets != NULL) free(fixups.offsets);
+    return staged_root;
+  }
+
+  void *arena_dest = rt_alloc(rt, staging_used);
+  if (arena_dest == NULL) abort();
+
+  ptrdiff_t diff = (unsigned char *)arena_dest - staging;
+
+  for (size_t i = 0; i < fixups.count; i++) {
+    size_t off = fixups.offsets[i];
+    unsigned char **p = (unsigned char **)(staging + off);
+    *p += diff;
+  }
+
+  memcpy(arena_dest, staging, staging_used);
+
+  k_value *new_root = (staged_root != NULL && (unsigned char *)staged_root >= staging && (unsigned char *)staged_root < staging + staging_used)
+    ? (k_value *)((unsigned char *)staged_root + diff)
+    : staged_root;
+
+  free(staging);
+  if (fixups.offsets != NULL) free(fixups.offsets);
+
+  return new_root;
+}
+
 void k_rt_free(k_rt *rt) {
   if (rt == NULL) return;
   k_arena_block *block = rt->blocks;

package/backends/llvm/runtime/krt.h

@@ -66,6 +66,7 @@ k_rt *k_rt_new(void);
 void k_rt_reset(k_rt *rt);
 k_rt_checkpoint k_rt_mark(k_rt *rt);
 void k_rt_rewind(k_rt *rt, k_rt_checkpoint mark);
+k_value *k_rt_compact(k_rt *rt, k_value *root, k_rt_checkpoint *mark_ptr);
 void *k_rt_alloc(k_rt *rt, size_t size);
 void k_rt_free(k_rt *rt);
 

package/backends/llvm/src/kvm2llvm.mjs

@@ -53,6 +53,7 @@ export function runtimeDeclarations() {
     "",
     "declare %k_rt_mark @k_rt_mark(ptr)",
     "declare void @k_rt_rewind(ptr, %k_rt_mark)",
+    "declare ptr @k_rt_compact(ptr, ptr, ptr)",
     "declare ptr @k_rt_alloc(ptr, i64)",
     "declare ptr @k_unit(ptr)",
     "declare ptr @k_bit0(ptr)",
@@ -146,10 +147,11 @@ function lowerRawVariant(ctx, tag, payload) {
   return variant;
 }
 
-function lowerProductGetAt(ctx, input, edgeIndex) {
+function lowerProductGetAt(ctx, input, edgeIndex, label = null) {
   const nonNullBlock = ctx.blockName("product_non_null");
   const productBlock = ctx.blockName("product_kind");
   const fieldBlock = ctx.blockName("product_field");
+  const fallbackBlock = ctx.blockName("product_fallback");
   const missingBlock = ctx.blockName("product_missing");
   const doneBlock = ctx.blockName("product_done");
   const isMissing = ctx.tempName("product_is_missing");
@@ -172,16 +174,38 @@ function lowerProductGetAt(ctx, input, edgeIndex) {
   const fields = loadPtrAt(ctx, input, K_VALUE_PRODUCT_FIELDS_OFFSET, "product_fields_ptr");
   const slot = bytePtr(ctx, fields, edgeIndex * K_FIELD_SIZE, "field_slot");
   const value = loadPtrAt(ctx, slot, K_FIELD_VALUE_OFFSET, "field");
-  ctx.lines.push(`  br label %${doneBlock}`);
 
-  ctx.lines.push(`${missingBlock}:`);
-  ctx.lines.push(`  br label %${doneBlock}`);
+  if (label) {
+    const fLabel = loadPtrAt(ctx, slot, K_FIELD_LABEL_OFFSET, "field_label");
+    const labelMatch = ctx.tempName("label_match");
+    ctx.lines.push(`  ${labelMatch} = icmp eq ptr ${fLabel}, ${label.pointer}`);
+    ctx.lines.push(`  br i1 ${labelMatch}, label %${doneBlock}, label %${fallbackBlock}`);
+
+    ctx.lines.push(`${fallbackBlock}:`);
+    const fallbackVal = ctx.tempName("fallback_field");
+    ctx.lines.push(`  ${fallbackVal} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
+    ctx.lines.push(`  br label %${doneBlock}`);
+
+    ctx.lines.push(`${missingBlock}:`);
+    ctx.lines.push(`  br label %${doneBlock}`);
+
+    ctx.lines.push(`${doneBlock}:`);
+    const resultValue = ctx.tempName("field_value");
+    ctx.lines.push(`  ${resultValue} = phi ptr [${value}, %${fieldBlock}], [${fallbackVal}, %${fallbackBlock}], [null, %${missingBlock}]`);
+    ctx.currentBlock = doneBlock;
+    return resultValue;
+  } else {
+    ctx.lines.push(`  br label %${doneBlock}`);
 
-  ctx.lines.push(`${doneBlock}:`);
-  const resultValue = ctx.tempName("field_value");
-  ctx.lines.push(`  ${resultValue} = phi ptr [${value}, %${fieldBlock}], [null, %${missingBlock}]`);
-  ctx.currentBlock = doneBlock;
-  return resultValue;
+    ctx.lines.push(`${missingBlock}:`);
+    ctx.lines.push(`  br label %${doneBlock}`);
+
+    ctx.lines.push(`${doneBlock}:`);
+    const resultValue = ctx.tempName("field_value");
+    ctx.lines.push(`  ${resultValue} = phi ptr [${value}, %${fieldBlock}], [null, %${missingBlock}]`);
+    ctx.currentBlock = doneBlock;
+    return resultValue;
+  }
 }
 
 function lowerVariantMatchBranch(ctx, input, label, matchBlock, mismatchBlock) {
@@ -287,6 +311,56 @@ function lowerRtRewind(ctx, mark) {
   ctx.currentBlock = doneBlock;
 }
 
+function lowerRtCompact(ctx, val, tailMarkSlot = "%tail_mark_slot") {
+  const curBlock = loadPtrAt(ctx, "%rt", K_RT_BLOCKS_OFFSET, "cur_block");
+  const hasBlock = ctx.tempName("has_block");
+  const markBlockPtr = ctx.tempName("mark_block_ptr");
+  ctx.lines.push(`  ${hasBlock} = icmp ne ptr ${curBlock}, null`);
+  ctx.lines.push(`  ${markBlockPtr} = getelementptr inbounds %k_rt_mark, ptr ${tailMarkSlot}, i32 0, i32 0`);
+  const markBlock = ctx.tempName("mark_block");
+  ctx.lines.push(`  ${markBlock} = load ptr, ptr ${markBlockPtr}`);
+
+  const diffBlock = ctx.tempName("diff_block");
+  ctx.lines.push(`  ${diffBlock} = icmp ne ptr ${curBlock}, ${markBlock}`);
+  const needCheck = ctx.tempName("need_growth_check");
+  ctx.lines.push(`  ${needCheck} = and i1 ${hasBlock}, ${diffBlock}`);
+
+  const checkGrowthBlock = ctx.blockName("check_growth");
+  const doCompactBlock = ctx.blockName("do_compact");
+  const doneBlock = ctx.blockName("compact_done");
+
+  ctx.lines.push(`  br i1 ${needCheck}, label %${doCompactBlock}, label %${checkGrowthBlock}`);
+
+  ctx.lines.push(`${checkGrowthBlock}:`);
+  const checkBlockHasBlock = ctx.tempName("check_has_block");
+  ctx.lines.push(`  ${checkBlockHasBlock} = icmp ne ptr ${curBlock}, null`);
+  const loadGrowthBlock = ctx.blockName("load_growth");
+  ctx.lines.push(`  br i1 ${checkBlockHasBlock}, label %${loadGrowthBlock}, label %${doneBlock}`);
+
+  ctx.lines.push(`${loadGrowthBlock}:`);
+  const curUsed = loadI64At(ctx, curBlock, K_ARENA_BLOCK_USED_OFFSET, "cur_used");
+  const markUsedPtr = ctx.tempName("mark_used_ptr");
+  ctx.lines.push(`  ${markUsedPtr} = getelementptr inbounds %k_rt_mark, ptr ${tailMarkSlot}, i32 0, i32 1`);
+  const markUsed = ctx.tempName("mark_used");
+  ctx.lines.push(`  ${markUsed} = load i64, ptr ${markUsedPtr}`);
+  const growth = ctx.tempName("arena_growth");
+  ctx.lines.push(`  ${growth} = sub i64 ${curUsed}, ${markUsed}`);
+  const threshExceeded = ctx.tempName("thresh_exceeded");
+  ctx.lines.push(`  ${threshExceeded} = icmp ugt i64 ${growth}, 4194304`);
+  ctx.lines.push(`  br i1 ${threshExceeded}, label %${doCompactBlock}, label %${doneBlock}`);
+
+  ctx.lines.push(`${doCompactBlock}:`);
+  const compacted = ctx.tempName("compacted");
+  ctx.lines.push(`  ${compacted} = call ptr @k_rt_compact(ptr %rt, ptr ${val}, ptr ${tailMarkSlot})`);
+  ctx.lines.push(`  br label %${doneBlock}`);
+
+  ctx.lines.push(`${doneBlock}:`);
+  const finalVal = ctx.tempName("compact_res");
+  ctx.lines.push(`  ${finalVal} = phi ptr [${val}, %${checkGrowthBlock}], [${val}, %${loadGrowthBlock}], [${compacted}, %${doCompactBlock}]`);
+  ctx.currentBlock = doneBlock;
+  return finalVal;
+}
+
 function nullCheck(ctx, val, failTarget) {
   const isMissing = ctx.tempName("missing");
   const okBlock = ctx.blockName("nonnull");
@@ -322,7 +396,8 @@ function statusCheck(ctx, callResult, failTarget = "func_fail") {
   if (ctx.catchTail) {
     const tailInput = ctx.tempName("tail_arg");
     ctx.lines.push(`  ${tailInput} = extractvalue %k_result ${callResult}, 1`);
-    ctx.lines.push(`  store ptr ${tailInput}, ptr %tail_input_slot`);
+    const compacted = lowerRtCompact(ctx, tailInput, "%tail_mark_slot");
+    ctx.lines.push(`  store ptr ${compacted}, ptr %tail_input_slot`);
     ctx.lines.push("  br label %tail_loop");
   } else {
     ctx.lines.push(`  ret %k_result ${callResult}`);
@@ -366,8 +441,7 @@ function hasSelfTailCall(insts, funcName, isTail = true) {
     if (inst.branches) {
       const unionIsTail = isTail && tailValueAfter(insts, i + 1, inst.dest);
       for (let bIdx = 0; bIdx < inst.branches.length; bIdx++) {
-        const isLast = (bIdx === inst.branches.length - 1);
-        if (hasSelfTailCall(inst.branches[bIdx].body, funcName, unionIsTail && isLast)) return true;
+        if (hasSelfTailCall(inst.branches[bIdx].body, funcName, unionIsTail)) return true;
       }
     }
   }
@@ -384,13 +458,6 @@ function getFieldEdgeIndex(inst, regPatterns, kvmFunc) {
       if (idx >= 0) return idx;
     }
   }
-  if (Array.isArray(inst.pattern) && inst.pattern.length > 0) {
-    const root = inst.pattern[0];
-    if ((root[0] === "open-product" || root[0] === "closed-product") && Array.isArray(root[1])) {
-      const idx = root[1].findIndex(([l]) => l === inst.label);
-      if (idx >= 0) return idx;
-    }
-  }
   return -1;
 }
 
@@ -538,7 +605,11 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
 
   if (isCatchTail) {
     ctx.allocas.push("  %tail_input_slot = alloca ptr");
+    ctx.allocas.push("  %tail_mark_slot = alloca %k_rt_mark");
     ctx.lines.push("  store ptr %input, ptr %tail_input_slot");
+    const initMark = ctx.tempName("init_mark");
+    ctx.lines.push(`  ${initMark} = call %k_rt_mark @k_rt_mark(ptr %rt)`);
+    ctx.lines.push(`  store %k_rt_mark ${initMark}, ptr %tail_mark_slot`);
     ctx.lines.push("  br label %tail_loop");
     ctx.lines.push("tail_loop:");
     ctx.lines.push("  %tail_input = load ptr, ptr %tail_input_slot");
@@ -598,17 +669,13 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const input = getReg(inst.src);
           nullCheck(ctx, input, failTarget);
           const edgeIndex = getFieldEdgeIndex(inst, regPatterns, kvmFunc);
+          const label = ctx.labelRef(inst.label);
           let val;
           if (edgeIndex >= 0 && ctx.runtimeMode !== "compact") {
-            val = lowerProductGetAt(ctx, input, edgeIndex);
+            val = lowerProductGetAt(ctx, input, edgeIndex, label);
           } else {
-            const label = ctx.labelRef(inst.label);
             val = ctx.tempName("field");
-            if (edgeIndex >= 0) {
-              ctx.lines.push(`  ${val} = call ptr @k_product_get_at(ptr ${input}, i64 ${edgeIndex})`);
-            } else {
-              ctx.lines.push(`  ${val} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
-            }
+            ctx.lines.push(`  ${val} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
           }
           nullCheck(ctx, val, failTarget);
           regValues.set(cleanReg(inst.dest), val);
@@ -656,7 +723,8 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const v = getReg(inst.src);
           if (isSelfTailCall(insts, i, tailRef)) {
             if (ctx.catchTail) {
-              ctx.lines.push(`  store ptr ${v}, ptr %tail_input_slot`);
+              const compacted = lowerRtCompact(ctx, v, "%tail_mark_slot");
+              ctx.lines.push(`  store ptr ${compacted}, ptr %tail_input_slot`);
               ctx.lines.push("  br label %tail_loop");
               return;
             } else {
@@ -796,7 +864,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
               outputPattern: kvmFunc.outputPattern,
               body: branch.body
             };
-            const armTailRef = (isLast && tailValueAfter(insts, i + 1, inst.dest)) ? tailRef : null;
+            const armTailRef = tailValueAfter(insts, i + 1, inst.dest) ? tailRef : null;
             const armBody = lowerKVMFunction(armFunc, armName, armFunc.name, moduleCtx, "internal", { ...options, tailRef: armTailRef });
             moduleCtx.syntheticFunctions.push(armBody);
 
@@ -818,7 +886,8 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
             if (ctx.catchTail) {
               const tailArg = ctx.tempName("arm_tail_arg");
               ctx.lines.push(`  ${tailArg} = extractvalue %k_result ${armCall}, 1`);
-              ctx.lines.push(`  store ptr ${tailArg}, ptr %tail_input_slot`);
+              const compacted = lowerRtCompact(ctx, tailArg, "%tail_mark_slot");
+              ctx.lines.push(`  store ptr ${compacted}, ptr %tail_input_slot`);
               ctx.lines.push("  br label %tail_loop");
             } else {
               ctx.lines.push(`  ret %k_result ${armCall}`);

package/backends/llvm/tests/perf-support.mjs

@@ -33,7 +33,7 @@ function sha256(text) {
 function backendFingerprint() {
   if (cachedBackendFingerprint != null) return cachedBackendFingerprint;
   const hash = crypto.createHash("sha256");
-  for (const relPath of ["src/llvm.mjs", "src/executable.mjs", "runtime/krt.c", "runtime/krt.h"]) {
+  for (const relPath of ["src/llvm.mjs", "src/kvm2llvm.mjs", "src/executable.mjs", "runtime/krt.c", "runtime/krt.h"]) {
     hash.update(relPath);
     hash.update("\0");
     hash.update(fs.readFileSync(path.join(root, relPath)));

package/backends/wasm/TECHNICAL-DEBT.md

@@ -31,12 +31,18 @@ paths do not reclaim temporary values until the whole run ends.
 
 Tail-call lowering now avoids allocating replacement input products for some
 self-tail-recursive loops by keeping top-level product fields in Wasm locals.
-That improves arithmetic workloads such as `factorial:o`, but it is still only
-a first step. Large runs still allocate far more arena memory than the final
-result requires because intermediate relation results, accumulator fragments,
-and temporary products remain in the bump arena.
+Furthermore, self-tail-recursive loops now incorporate threshold-based arena
+compaction: when arena growth within a tail loop exceeds 1 MB, live accumulator
+and argument graphs are compacted down to the loop entry mark using an iterative
+staging-and-copy mechanism in `runtime.wat`, freeing dead scratch data while
+preserving performance for hot short-lived loops.
 
-Future memory-management targets:
+Additionally, linear memory exhaustion and 32-bit unsigned offset overflow are
+now tracked explicitly via exported flags (`oom_flag`, `oom_size`) in `runtime.wat`,
+which the JS runtime intercepts to throw a descriptive `OutOfMemoryError` instead
+of an untyped `unreachable` trap.
+
+Remaining memory-management targets:
 
 - Add allocation profiling that attributes arena growth to generated relations
   and static allocation sites. Large regressions should be visible without
@@ -47,14 +53,6 @@ Future memory-management targets:
 - Introduce safe lifetime boundaries for successful non-tail calls. The runtime
   needs a way to reclaim scratch values after a callee result has been consumed
   without copying large live values on every call.
-- Make arena checkpoints part of code generation decisions, not just union
-  failure handling. Tail loops should be able to reset dead scratch space while
-  preserving the next live input/result.
 - Keep unsigned pointer handling explicit. Wasm arena addresses are `i32`
   offsets, and JavaScript sees exported `i32` values as signed numbers, so all
   JS-side arena offsets must be normalized before `DataView` access.
-
-The preferred direction is performance first: reduce allocation volume in hot
-generated loops before adding a general garbage collector or compaction pass.
-Copying live arena values can control memory, but it risks slowing exactly the
-large recursive arithmetic workloads that motivated tail-call lowering.