xbintsc 0.3.87 → 0.5.20

package/runtime/xt_containers/shapes.inc

@@ -0,0 +1,71 @@
+/* ------------------------------------------------------------------------- */
+/* Hidden classes                                                            */
+/* ------------------------------------------------------------------------- */
+
+/* Shapes are interned by their (parent, property key) transition. They are
+ * immortal metadata, but their keys are ordinary strings/symbols, so a root
+ * provider keeps those keys alive. Pointer identity is enough to share a
+ * transition between the same interned literal; dynamically built keys simply
+ * get their own shape, which is still a correct layout identity for the IC. */
+#define XT_SHAPE_BUCKETS 256
+/* Interned shapes are immortal metadata. A program that creates property names
+ * dynamically would otherwise leak one shape per name forever, so stop
+ * interning after a bounded number; those objects simply fall back to the
+ * uncached lookup (a NULL shape). */
+#define XT_SHAPE_LIMIT 16384
+static xt_shape *g_shapes[XT_SHAPE_BUCKETS];
+static xt_shape *g_shape_all = NULL;
+static xt_shape *g_shape_root = NULL;
+static uint32_t g_shape_count = 0;
+
+static size_t xt_shape_bucket(xt_shape *parent, xt_value key) {
+  uintptr_t mixed = ((uintptr_t)parent >> 4) ^ ((uintptr_t)XT_GET_PTR(key) >> 4);
+  return (size_t)mixed & (XT_SHAPE_BUCKETS - 1);
+}
+
+static void xt_shape_gc_roots(void) {
+  for (xt_shape *shape = g_shape_all; shape; shape = shape->all_next) xt_gc_mark_value(shape->key);
+}
+
+static xt_shape *xt_shape_empty(void) {
+  if (g_shape_root) return g_shape_root;
+  xt_shape *shape = (xt_shape *)calloc(1, sizeof(xt_shape));
+  if (!shape) abort();
+  shape->key = XT_UNDEFINED;
+  g_shape_root = shape;
+  g_shape_all = shape;
+  xt_gc_register_root_provider(xt_shape_gc_roots);
+  return shape;
+}
+
+xt_shape *xt_shape_transition(xt_shape *parent, xt_value key) {
+  if (!parent) parent = xt_shape_empty();
+  size_t bucket = xt_shape_bucket(parent, key);
+  for (xt_shape *shape = g_shapes[bucket]; shape; shape = shape->next) {
+    if (shape->parent == parent && shape->key == key) return shape;
+  }
+  if (g_shape_count >= XT_SHAPE_LIMIT) return NULL;
+  xt_shape *shape = (xt_shape *)calloc(1, sizeof(xt_shape));
+  if (!shape) abort();
+  shape->key = key;
+  shape->count = parent->count + 1;
+  shape->parent = parent;
+  shape->next = g_shapes[bucket];
+  g_shapes[bucket] = shape;
+  shape->all_next = g_shape_all;
+  g_shape_all = shape;
+  g_shape_count++;
+  return shape;
+}
+
+void xt_object_shape_changed(xt_object *obj) {
+  xt_shape *shape = xt_shape_empty();
+  for (uint32_t i = 0; i < obj->count; i++) {
+    shape = xt_shape_transition(shape, obj->properties[i].key);
+    if (!shape) {
+      obj->shape = NULL;
+      return;
+    }
+  }
+  obj->shape = shape;
+}

package/runtime/xt_containers.c

@@ -16,6 +16,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "xt_containers/shapes.inc"
 #include "xt_containers/objects.inc"
 #include "xt_containers/arrays.inc"
 #include "xt_containers/access.inc"

package/runtime/xt_coroutine.c

@@ -0,0 +1,229 @@
+/*
+ * xbintsc runtime — stackful coroutines.
+ *
+ * A coroutine owns a private C stack and switches to it with `ucontext`
+ * (POSIX) or fibers (Windows). Because the body keeps a real call stack,
+ * `try`/`finally`, nested loops and ordinary locals work across suspension
+ * points without a state-machine transform. Generators (`xt_generator.c`) and
+ * `async` functions (`xt_async.c`) are both built on this module.
+ *
+ * The coroutine's exception stack is swapped alongside its C stack, so a
+ * `throw` inside the body still targets the body's own `try` frames. Its stack
+ * is registered as an active GC region while it runs and scanned while it is
+ * suspended (through the owner's trace hook).
+ *
+ * The owner object decides *when* to enter/leave; this module only performs
+ * the switch, the exception-stack hand-off and the GC region bookkeeping.
+ */
+
+#define _XOPEN_SOURCE 700
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__APPLE__)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <ucontext.h>
+#endif
+
+/* Generous enough for deep JavaScript recursion on top of a coroutine. The
+ * pages are committed lazily by the OS, so a suspended coroutine is cheap. */
+#define XT_COROUTINE_STACK_SIZE ((size_t)1 << 20)
+
+struct xt_coroutine {
+  void (*entry)(void *);
+  void *arg;
+  /* Private stack bounds, registered as an active stack region while the
+   * coroutine runs and scanned conservatively while it is suspended. */
+  char *stack;
+  size_t stack_size;
+  int stack_pushed;
+  int booted;
+  int started;
+  void *saved_try_top;
+  /* Coroutine that was current when this one was entered. Used to answer
+   * "which JavaScript execution context is running?" so a nested async
+   * function inside an async generator (or vice versa) does not mistake the
+   * outer coroutine for its own. */
+  xt_coroutine *previous;
+#ifdef _WIN32
+  void *fiber;
+  void *caller_fiber;
+  /* `SwitchToFiber` keeps the resumer's callee-saved registers in an opaque
+   * fiber context (POSIX stores them in `caller`), so snapshot them for the
+   * collector before switching away. */
+  jmp_buf caller_regs;
+  int has_caller_regs;
+#else
+  ucontext_t ctx;
+  ucontext_t caller;
+#endif
+};
+
+/* Filled in just before a coroutine is first entered (POSIX has no portable
+ * way to pass a pointer to `makecontext`). */
+static xt_coroutine *g_boot_coroutine = NULL;
+/* The coroutine whose body is executing right now (NULL on the main stack). */
+static xt_coroutine *g_current_coroutine = NULL;
+
+xt_coroutine *xt_coroutine_current(void) { return g_current_coroutine; }
+
+int xt_coroutine_is_current(xt_coroutine *co) {
+  return co != NULL && g_current_coroutine == co;
+}
+#ifdef _WIN32
+static void *g_main_fiber = NULL;
+#else
+/* Async functions are frequently short-lived, so keep a few private stacks
+ * around instead of asking the OS for a fresh 1 MiB mapping every call. The
+ * cached stacks hold no live values and are not part of the GC scan. */
+#define XT_COROUTINE_STACK_CACHE 8
+static char *g_stack_cache[XT_COROUTINE_STACK_CACHE];
+static int g_stack_cache_count = 0;
+#endif
+
+xt_coroutine *xt_coroutine_create(void (*entry)(void *), void *arg) {
+  xt_coroutine *co = (xt_coroutine *)calloc(1, sizeof(xt_coroutine));
+  if (!co) abort();
+  co->entry = entry;
+  co->arg = arg;
+  return co;
+}
+
+#ifndef _WIN32
+static void xt_coroutine_entry(void) {
+  xt_coroutine *co = g_boot_coroutine;
+  g_boot_coroutine = NULL;
+  co->entry(co->arg);
+}
+#else
+static void CALLBACK xt_coroutine_entry(void *param) {
+  xt_coroutine *co = (xt_coroutine *)param;
+  /* The fiber stack is not observable from the outside; capture its bounds
+   * here (before the body allocates anything) so a collection during the body
+   * has a valid scan region. */
+  MEMORY_BASIC_INFORMATION info;
+  uintptr_t here = (uintptr_t)&info;
+  if (VirtualQuery((LPCVOID)here, &info, sizeof(info))) {
+    /* Use the *committed* region containing the current frame: a Windows
+     * stack reserves more than it commits, and `AllocationBase + RegionSize`
+     * can fall in uncommitted memory. `BaseAddress + RegionSize` is the
+     * stack top. */
+    co->stack = (char *)info.BaseAddress;
+    co->stack_size = info.RegionSize;
+  }
+  if (co->stack && co->stack_size && !co->stack_pushed) {
+    xt_gc_push_stack((uintptr_t)co->stack, (uintptr_t)co->stack + co->stack_size);
+    co->stack_pushed = 1;
+  }
+  co->entry(co->arg);
+}
+#endif
+
+static void xt_coroutine_boot(xt_coroutine *co) {
+#ifdef _WIN32
+  if (!g_main_fiber) g_main_fiber = ConvertThreadToFiber(NULL);
+  co->fiber = CreateFiber(XT_COROUTINE_STACK_SIZE, xt_coroutine_entry, co);
+  if (!co->fiber) abort();
+#else
+  size_t size = XT_COROUTINE_STACK_SIZE;
+  char *stack = NULL;
+  if (g_stack_cache_count > 0) stack = g_stack_cache[--g_stack_cache_count];
+  if (!stack) stack = (char *)malloc(size);
+  if (!stack) abort();
+  co->stack = stack;
+  co->stack_size = size;
+  if (getcontext(&co->ctx) != 0) abort();
+  co->ctx.uc_stack.ss_sp = co->stack;
+  co->ctx.uc_stack.ss_size = size;
+  co->ctx.uc_link = NULL;
+  g_boot_coroutine = co;
+  makecontext(&co->ctx, xt_coroutine_entry, 0);
+#endif
+  co->booted = 1;
+}
+
+void xt_coroutine_enter(xt_coroutine *co) {
+  if (!co->booted) xt_coroutine_boot(co);
+  /* Record where the current (calling) stack suspends before switching away.
+   * On Windows the first push happens inside the fiber once its stack bounds
+   * are known, so the caller's region must be marked suspended here, on the
+   * caller's own stack. */
+  xt_gc_suspend((uintptr_t)&co);
+  if (co->stack && co->stack_size && !co->stack_pushed) {
+    xt_gc_push_stack((uintptr_t)co->stack, (uintptr_t)co->stack + co->stack_size);
+    co->stack_pushed = 1;
+  }
+  void *caller_try = xt_try_mark();
+  xt_try_restore(co->saved_try_top);
+  co->previous = g_current_coroutine;
+  g_current_coroutine = co;
+#ifdef _WIN32
+  _setjmp(co->caller_regs);
+  co->has_caller_regs = 1;
+  co->caller_fiber = GetCurrentFiber();
+  SwitchToFiber(co->fiber);
+#else
+  swapcontext(&co->caller, &co->ctx);
+#endif
+  g_current_coroutine = co->previous;
+  co->saved_try_top = xt_try_mark();
+  xt_try_restore(caller_try);
+  if (co->stack_pushed) {
+    xt_gc_pop_stack();
+    co->stack_pushed = 0;
+  }
+}
+
+void xt_coroutine_leave(xt_coroutine *co) {
+  co->saved_try_top = xt_try_mark();
+  g_current_coroutine = co->previous;
+#ifdef _WIN32
+  SwitchToFiber(co->caller_fiber);
+#else
+  swapcontext(&co->ctx, &co->caller);
+#endif
+}
+
+void xt_coroutine_gc_trace(xt_coroutine *co) {
+  if (!co) return;
+  if (co->stack && co->stack_size) xt_gc_scan_region(co->stack, co->stack_size);
+#ifndef _WIN32
+  /* Registers saved by `swapcontext` at the last suspension are not on the
+   * stack. */
+  xt_gc_scan_region(&co->ctx, sizeof(co->ctx));
+#else
+  if (co->has_caller_regs) xt_gc_scan_region(&co->caller_regs, sizeof(co->caller_regs));
+#endif
+}
+
+void xt_coroutine_release(xt_coroutine *co) {
+  if (!co) return;
+#ifdef _WIN32
+  if (co->fiber) {
+    DeleteFiber(co->fiber);
+    co->fiber = NULL;
+  }
+  co->caller_fiber = NULL;
+  /* `DeleteFiber` releases the stack: never scan it again. */
+  co->stack = NULL;
+  co->stack_size = 0;
+#else
+  if (co->stack && co->stack_size == XT_COROUTINE_STACK_SIZE &&
+      g_stack_cache_count < XT_COROUTINE_STACK_CACHE) {
+    g_stack_cache[g_stack_cache_count++] = co->stack;
+  } else {
+    free(co->stack);
+  }
+  co->stack = NULL;
+  co->stack_size = 0;
+#endif
+  free(co);
+}