xbintsc 0.3.35 → 0.3.46

package/runtime/ext_node/http/parts/prototypes.inc

@@ -2,6 +2,7 @@
 
 static xt_value xt_http_server_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -13,6 +14,7 @@ static xt_value xt_http_server_proto(void) {
 
 static xt_value xt_http_response_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -28,6 +30,7 @@ static xt_value xt_http_response_proto(void) {
 
 static xt_value xt_http_request_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -37,6 +40,7 @@ static xt_value xt_http_request_proto(void) {
 
 static xt_value xt_http_client_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -49,6 +53,7 @@ static xt_value xt_http_client_proto(void) {
 
 static xt_value xt_http_client_response_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/net/parts/prototypes.inc

@@ -2,6 +2,7 @@
 
 static xt_value xt_net_socket_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);
@@ -22,6 +23,7 @@ static xt_value xt_net_socket_proto(void) {
 
 static xt_value xt_net_server_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/process/process.c

@@ -70,16 +70,18 @@ static xt_value xt_process_env(void) {
 
 static xt_value xt_process_argv(void) {
   int32_t count = xt_program_argc;
-  if (count <= 0 || !xt_program_argv) return xt_array_new(0, NULL);
+  /* Fill an `xt_array` element by element rather than a raw `xt_value` buffer:
+     the collector cannot see a plain malloc'd buffer, so strings created here
+     would be swept as soon as a later element allocates (demonstrated by
+     `process.argv` returning recycled strings under GC stress). The array is a
+     stack local, so the conservative scan keeps it and its elements alive. */
+  xt_value result = xt_array_new(0, NULL);
+  if (count <= 0 || !xt_program_argv) return result;
   /* Node semantics: `[execPath, scriptPath, ...args]`. A standalone binary is
      both the executable and the script, so the executable path is repeated;
      user arguments therefore start at index 2, matching `node script.js a b`. */
-  xt_value *items = (xt_value *)malloc(sizeof(xt_value) * (size_t)(count + 1));
-  if (!items) return xt_array_new(0, NULL);
-  items[0] = xt_string_from_cstr(xt_program_argv[0]);
-  for (int32_t i = 0; i < count; i++) items[i + 1] = xt_string_from_cstr(xt_program_argv[i]);
-  xt_value result = xt_array_new(count + 1, items);
-  free(items);
+  xt_array_push(result, xt_string_from_cstr(xt_program_argv[0]));
+  for (int32_t i = 0; i < count; i++) xt_array_push(result, xt_string_from_cstr(xt_program_argv[i]));
   return result;
 }
 

package/runtime/ext_node/stream/stream.c

@@ -363,6 +363,7 @@ xt_value xt_stream_static(xt_value name, int32_t argc, xt_value *argv) {
 
 static xt_value xt_stream_proto(void) {
   static xt_value proto = 0;
+  xt_gc_add_root(&proto);
   if (proto) return proto;
   proto = xt_object_new();
   xt_node_install_emitter(proto);

package/runtime/ext_node/util/util.c

@@ -363,13 +363,13 @@ static xt_value util_promisify_executor(xt_value thisValue, xt_value env, int32_
   xt_value resolve = xt_arg(argc, argv, 0);
   xt_value reject = xt_arg(argc, argv, 1);
   int32_t count = (int32_t)xt_to_number(xt_array_length(args));
-  xt_value *callArgs = (xt_value *)malloc(sizeof(xt_value) * (size_t)(count + 1));
-  if (!callArgs) return xt_undefined();
-  for (int32_t i = 0; i < count; i++) callArgs[i] = xt_array_get(args, xt_number((double)i));
+  /* An `xt_array` keeps the arguments, and the freshly created callback
+     closure, reachable if the call below triggers a collection. */
+  xt_value argArray = xt_array_new(0, NULL);
+  for (int32_t i = 0; i < count; i++) xt_array_push(argArray, xt_array_get(args, xt_number((double)i)));
   xt_value callbackEnv[2] = {resolve, reject};
-  callArgs[count] = xt_closure_new((void *)util_promisify_callback, 2, callbackEnv);
-  if (XT_IS_FUNCTION(fn)) xt_closure_call(fn, count + 1, callArgs);
-  free(callArgs);
+  xt_array_push(argArray, xt_closure_new((void *)util_promisify_callback, 2, callbackEnv));
+  if (XT_IS_FUNCTION(fn)) xt_closure_call(fn, count + 1, xt_as_array(argArray)->items);
   return xt_undefined();
 }
 

package/runtime/rt.h

@@ -362,6 +362,16 @@ void xt_println(xt_value v);
 size_t xt_heap_bytes(void);
 size_t xt_heap_allocations(void);
 
+/* -- garbage collector ---------------------------------------------------- */
+/**
+ * Register `slot` as a GC root: a static prototype cache or any value cell
+ * that lives outside the heap graph. The slot may be registered before it
+ * holds a value; it is marked on every collection and registration is
+ * idempotent. `xt_gc_add_root_range` registers `count` consecutive cells.
+ */
+void xt_gc_add_root(xt_value *slot);
+void xt_gc_add_root_range(xt_value *base, size_t count);
+
 #ifdef __cplusplus
 }
 #endif

package/runtime/rt_internal.h

@@ -52,7 +52,8 @@
 #define XT_OBJECT_KIND_GENERATOR 13
 #define XT_OBJECT_KIND_ITERATOR 14
 
-/* Common header for every heap object. */
+/* Common header for every heap object. `flags` bit 0 is the collector's mark
+ * bit; it is cleared on every surviving object at the end of a sweep. */
 typedef struct xt_header {
   uint8_t kind;
   uint8_t flags;
@@ -61,6 +62,8 @@ typedef struct xt_header {
   struct xt_header *gc_next;
 } xt_header;
 
+#define XT_GC_MARK 0x01u
+
 typedef struct {
   xt_header header;
   uint32_t length;
@@ -122,9 +125,67 @@ typedef struct {
   uint8_t is_generator;
 } xt_function;
 
-/* Allocation (xt_alloc.c). */
+/* Allocation and garbage collection (xt_alloc.c).
+ *
+ * The collector is a non-moving mark-sweep over the linked list of every
+ * allocation. Roots are (a) explicitly registered value slots, (b) root
+ * providers registered by runtime subsystems and extensions, and (c) a
+ * conservative scan of the active C stack (plus a setjmp buffer for the
+ * callee-saved registers). Heap objects are traced precisely for their own
+ * value fields, with a conservative scan of their payload for the raw pointer
+ * fields that older code still stores directly. */
 void *xt_alloc(size_t size, int kind);
 
+/* Record the current stack as the base of the root set. Call once, as early as
+ * possible, before any allocation (generated `main` does this). */
+void xt_gc_init(void);
+/* Record the high bound of the main stack. The generated `main` passes the
+ * address of one of its own locals, which lives above every frame its callees
+ * ever use, so the conservative scan reaches spilled roots. Without this the
+ * bound would be taken from inside the runtime and would cut off the top of
+ * the caller's frame. Safe to call before `xt_gc_init`. */
+void xt_gc_set_stack_base(void *base);
+/* Enable automatic collection once the heap crosses the threshold. Programs
+ * that never arm the collector still get `xt_gc_collect()` on demand. */
+void xt_gc_arm(void);
+/* Run a full collection now. Re-entrant calls are ignored. */
+void xt_gc_collect(void);
+/* Override the automatic trigger threshold (bytes of live heap). */
+void xt_gc_set_threshold(size_t bytes);
+
+/* Explicit roots: the address of a slot that always holds a live value (a
+ * module global, a runtime prototype cache, ...). */
+void xt_gc_add_root(xt_value *slot);
+void xt_gc_add_root_range(xt_value *base, size_t count);
+/* Subsystems whose live set is not reachable through value slots (the event
+ * loop's timers, the promise microtask queue, ...) register a provider that
+ * marks its reachable objects. Providers run during every collection. */
+void xt_gc_register_root_provider(void (*provider)(void));
+
+/* Track the active C stack so the conservative scan has an upper bound. The
+ * initial region is installed by `xt_gc_init`; each generator pushes its own
+ * private stack while it runs. Before switching to a deeper region the caller
+ * records where its own stack was suspended, so every active region is scanned
+ * and suspended callers stay reachable. */
+void xt_gc_push_stack(uintptr_t low, uintptr_t high);
+/* Mark the currently-executing region as suspended at `sp` (its frames above
+ * `sp` stay live while a deeper generator region runs). */
+void xt_gc_suspend(uintptr_t sp);
+void xt_gc_pop_stack(void);
+
+/* Marking primitives used by root providers and per-kind trace hooks. */
+void xt_gc_mark_value(xt_value value);
+void xt_gc_mark_header(xt_header *header);
+/* Conservatively mark every pointer-sized word in `[base, base + bytes)`. */
+void xt_gc_scan_region(const void *base, size_t bytes);
+
+/* Kind-specific hooks for allocations with separately allocated sub-objects.
+ * Implemented by the translation unit that owns the representation. */
+void xt_promise_gc_trace(xt_header *header);
+void xt_promise_gc_release(xt_header *header);
+void xt_generator_gc_trace(xt_header *header);
+void xt_generator_gc_release(xt_header *header);
+
 /* Value / string helpers shared across translation units (xt_values.c). */
 xt_string *xt_string_alloc(size_t length);
 xt_string *xt_as_string(xt_value value);