inline-method

objects.c
View Options

			#include "internal.h"
			#include "gc.h"
			#include "gc/objects.h"
			#include "gc/roots.h"
			#include "gc/modules.h"
			#include "sugar.h"
			#include "silver/engine.h"
			#include "shapes.h"
			#include "runtime.h"
			#include "modules/collections.h"
			#include "modules/generator.h"
			#include "modules/regex.h"

			#include <stdlib.h>
			#include <string.h>
			#include <setjmp.h>
			#include <sys/time.h>
			#include <utarray.h>

			#define MCO_API extern
			#include <minicoro.h>

			#if defined(__has_feature)
			#if __has_feature(address_sanitizer)
			#include <sanitizer/asan_interface.h>
			#define ANT_HAS_ASAN 1
			#endif
			#endif

			#ifndef ANT_HAS_ASAN
			#define ANT_HAS_ASAN 0
			#endif

			static inline bool gc_stack_word_readable(uintptr_t addr) {
			#if ANT_HAS_ASAN
			return __asan_region_is_poisoned((void *)addr, sizeof(uint64_t)) == NULL;
			#else
			return true;
			#endif
			}

			static inline bool gc_get_stack_bounds(
			uintptr_t base, uintptr_t sp, uintptr_t lo, uintptr_t hi
			) {
			if (base == 0 \|\| sp == 0) return false;
			uintptr_t minp = (sp < base) ? sp : base;
			uintptr_t maxp = (sp < base) ? base : sp;

			uintptr_t aligned_lo = (minp + sizeof(uint64_t) - 1u) & ~(sizeof(uint64_t) - 1u);
			uintptr_t aligned_hi = maxp & ~(sizeof(uint64_t) - 1u);

			if (aligned_lo >= aligned_hi) return false;
			*lo = aligned_lo;
			*hi = aligned_hi;
			return true;
			}

			static gc_func_mark_profile_t g_gc_func_mark_profile = {0};
			static void gc_mark_coroutine(ant_t js, coroutine_t c);

			static uint32_t g_gc_func_mark_profile_depth = 0;
			static uint64_t g_gc_func_mark_profile_start_ns = 0;

			static gc_str_mark_fn g_str_mark = NULL;
			static ant_object_t *g_pending_promises = NULL;

			static uint64_t gc_epoch = 0;
			static uint8_t gc_obj_epoch = 0;
			static bool g_minor_gc = false;

			static uint64_t gc_now_ns(void) {
			struct timeval tv;
			gettimeofday(&tv, NULL);
			return (uint64_t)tv.tv_sec * 1000000000ULL + (uint64_t)tv.tv_usec * 1000ULL;
			}

			void gc_func_mark_profile_enable(bool enabled) {
			g_gc_func_mark_profile.enabled = enabled;
			}

			void gc_func_mark_profile_reset(void) {
			bool enabled = g_gc_func_mark_profile.enabled;
			g_gc_func_mark_profile = (gc_func_mark_profile_t){ .enabled = enabled };
			g_gc_func_mark_profile_depth = 0;
			g_gc_func_mark_profile_start_ns = 0;
			}

			gc_func_mark_profile_t gc_func_mark_profile_get(void) {
			return g_gc_func_mark_profile;
			}

			bool gc_obj_is_marked(const ant_object_t *obj) {
			return obj && obj->mark_epoch == gc_obj_epoch;
			}

			void gc_root_pending_promise(ant_object_t *obj) {
			if (!obj \|\| obj->gc_pending_rooted) return;
			obj->gc_pending_rooted = true;
			obj->gc_pending_next = g_pending_promises;
			g_pending_promises = obj;
			}

			void gc_unroot_pending_promise(ant_object_t *obj) {
			if (!obj \|\| !obj->gc_pending_rooted) return;
			obj->gc_pending_rooted = false;
			ant_object_t **pp = &g_pending_promises;
			while (*pp) {
			if (pp == obj) { pp = obj->gc_pending_next; break; }
			pp = &(*pp)->gc_pending_next;
			}
			obj->gc_pending_next = NULL;
			}

			void gc_remember_add(ant_t js, ant_object_t obj) {
			if (!obj \|\| obj->in_remember_set) return;
			if (js->remember_set_len >= js->remember_set_cap) {
			size_t new_cap = js->remember_set_cap ? js->remember_set_cap * 2 : 64;
			ant_object_t *ns = realloc(js->remember_set, new_cap sizeof(*ns));
			if (!ns) return;
			js->remember_set = ns;
			js->remember_set_cap = new_cap;
			}
			obj->in_remember_set = 1;
			js->remember_set[js->remember_set_len++] = obj;
			}

			#define GC_MARK_STACK_INIT 4096

			static ant_object_t **gc_mark_stack = NULL;
			static void gc_mark_promise_handlers(ant_t js, ant_promise_state_t pd);

			static size_t gc_mark_sp = 0;
			static size_t gc_mark_cap = 0;

			static void gc_mark_stack_push(ant_object_t *obj) {
			if (gc_mark_sp >= gc_mark_cap) {
			size_t new_cap = gc_mark_cap ? gc_mark_cap * 2 : GC_MARK_STACK_INIT;
			ant_object_t *ns = realloc(gc_mark_stack, new_cap sizeof(*ns));
			if (!ns) return;
			gc_mark_stack = ns;
			gc_mark_cap = new_cap;
			}
			gc_mark_stack[gc_mark_sp++] = obj;
			}

			static inline void gc_grey_obj(ant_t js, ant_object_t obj) {
			if (!obj \|\| !fixed_arena_contains(&js->obj_arena, obj)) return;
			if (obj->mark_epoch == gc_obj_epoch \|\| obj->mark_epoch == ANT_GC_DEAD) return;
			if (g_minor_gc && obj->generation == 1) return;
			obj->mark_epoch = gc_obj_epoch;
			gc_mark_stack_push(obj);
			}

			static void gc_mark_func(ant_t js, sv_func_t func) {
			if (!func) return;
			if (func->gc_epoch == gc_epoch) return;

			bool prof = __builtin_expect(g_gc_func_mark_profile.enabled, 0);
			if (prof) {
			if (g_gc_func_mark_profile_depth++ == 0) g_gc_func_mark_profile_start_ns = gc_now_ns();
			g_gc_func_mark_profile.func_visits++;
			g_gc_func_mark_profile.child_edges += (uint64_t)func->child_func_count;
			g_gc_func_mark_profile.const_slots += (uint64_t)func->gc_const_slot_count;
			}

			func->gc_epoch = gc_epoch;

			for (int i = 0; i < func->child_func_count; i++)
			gc_mark_func(js, func->child_funcs[i]);

			for (int i = 0; i < func->obj_site_count; i++) {
			if (func->obj_sites) ant_gc_shapes_mark(func->obj_sites[i].shared_shape);
			}

			for (int i = 0; i < func->gc_const_slot_count; i++) {
			uint32_t idx = func->gc_const_slots[i];
			ant_value_t v = func->constants[idx];
			gc_mark_value(js, v);
			}

			if (prof && --g_gc_func_mark_profile_depth == 0)
			g_gc_func_mark_profile.time_ns += gc_now_ns() - g_gc_func_mark_profile_start_ns;
			}

			static void gc_mark_closure(ant_t js, sv_closure_t c) {
			if (!c) return;
			if (c->gc_epoch == gc_epoch) return;

			c->gc_epoch = gc_epoch;
			gc_mark_func(js, c->func);
			gc_mark_value(js, c->func_obj);
			gc_mark_value(js, c->bound_this);
			gc_mark_value(js, c->bound_args);
			gc_mark_value(js, c->super_val);

			if (c->upvalues && c->func) {
			for (int i = 0; i < c->func->upvalue_count; i++) {
			sv_upvalue_t *uv = c->upvalues[i];
			if (!uv) continue;
			uv->gc_epoch = gc_epoch;
			if (uv->location == &uv->closed) gc_mark_value(js, uv->closed);
			}}

			if (c->bound_argv) {
			for (int i = 0; i < c->bound_argc; i++) gc_mark_value(js, c->bound_argv[i]);
			}
			}

			void gc_mark_value(ant_t *js, ant_value_t v) {
			if (v <= NANBOX_PREFIX) return;
			uint8_t t = (v >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK;

			if (t == T_FUNC) {
			gc_mark_closure(js, (sv_closure_t *)(uintptr_t)(v & NANBOX_DATA_MASK));
			return;
			}

			if (t == T_STR && g_str_mark) {
			g_str_mark(js, v);
			return;
			}

			if (!((1u << t) & GC_OBJ_TYPE_MASK)) return;
			ant_object_t obj = (ant_object_t )(uintptr_t)(v & NANBOX_DATA_MASK);

			if (!obj) return;
			gc_grey_obj(js, obj);
			}

			static void gc_scan_obj(ant_t js, ant_object_t obj) {
			ant_gc_shapes_mark(obj->shape);
			gc_mark_value(js, obj->proto);

			if (obj->type_tag != T_ARR) gc_mark_value(js, obj->u.data.value);
			if (obj->type_tag == T_GENERATOR) {
			coroutine_t *coro = generator_get_coro_for_gc(js_obj_from_ptr(obj));
			if (coro) gc_mark_coroutine(js, coro);
			generator_mark_for_gc(js, js_obj_from_ptr(obj));
			}

			if (obj->type_tag == T_MAP) {
			map_entry_t head = (map_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			map_entry_t e, tmp;
			HASH_ITER(hh, *head, e, tmp) {
			gc_mark_value(js, e->key_val);
			gc_mark_value(js, e->value);
			}}
			} else if (obj->type_tag == T_WEAKMAP) {
			weakmap_entry_t head = (weakmap_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			weakmap_entry_t e, tmp;
			HASH_ITER(hh, *head, e, tmp) {
			gc_mark_value(js, e->key_obj);
			gc_mark_value(js, e->value);
			}}
			} else if (obj->type_tag == T_SET) {
			set_entry_t head = (set_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			set_entry_t e, tmp;
			HASH_ITER(hh, *head, e, tmp) { gc_mark_value(js, e->value); }
			}
			}

			if (obj->shape) {
			uint32_t count = ant_shape_count(obj->shape);
			for (uint32_t i = 0; i < count && i < obj->prop_count; i++)
			gc_mark_value(js, ant_object_prop_get_unchecked(obj, i));
			for (uint32_t i = 0; i < count; i++) {
			const ant_shape_prop_t *prop = ant_shape_prop_at(obj->shape, i);
			if (prop && prop->has_getter) gc_mark_value(js, prop->getter);
			if (prop && prop->has_setter) gc_mark_value(js, prop->setter);
			}}

			if (obj->extra_slots) {
			ant_extra_slot_t entries = (ant_extra_slot_t )obj->extra_slots;
			for (uint8_t i = 0; i < obj->extra_count; i++) gc_mark_value(js, entries[i].value);
			}

			if (obj->type_tag == T_ARR && obj->u.array.data) {
			uint32_t n = obj->u.array.len < obj->u.array.cap ? obj->u.array.len : obj->u.array.cap;
			for (uint32_t i = 0; i < n; i++) gc_mark_value(js, obj->u.array.data[i]);
			}

			ant_promise_state_t *pd = obj->promise_state;
			if (pd) {
			gc_mark_value(js, pd->value);
			gc_mark_value(js, pd->trigger_parent);
			gc_mark_promise_handlers(js, pd);
			}

			if (obj->proxy_state) {
			gc_mark_value(js, obj->proxy_state->target);
			gc_mark_value(js, obj->proxy_state->handler);
			}

			gc_mark_abort_signal_object(
			js, js_obj_from_ptr(obj), gc_mark_value
			);
			}

			static void gc_drain_mark_stack(ant_t *js) {
			while (gc_mark_sp > 0) {
			ant_object_t *obj = gc_mark_stack[--gc_mark_sp];
			gc_scan_obj(js, obj);
			}}

			static void gc_scan_vm_stack(ant_t js, sv_vm_t vm) {
			if (!vm) return;

			for (int i = 0; i < vm->sp; i++)
			gc_mark_value(js, vm->stack[i]);

			for (int f = 0; f <= vm->fp; f++) {
			sv_frame_t *frame = &vm->frames[f];
			gc_mark_func(js, frame->func);
			gc_mark_value(js, frame->callee);
			gc_mark_value(js, frame->this);
			gc_mark_value(js, frame->new_target);
			gc_mark_value(js, frame->super_val);
			gc_mark_value(js, frame->with_obj);
			gc_mark_value(js, frame->completion.value);
			gc_mark_value(js, frame->arguments_obj);
			}

			for (sv_upvalue_t *uv = vm->open_upvalues; uv; uv = uv->next) {
			uv->gc_epoch = gc_epoch;
			if (uv->location == &uv->closed) gc_mark_value(js, uv->closed);
			}

			for (int f = 0; f <= vm->fp; f++) {
			sv_frame_t *frame = &vm->frames[f];
			if (!frame->upvalues) continue;
			for (int j = 0; j < frame->upvalue_count; j++) {
			sv_upvalue_t *uv = frame->upvalues[j];
			if (!uv) continue;
			uv->gc_epoch = gc_epoch;
			if (uv->location == &uv->closed) gc_mark_value(js, uv->closed);
			}}
			}

			static void gc_scan_range(ant_t *js, uintptr_t lo, uintptr_t hi) {
			for (uintptr_t addr = lo; addr < hi; addr += sizeof(uint64_t)) {
			if (!gc_stack_word_readable(addr)) continue;
			uint64_t w;
			memcpy(&w, (void *)addr, sizeof(w));

			ant_object_t raw_obj = (ant_object_t )(uintptr_t)w;
			if (fixed_arena_contains(&js->obj_arena, raw_obj))
			gc_grey_obj(js, raw_obj);

			sv_closure_t raw_closure = (sv_closure_t )(uintptr_t)w;
			if (fixed_arena_contains(&js->closure_arena, raw_closure))
			gc_mark_closure(js, raw_closure);

			if (w <= NANBOX_PREFIX) continue;
			uint8_t type = (w >> NANBOX_TYPE_SHIFT) & NANBOX_TYPE_MASK;

			if ((1u << type) & GC_OBJ_TYPE_MASK) {
			ant_object_t obj = (ant_object_t )(uintptr_t)(w & NANBOX_DATA_MASK);
			if (obj) gc_grey_obj(js, obj);
			}

			if (type == T_FUNC) {
			sv_closure_t c = (sv_closure_t )(uintptr_t)(w & NANBOX_DATA_MASK);
			if (c && fixed_arena_contains(&js->closure_arena, c)) gc_mark_closure(js, c);
			}

			if (type == T_STR && g_str_mark) g_str_mark(js, w);
			}
			}

			__attribute__((noinline))
			static void gc_scan_current_stack(ant_t *js) {
			jmp_buf jb;
			if (setjmp(jb) != 0) return;
			volatile uint8_t sp_marker = 0;

			mco_coro *running = mco_running();
			uintptr_t base;

			if (running && running->stack_base && running->stack_size > 0) {
			base = (uintptr_t)running->stack_base + running->stack_size;
			} else base = (uintptr_t)js->cstk.base;

			uintptr_t lo, hi;
			if (!gc_get_stack_bounds(base, (uintptr_t)&sp_marker, &lo, &hi)) return;
			gc_scan_range(js, lo, hi);
			}

			static void gc_scan_mco_stack(ant_t js, mco_coro mco, mco_coro *skip) {
			if (!mco \|\| mco == skip) return;
			if (!mco->stack_base \|\| mco->stack_size == 0) return;
			uintptr_t lo = (uintptr_t)mco->stack_base;
			uintptr_t hi = lo + mco->stack_size;
			gc_scan_range(js, lo, hi);
			}

			static void gc_scan_other_stacks(ant_t *js) {
			mco_coro *running = mco_running();

			if (running) {
			for (mco_coro *a = running->prev_co; a; a = a->prev_co)
			gc_scan_mco_stack(js, a, running);
			}

			for (coroutine_t *c = pending_coroutines.head; c; c = c->next)
			gc_scan_mco_stack(js, c->mco, running);

			if (js->cstk.main_base && js->cstk.main_lo) {
			uintptr_t lo, hi;
			if (gc_get_stack_bounds(
			(uintptr_t)js->cstk.main_base,
			(uintptr_t)js->cstk.main_lo, &lo, &hi))
			gc_scan_range(js, lo, hi);
			}
			}

			static void gc_mark_coroutine(ant_t js, coroutine_t c) {
			if (!c) return;
			gc_scan_vm_stack(js, c->sv_vm ? c->sv_vm : c->owner_vm);
			gc_mark_value(js, c->this_val);
			gc_mark_value(js, c->async_func);
			gc_mark_value(js, c->async_promise);
			gc_mark_value(js, c->awaited_promise);
			gc_mark_value(js, c->result);
			gc_mark_value(js, c->yield_value);
			gc_mark_value(js, c->super_val);
			gc_mark_value(js, c->new_target);
			if (c->args) for (int i = 0; i < c->nargs; i++) gc_mark_value(js, c->args[i]);
			}

			static inline void gc_mark_promise_handler(ant_t js, const promise_handler_t h) {
			if (!h) return;

			gc_mark_value(js, h->onFulfilled);
			gc_mark_value(js, h->onRejected);
			gc_mark_value(js, h->nextPromise);

			if (h->await_coro) gc_mark_coroutine(js, h->await_coro);
			}

			static inline void gc_mark_promise_handlers(ant_t js, ant_promise_state_t pd) {
			if (!pd) return;

			if (pd->handler_count == 1) {
			gc_mark_promise_handler(js, &pd->inline_handler);
			return;
			}

			if (pd->handler_count <= 1 \|\| !pd->handlers) return;
			promise_handler_t *h = NULL;

			while ((h = (promise_handler_t *)utarray_next(pd->handlers, h)))
			gc_mark_promise_handler(js, h);
			}

			static void gc_mark_roots(ant_t *js) {
			gc_scan_vm_stack(js, js->vm);

			for (coroutine_t *c = pending_coroutines.head; c; c = c->next) gc_mark_coroutine(js, c);
			for (coroutine_t *c = js->active_async_coro; c; c = c->active_parent) gc_mark_coroutine(js, c);

			gc_mark_value(js, js->global);
			gc_mark_value(js, js->sym.object_proto);
			gc_mark_value(js, js->sym.array_proto);
			gc_mark_value(js, js->this_val);
			gc_mark_value(js, js->new_target);
			gc_mark_value(js, js->current_func);
			gc_mark_value(js, js->thrown_value);
			gc_mark_value(js, js->thrown_stack);
			gc_mark_value(js, js->length_str);

			if (rt && rt->js == js)
			gc_mark_value(js, rt->ant_obj);

			for (ant_module_t *ctx = js->module; ctx; ctx = ctx->prev) {
			gc_mark_value(js, ctx->module_ns);
			gc_mark_value(js, ctx->module_ctx);
			gc_mark_value(js, ctx->prev_import_meta_prop);
			}

			for (size_t i = 0; i < js->pending_rejections.len; i++)
			gc_mark_value(js, js->pending_rejections.items[i]);

			for (uint8_t i = 0; i < js->cfunc_promote_cache.len; i++)
			gc_mark_value(js, js->cfunc_promote_cache.promoted[i]);

			gc_visit_roots(js, gc_mark_value);
			gc_mark_timers(js, gc_mark_value);
			gc_mark_atomics(js, gc_mark_value);
			gc_mark_fetch(js, gc_mark_value);
			gc_mark_fs(js, gc_mark_value);
			gc_mark_child_process(js, gc_mark_value);
			gc_mark_readline(js, gc_mark_value);
			gc_mark_process(js, gc_mark_value);
			gc_mark_navigator(js, gc_mark_value);
			gc_mark_net(js, gc_mark_value);
			gc_mark_server(js, gc_mark_value);
			gc_mark_events(js, gc_mark_value);
			gc_mark_lmdb(js, gc_mark_value);
			gc_mark_symbols(js, gc_mark_value);
			gc_mark_esm(js, gc_mark_value);
			gc_mark_worker_threads(js, gc_mark_value);
			gc_mark_abort(js, gc_mark_value);
			gc_mark_domexception(js, gc_mark_value);
			gc_mark_queuing_strategies(js, gc_mark_value);
			gc_mark_readable_streams(js, gc_mark_value);
			gc_mark_writable_streams(js, gc_mark_value);
			gc_mark_transform_streams(js, gc_mark_value);
			gc_mark_codec_streams(js, gc_mark_value);
			gc_mark_compression_streams(js, gc_mark_value);
			gc_mark_zlib(js, gc_mark_value);
			gc_mark_wasm(js, gc_mark_value);
			gc_mark_napi(js, gc_mark_value);

			for (
			ant_object_t *obj = g_pending_promises;
			obj; obj = obj->gc_pending_next
			) gc_grey_obj(js, obj);

			gc_scan_current_stack(js);
			gc_scan_other_stacks(js);

			if (!g_minor_gc) {
			for (ant_object_t *obj = js->permanent_objects; obj; obj = obj->next)
			gc_scan_obj(js, obj);
			}

			gc_drain_mark_stack(js);
			}

			void gc_object_free(ant_t js, ant_object_t obj) {
			if (!obj) return;
			if (obj->finalizer) obj->finalizer(js, obj);
			obj->mark_epoch = ANT_GC_DEAD;

			if (obj->shape) {
			ant_shape_release(obj->shape);
			obj->shape = NULL;
			}

			if (obj->extra_slots) {
			free(obj->extra_slots);
			obj->extra_slots = NULL;
			}

			if (obj->gc_pending_rooted)
			gc_unroot_pending_promise(obj);

			if (obj->promise_state) {
			if (obj->promise_state->handlers)
			utarray_free(obj->promise_state->handlers);
			free(obj->promise_state);
			obj->promise_state = NULL;
			}

			if (obj->proxy_state) {
			free(obj->proxy_state);
			obj->proxy_state = NULL;
			}

			if (obj->type_tag == T_ARR && obj->u.array.data) {
			free(obj->u.array.data);
			obj->u.array.data = NULL;
			}

			switch (obj->type_tag) {
			case T_MAP: {
			map_entry_t head = (map_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			map_entry_t e, tmp;
			HASH_ITER(hh, head, e, tmp) { HASH_DEL(head, e); free(e->key); free(e); }
			free(head);
			}
			break;
			}
			case T_SET: {
			set_entry_t head = (set_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			set_entry_t e, tmp;
			HASH_ITER(hh, head, e, tmp) { HASH_DEL(head, e); free(e->key); free(e); }
			free(head);
			}
			break;
			}
			case T_WEAKMAP: {
			weakmap_entry_t head = (weakmap_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			weakmap_entry_t e, tmp;
			HASH_ITER(hh, head, e, tmp) { HASH_DEL(head, e); free(e); }
			free(head);
			}
			break;
			}
			case T_WEAKSET: {
			weakset_entry_t head = (weakset_entry_t )(uintptr_t)js_getnum(obj->u.data.value);
			if (head) {
			weakset_entry_t e, tmp;
			HASH_ITER(hh, head, e, tmp) { HASH_DEL(head, e); free(e); }
			free(head);
			}
			break;
			}
			default: break;
			}

			free(obj->overflow_prop);
			obj->overflow_prop = NULL;
			free((void *)obj->exotic_ops);
			obj->exotic_ops = NULL;
			fixed_arena_free_elem(&js->obj_arena, obj);
			}

			static void gc_sweep_young(ant_t *js) {
			ant_object_t **pp = &js->objects;
			while (*pp) {
			ant_object_t obj = pp;
			if (obj->mark_epoch == gc_obj_epoch) pp = &obj->next; else {
			*pp = obj->next;
			gc_object_free(js, obj);
			}}
			}

			static void gc_promote_survivors(ant_t *js) {
			ant_object_t *obj = js->objects;
			while (obj) {
			ant_object_t *next = obj->next;
			obj->generation = 1;
			obj->next = js->objects_old;
			js->objects_old = obj;
			obj = next;
			}
			js->objects = NULL;
			}

			static void gc_sweep(ant_t *js) {
			ant_object_t **pp = &js->objects;
			while (*pp) {
			ant_object_t obj = pp;
			if (obj->mark_epoch == gc_obj_epoch) pp = &obj->next; else {
			*pp = obj->next;
			gc_object_free(js, obj);
			}}

			pp = &js->objects_old;
			while (*pp) {
			ant_object_t obj = pp;
			if (obj->mark_epoch == gc_obj_epoch) pp = &obj->next; else {
			*pp = obj->next;
			gc_object_free(js, obj);
			}}
			}

			void gc_pin_existing_objects(ant_t *js) {
			if (!js) return;

			ant_object_t *tail = NULL;
			for (ant_object_t *obj = js->objects; obj; obj = obj->next) {
			obj->gc_permanent = 1;
			obj->generation = 1;
			tail = obj;
			}

			if (tail) {
			tail->next = js->permanent_objects;
			js->permanent_objects = js->objects;
			js->objects = NULL;
			}

			tail = NULL;
			for (ant_object_t *obj = js->objects_old; obj; obj = obj->next) {
			obj->gc_permanent = 1;
			tail = obj;
			}

			if (tail) {
			tail->next = js->permanent_objects;
			js->permanent_objects = js->objects_old;
			js->objects_old = NULL;
			}
			}

			void gc_objects_run(ant_t *js, gc_str_mark_fn str_mark) {
			if (!js) return;

			g_str_mark = str_mark;
			if (g_gc_func_mark_profile.enabled) g_gc_func_mark_profile.collections++;

			gc_epoch++;
			if (gc_epoch == 0) gc_epoch = 1;

			gc_obj_epoch = (uint8_t)(gc_obj_epoch + 1u);
			if (gc_obj_epoch == 0 \|\| gc_obj_epoch == ANT_GC_DEAD) gc_obj_epoch = 1;

			ant_gc_shapes_begin();
			for (size_t i = 0; i < js->remember_set_len; i++)
			js->remember_set[i]->in_remember_set = 0;
			js->remember_set_len = 0;

			if (js->remember_set_cap > 512) {
			ant_object_t *ns = realloc(js->remember_set, 256 sizeof(*ns));
			if (ns) { js->remember_set = ns; js->remember_set_cap = 256; }
			}

			gc_mark_roots(js);
			gc_sweep_regex_cache();
			gc_sweep(js);

			if (ant_gc_shapes_sweep()) ant_ic_epoch_bump();
			gc_promote_survivors(js);

			ant_fixed_arena_t *ca = &js->closure_arena;
			ca->free_list = NULL;
			ca->live_count = 0;

			for (size_t off = 0; off < ca->watermark; off += ca->elem_size) {
			sv_closure_t c = (sv_closure_t )(ca->base + off);

			if (c->gc_epoch == gc_epoch) ca->live_count++;
			else {
			if (!(c->call_flags & SV_CALL_BORROWED_UPVALS)) {
			free(c->upvalues);
			c->upvalues = NULL;
			}

			free(c->bound_argv);
			c->bound_argv = NULL;

			(void *)c = ca->free_list;
			ca->free_list = c;
			}}

			ant_fixed_arena_t *ua = &js->upvalue_arena;
			ua->free_list = NULL;
			ua->live_count = 0;
			for (size_t off = 0; off < ua->watermark; off += ua->elem_size) {
			uint8_t *slot = ua->base + off;
			uint64_t epoch;
			memcpy(&epoch, slot + ua->epoch_offset, sizeof(epoch));
			if (epoch == gc_epoch) ua->live_count++;
			else {
			(void *)slot = ua->free_list;
			ua->free_list = slot;
			}
			}

			ant_fixed_arena_t *oa = &js->obj_arena;
			size_t new_wm = 0;

			for (size_t off = oa->watermark; off >= oa->elem_size; off -= oa->elem_size) {
			ant_object_t slot = (ant_object_t )(oa->base + off - oa->elem_size);
			if (slot->mark_epoch != ANT_GC_DEAD) { new_wm = off; break; }
			}

			if (new_wm < oa->watermark) {
			oa->free_list = NULL;

			for (size_t off = 0; off < new_wm; off += oa->elem_size) {
			ant_object_t slot = (ant_object_t )(oa->base + off);
			if (slot->mark_epoch == ANT_GC_DEAD) {
			(void *)slot = oa->free_list;
			oa->free_list = slot;
			}}

			ant_arena_decommit(oa->base, oa->committed, new_wm);
			oa->committed = new_wm;
			oa->watermark = new_wm;
			}

			if (gc_mark_cap > GC_MARK_STACK_INIT) {
			size_t target = js->obj_arena.live_count * 2;
			if (target < GC_MARK_STACK_INIT) target = GC_MARK_STACK_INIT;
			if (target < gc_mark_cap / 2) {
			ant_object_t *ns = realloc(gc_mark_stack, target sizeof(*ns));
			if (ns) { gc_mark_stack = ns; gc_mark_cap = target; }
			}
			}
			}

			void gc_objects_run_minor(ant_t *js, gc_str_mark_fn str_mark) {
			if (!js) return;

			g_str_mark = str_mark;
			gc_epoch++;

			if (gc_epoch == 0) gc_epoch = 1;
			gc_obj_epoch = (uint8_t)(gc_obj_epoch + 1u);

			if (gc_obj_epoch == 0 \|\| gc_obj_epoch == ANT_GC_DEAD) gc_obj_epoch = 1;
			g_minor_gc = true;

			for (size_t i = 0; i < js->remember_set_len; i++) gc_scan_obj(js, js->remember_set[i]);
			for (size_t i = 0; i < js->remember_set_len; i++) js->remember_set[i]->in_remember_set = 0;

			js->remember_set_len = 0;
			gc_mark_roots(js);
			g_minor_gc = false;

			gc_sweep_regex_cache();
			gc_sweep_young(js);
			gc_promote_survivors(js);

			// will NOT sweep closure/upvalue arenas here. old closures stored as T_FUNC
			// property values on old objects are not scanned during minor GC (old objects
			// are pre-marked but not traversed unless in the remember set), so their
			// gc_epoch would not be updated and they would be incorrectly freed.
			// closure/upvalue arenas are only swept on major GC `gc_objects_run`
			}

			uint64_t gc_get_epoch(void) {
			return gc_epoch;
			}

Owner Packages

No Owners

ant/src/gc/objects.c3fa05edd2fe3mir/inline-method

objects.cView Options

Owner Packages

ant/src/gc/objects.c
3fa05edd2fe3mir/inline-method

objects.c
View Options