DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
/* Free strings in the stringtable and any allocations needed
* by the stringtable itself.
*/
duk_uint_fast32_t i, j;
duk_strtab_entry *e;
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t *lst;
duk_uint16_t null16 = heap->heapptr_null16;
#else
duk_hstring **lst;
#endif
duk_hstring *h;
for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
e = heap->strtable + i;
if (e->listlen > 0) {
#if defined(DUK_USE_HEAPPTR16)
lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
#else
lst = e->u.strlist;
#endif
DUK_ASSERT(lst != NULL);
for (j = 0; j < e->listlen; j++) {
#if defined(DUK_USE_HEAPPTR16)
h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[j]);
lst[j] = null16;
#else
h = lst[j];
lst[j] = NULL;
#endif
/* strings may have inner refs (extdata) in some cases */
if (h != NULL) {
duk_free_hstring_inner(heap, h);
DUK_FREE(heap, h);
}
}
#if defined(DUK_USE_HEAPPTR16)
e->u.strlist16 = null16;
#else
e->u.strlist = NULL;
#endif
DUK_FREE(heap, lst);
} else {
#if defined(DUK_USE_HEAPPTR16)
h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16);
e->u.str16 = null16;
#else
h = e->u.str;
e->u.str = NULL;
#endif
if (h != NULL) {
duk_free_hstring_inner(heap, h);
DUK_FREE(heap, h);
}
}
e->listlen = 0;
}
}
/* free inner references (these exist e.g. when external
* strings are enabled)
*/
duk_free_hstring_inner(heap, h);
DUK_FREE(heap, h);
(*count_free)++;
}
}
#else /* DUK_USE_HEAPPTR16 */
DUK_LOCAL void duk__sweep_string_chain(duk_heap *heap, duk_hstring **slot, duk_size_t *count_keep, duk_size_t *count_free) {
duk_hstring *h = *slot;
if (h == NULL) {
/* nop */
return;
}
if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
(*count_keep)++;
} else {
#if defined(DUK_USE_REFERENCE_COUNTING)
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
#endif
/* deal with weak references first */
duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
*slot = NULL;
/* free inner references (these exist e.g. when external
* strings are enabled)
*/
duk_free_hstring_inner(heap, h);
DUK_FREE(heap, h);
(*count_free)++;
}
}
DUK_LOCAL void duk__sweep_string_chain16(duk_heap *heap, duk_uint16_t *slot, duk_size_t *count_keep, duk_size_t *count_free) {
duk_uint16_t h16 = *slot;
duk_hstring *h;
duk_uint16_t null16 = heap->heapptr_null16;
if (h16 == null16) {
/* nop */
return;
}
h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, h16);
DUK_ASSERT(h != NULL);
if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
(*count_keep)++;
} else {
#if defined(DUK_USE_REFERENCE_COUNTING)
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
#endif
/* deal with weak references first */
duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
*slot = null16;
/* free inner references (these exist e.g. when external
* strings are enabled)
*/
duk_free_hstring_inner(heap, h);
DUK_FREE(heap, h);
(*count_free)++;
}
}
DUK_INTERNAL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr) {
DUK_ASSERT(heap);
DUK_ASSERT(hdr);
DUK_DDD(DUK_DDDPRINT("free heaphdr %p, htype %ld", (void *) hdr, (long) DUK_HEAPHDR_GET_TYPE(hdr)));
switch ((int) DUK_HEAPHDR_GET_TYPE(hdr)) {
case DUK_HTYPE_STRING:
duk_free_hstring_inner(heap, (duk_hstring *) hdr);
break;
case DUK_HTYPE_OBJECT:
duk_free_hobject_inner(heap, (duk_hobject *) hdr);
break;
case DUK_HTYPE_BUFFER:
duk_free_hbuffer_inner(heap, (duk_hbuffer *) hdr);
break;
default:
DUK_UNREACHABLE();
}
DUK_FREE(heap, hdr);
}
DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
duk_uint_fast32_t i;
duk_hstring *h;
#if defined(DUK_USE_HEAPPTR16)
if (heap->strtable16) {
#else
if (heap->strtable) {
#endif
for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
#if defined(DUK_USE_HEAPPTR16)
h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
#else
h = heap->strtable[i];
#endif
if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
continue;
}
DUK_ASSERT(h != NULL);
/* strings may have inner refs (extdata) in some cases */
duk_free_hstring_inner(heap, h);
DUK_FREE(heap, h);
#if 0 /* not strictly necessary */
heap->strtable[i] = NULL;
#endif
}
#if defined(DUK_USE_HEAPPTR16)
DUK_FREE(heap, heap->strtable16);
#else
DUK_FREE(heap, heap->strtable);
#endif
#if 0 /* not strictly necessary */
heap->strtable = NULL;
#endif
}
}
DUK_LOCAL void duk__free_stringtable(duk_heap *heap) {
duk_uint_fast32_t i;
/* strings are only tracked by stringtable */
#if defined(DUK_USE_HEAPPTR16)
if (heap->strtable16) {
#else
if (heap->strtable) {
#endif
for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
duk_hstring *e;
#if defined(DUK_USE_HEAPPTR16)
e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]);
#else
e = heap->strtable[i];
#endif
if (e == NULL || e == DUK_STRTAB_DELETED_MARKER(heap)) {
continue;
}
DUK_ASSERT(e != NULL);
/* strings may have inner refs (extdata) in some cases */
duk_free_hstring_inner(heap, (duk_hstring *) e);
DUK_DDD(DUK_DDDPRINT("FINALFREE (string): %!iO",
(duk_heaphdr *) e));
DUK_FREE(heap, e);
#if 0 /* not strictly necessary */
heap->strtable[i] = NULL;
#endif
}
#if defined(DUK_USE_HEAPPTR16)
DUK_FREE(heap, heap->strtable16);
#else
DUK_FREE(heap, heap->strtable);
#endif
#if 0 /* not strictly necessary */
heap->strtable = NULL;
#endif
}
}
DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) {
duk_hthread *thr;
duk_heaphdr *curr;
#ifdef DUK_USE_DEBUG
duk_size_t count_obj = 0;
#endif
DUK_ASSERT(heap != NULL);
DUK_ASSERT(heap->heap_thread != NULL);
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_ASSERT(heap->refzero_list == NULL); /* refzero not running -> must be empty */
#endif
#ifdef DUK_USE_MARK_AND_SWEEP
DUK_ASSERT(heap->finalize_list == NULL); /* mark-and-sweep not running -> must be empty */
#endif
/* XXX: here again finalizer thread is the heap_thread which needs
* to be coordinated with finalizer thread fixes.
*/
thr = heap->heap_thread;
DUK_ASSERT(thr != NULL);
curr = heap->heap_allocated;
while (curr) {
if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) {
/* Only objects in heap_allocated may have finalizers. Check that
* the object itself has a _Finalizer property so that we don't
* execute finalizers for e.g. Proxy objects.
*/
DUK_ASSERT(thr != NULL);
DUK_ASSERT(curr != NULL);
if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
duk_hobject_run_finalizer(thr, (duk_hobject *) curr);
}
#ifdef DUK_USE_DEBUG
count_obj++;
#endif
}
curr = DUK_HEAPHDR_GET_NEXT(curr);
}
/* Note: count includes all objects, not only those with an actual finalizer. */
#ifdef DUK_USE_DEBUG
DUK_D(DUK_DPRINT("checked %ld objects for finalizers before freeing heap", (long) count_obj));
#endif
}
DUK_LOCAL void duk__sweep_stringtable_probe(duk_heap *heap, duk_size_t *out_count_keep) {
duk_hstring *h;
duk_uint_fast32_t i;
#ifdef DUK_USE_DEBUG
duk_size_t count_free = 0;
#endif
duk_size_t count_keep = 0;
DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap));
for (i = 0; i < heap->st_size; i++) {
#if defined(DUK_USE_HEAPPTR16)
h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
#else
h = heap->strtable[i];
#endif
if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
continue;
} else if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
count_keep++;
continue;
}
#ifdef DUK_USE_DEBUG
count_free++;
#endif
#if defined(DUK_USE_REFERENCE_COUNTING)
/* Non-zero refcounts should not happen for unreachable strings,
* because we refcount finalize all unreachable objects which
* should have decreased unreachable string refcounts to zero
* (even for cycles).
*/
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
#endif
DUK_DDD(DUK_DDDPRINT("sweep string, not reachable: %p", (void *) h));
/* deal with weak references first */
duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
/* remove the string (mark DELETED), could also call
* duk_heap_string_remove() but that would be slow and
* pointless because we already know the slot.
*/
#if defined(DUK_USE_HEAPPTR16)
heap->strtable16[i] = heap->heapptr_deleted16;
#else
heap->strtable[i] = DUK_STRTAB_DELETED_MARKER(heap);
#endif
/* free inner references (these exist e.g. when external
* strings are enabled)
*/
duk_free_hstring_inner(heap, (duk_hstring *) h);
/* finally free the struct itself */
DUK_FREE(heap, h);
}
#ifdef DUK_USE_DEBUG
DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept",
(long) count_free, (long) count_keep));
#endif
*out_count_keep = count_keep;
}
