DUK_LOCAL void duk__assert_valid_refcounts(duk_heap *heap) {
duk_heaphdr *hdr = heap->heap_allocated;
while (hdr) {
if (DUK_HEAPHDR_GET_REFCOUNT(hdr) == 0 &&
DUK_HEAPHDR_HAS_FINALIZED(hdr)) {
/* An object may be in heap_allocated list with a zero
* refcount if it has just been finalized and is waiting
* to be collected by the next cycle.
*/
} else if (DUK_HEAPHDR_GET_REFCOUNT(hdr) == 0) {
/* An object may be in heap_allocated list with a zero
* refcount also if it is a temporary object created by
* a finalizer; because finalization now runs inside
* mark-and-sweep, such objects will not be queued to
* refzero_list and will thus appear here with refcount
* zero.
*/
#if 0 /* this case can no longer occur because refcount is unsigned */
} else if (DUK_HEAPHDR_GET_REFCOUNT(hdr) < 0) {
DUK_D(DUK_DPRINT("invalid refcount: %ld, %p -> %!O",
(hdr != NULL ? (long) DUK_HEAPHDR_GET_REFCOUNT(hdr) : (long) 0),
(void *) hdr, (duk_heaphdr *) hdr));
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(hdr) > 0);
#endif
}
hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
}
}
DUK_INTERNAL void duk_heaphdr_incref(duk_heaphdr *h) {
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
/* 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_LOCAL void duk__print_hstring(duk__dprint_state *st, duk_hstring *h, duk_bool_t quotes) {
duk_fixedbuffer *fb = st->fb;
const duk_uint8_t *p;
const duk_uint8_t *p_end;
/* terminal type: no depth check */
if (duk_fb_is_full(fb)) {
return;
}
duk__print_shared_heaphdr_string(st, &h->hdr);
if (!h) {
duk_fb_put_cstring(fb, "NULL");
return;
}
p = DUK_HSTRING_GET_DATA(h);
p_end = p + DUK_HSTRING_GET_BYTELEN(h);
if (p_end > p && p[0] == DUK_ASC_UNDERSCORE) {
/* if property key begins with underscore, encode it with
* forced quotes (e.g. "_Foo") to distinguish it from encoded
* internal properties (e.g. \xffBar -> _Bar).
*/
quotes = 1;
}
if (quotes) {
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_DOUBLEQUOTE);
}
while (p < p_end) {
duk_uint8_t ch = *p++;
/* two special escapes: '\' and '"', other printables as is */
if (ch == '\\') {
duk_fb_sprintf(fb, "\\\\");
} else if (ch == '"') {
duk_fb_sprintf(fb, "\\\"");
} else if (ch >= 0x20 && ch <= 0x7e) {
duk_fb_put_byte(fb, ch);
} else if (ch == 0xff && !quotes) {
/* encode \xffBar as _Bar if no quotes are applied, this is for
* readable internal keys.
*/
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_UNDERSCORE);
} else {
duk_fb_sprintf(fb, "\\x%02lx", (unsigned long) ch);
}
}
if (quotes) {
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_DOUBLEQUOTE);
}
#if defined(DUK_USE_REFERENCE_COUNTING)
/* XXX: limit to quoted strings only, to save keys from being cluttered? */
duk_fb_sprintf(fb, "/%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(&h->hdr));
#endif
}
static void duk__sweep_stringtable(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++) {
h = heap->st[i];
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.
*/
heap->st[i] = DUK_STRTAB_DELETED_MARKER(heap);
/* then free */
#if 1
DUK_FREE(heap, (duk_heaphdr *) h); /* no inner refs/allocs, just free directly */
#else
duk_heap_free_heaphdr_raw(heap, (duk_heaphdr *) h); /* this would be OK but unnecessary */
#endif
}
#ifdef DUK_USE_DEBUG
DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %d freed, %d kept",
(int) count_free, (int) count_keep));
#endif
*out_count_keep = count_keep;
}
/*
* Buffers have no internal references. However, a dynamic
* buffer has a separate allocation for the buffer. This is
* freed by duk_heap_free_heaphdr_raw().
*/
duk_heap_remove_any_from_heap_allocated(heap, h);
duk_heap_free_heaphdr_raw(heap, h);
break;
default:
DUK_D(DUK_DPRINT("invalid heap type in decref: %ld", (long) DUK_HEAPHDR_GET_TYPE(h)));
DUK_UNREACHABLE();
}
}
#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
DUK_INTERNAL void duk_tval_incref(duk_tval *tv) {
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT_DISABLE(h->h_refcount >= 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
}
#endif
#if 0 /* unused */
DUK_INTERNAL void duk_tval_incref_allownull(duk_tval *tv) {
if (tv == NULL) {
return;
}
if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT_DISABLE(h->h_refcount >= 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
}
#endif
DUK_INTERNAL void duk_tval_decref(duk_hthread *thr, duk_tval *tv) {
DUK_ASSERT(thr != NULL);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
duk_heaphdr_decref(thr, h);
}
}
#if 0 /* unused */
DUK_INTERNAL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv) {
DUK_ASSERT(thr != NULL);
if (tv == NULL) {
return;
}
if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
duk_heaphdr_decref(thr, h);
}
}
#endif
#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
DUK_INTERNAL void duk_heaphdr_incref(duk_heaphdr *h) {
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
#endif
#if 0 /* unused */
DUK_INTERNAL void duk_heaphdr_incref_allownull(duk_heaphdr *h) {
if (h == NULL) {
return;
}
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
static void duk__dump_stringtable(duk_heap *heap) {
duk_uint_fast32_t i;
char buf[64+1];
DUK_D(DUK_DPRINT("stringtable %p, used %ld, size %ld, load %ld%%",
(void *) heap->st,
(long) heap->st_used,
(long) heap->st_size,
(long) (((double) heap->st_used) / ((double) heap->st_size) * 100.0)));
for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
duk_hstring *e = heap->st[i];
if (!e) {
DUK_D(DUK_DPRINT(" [%ld]: NULL", (long) i));
} else if (e == DUK_STRTAB_DELETED_MARKER(heap)) {
DUK_D(DUK_DPRINT(" [%ld]: DELETED", (long) i));
} else {
duk__sanitize_snippet(buf, sizeof(buf), e);
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_D(DUK_DPRINT(" [%ld]: %p (flags: 0x%08lx, ref: %ld) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, "
"arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld",
(long) i,
(void *) e,
(unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
(long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) e),
(const char *) buf,
(unsigned long) e->hash,
(long) e->blen,
(long) e->clen,
(long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0)));
#else
DUK_D(DUK_DPRINT(" [%ld]: %p (flags: 0x%08lx) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, "
"arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld",
(long) i,
(void *) e,
(unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
(const char *) buf,
(long) e->hash,
(long) e->blen,
(long) e->clen,
(long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0),
(long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0)));
#endif
}
}
}
DUK_INTERNAL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h) {
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr->heap != NULL);
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1);
if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
return;
}
duk_heaphdr_refzero(thr, h);
}
static void dump_stringtable(duk_heap *heap) {
duk_uint32_t i;
char buf[64+1];
DUK_DPRINT("stringtable %p, used %d, size %d, load %d%%",
(void *) heap->st,
(int) heap->st_used,
(int) heap->st_size,
(int) (((double) heap->st_used) / ((double) heap->st_size) * 100.0));
for (i = 0; i < heap->st_size; i++) {
duk_hstring *e = heap->st[i];
if (!e) {
DUK_DPRINT(" [%d]: NULL", i);
} else if (e == DUK_STRTAB_DELETED_MARKER(heap)) {
DUK_DPRINT(" [%d]: DELETED", i);
} else {
sanitize_snippet(buf, sizeof(buf), e);
/* FIXME: all string flags not printed now */
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_DPRINT(" [%d]: %p (flags: 0x%08x, ref: %d) '%s', strhash=0x%08x, blen=%d, clen=%d, arridx=%d, internal=%d",
i,
(void *) e,
(int) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
(int) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) e),
buf,
(int) e->hash,
(int) e->blen,
(int) e->clen,
DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0,
DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0);
#else
DUK_DPRINT(" [%d]: %p (flags: 0x%08x) '%s', strhash=0x%08x, blen=%d, clen=%d, arridx=%d, internal=%d",
i,
(void *) e,
(int) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
buf,
(int) e->hash,
(int) e->blen,
(int) e->clen,
DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0,
DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0);
#endif
}
}
}
DUK_LOCAL void duk__print_shared_heaphdr(duk__dprint_state *st, duk_heaphdr *h) {
duk_fixedbuffer *fb = st->fb;
if (st->heavy) {
duk_fb_sprintf(fb, "(%p)", (void *) h);
}
if (!h) {
return;
}
if (st->binary) {
duk_size_t i;
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET);
for (i = 0; i < (duk_size_t) sizeof(*h); i++) {
duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)h)[i]);
}
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET);
}
#if defined(DUK_USE_REFERENCE_COUNTING) /* currently implicitly also DUK_USE_DOUBLE_LINKED_HEAP */
if (st->heavy) {
duk_fb_sprintf(fb, "[h_next=%p,h_prev=%p,h_refcount=%lu,h_flags=%08lx,type=%ld,"
"reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]",
(void *) DUK_HEAPHDR_GET_NEXT(NULL, h),
(void *) DUK_HEAPHDR_GET_PREV(NULL, h),
(unsigned long) DUK_HEAPHDR_GET_REFCOUNT(h),
(unsigned long) DUK_HEAPHDR_GET_FLAGS(h),
(long) DUK_HEAPHDR_GET_TYPE(h),
(long) (DUK_HEAPHDR_HAS_REACHABLE(h) ? 1 : 0),
(long) (DUK_HEAPHDR_HAS_TEMPROOT(h) ? 1 : 0),
(long) (DUK_HEAPHDR_HAS_FINALIZABLE(h) ? 1 : 0),
(long) (DUK_HEAPHDR_HAS_FINALIZED(h) ? 1 : 0));
}
#else
if (st->heavy) {
duk_fb_sprintf(fb, "[h_next=%p,h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]",
(void *) DUK_HEAPHDR_GET_NEXT(NULL, h),
(unsigned long) DUK_HEAPHDR_GET_FLAGS(h),
(long) DUK_HEAPHDR_GET_TYPE(h),
(long) (DUK_HEAPHDR_HAS_REACHABLE(h) ? 1 : 0),
(long) (DUK_HEAPHDR_HAS_TEMPROOT(h) ? 1 : 0),
(long) (DUK_HEAPHDR_HAS_FINALIZABLE(h) ? 1 : 0),
(long) (DUK_HEAPHDR_HAS_FINALIZED(h) ? 1 : 0));
}
#endif
}
DUK_LOCAL void duk__print_hbuffer(duk__dprint_state *st, duk_hbuffer *h) {
duk_fixedbuffer *fb = st->fb;
duk_size_t i, n;
duk_uint8_t *p;
if (duk_fb_is_full(fb)) {
return;
}
/* terminal type: no depth check */
if (!h) {
duk_fb_put_cstring(fb, "NULL");
return;
}
if (DUK_HBUFFER_HAS_DYNAMIC(h)) {
if (DUK_HBUFFER_HAS_EXTERNAL(h)) {
duk_hbuffer_external *g = (duk_hbuffer_external *) h;
duk_fb_sprintf(fb, "buffer:external:%p:%ld",
(void *) DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(NULL, g),
(long) DUK_HBUFFER_EXTERNAL_GET_SIZE(g));
} else {
duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h;
duk_fb_sprintf(fb, "buffer:dynamic:%p:%ld",
(void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(NULL, g),
(long) DUK_HBUFFER_DYNAMIC_GET_SIZE(g));
}
} else {
duk_fb_sprintf(fb, "buffer:fixed:%ld", (long) DUK_HBUFFER_GET_SIZE(h));
}
#if defined(DUK_USE_REFERENCE_COUNTING)
duk_fb_sprintf(fb, "/%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(&h->hdr));
#endif
if (st->hexdump) {
duk_fb_sprintf(fb, "=[");
n = DUK_HBUFFER_GET_SIZE(h);
p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(NULL, h);
for (i = 0; i < n; i++) {
duk_fb_sprintf(fb, "%02lx", (unsigned long) p[i]);
}
duk_fb_sprintf(fb, "]");
}
}
DUK_INTERNAL void duk_heap_heaphdr_incref(duk_heaphdr *h) {
#if 0
DUK_DDD(DUK_DDDPRINT("heaphdr incref %p (%ld->%ld): %!O",
(void *) h,
(h != NULL ? (long) h->h_refcount : (long) 0),
(h != NULL ? (long) (h->h_refcount + 1) : (long) 0),
(duk_heaphdr *) h));
#endif
if (!h) {
return;
}
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h);
}
DUK_INTERNAL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h) {
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr->heap != NULL);
DUK_ASSERT(h != NULL);
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1);
#if defined(DUK_USE_ROM_OBJECTS)
if (DUK_HEAPHDR_HAS_READONLY(h)) {
return;
}
#endif
if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
return;
}
duk_heaphdr_refzero(thr, h);
}
int duk_builtin_duk_object_refc(duk_context *ctx) {
#ifdef DUK_USE_REFERENCE_COUNTING
duk_tval *tv = duk_get_tval(ctx, 0);
duk_heaphdr *h;
if (!tv) {
return 0;
}
if (!DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
return 0;
}
h = DUK_TVAL_GET_HEAPHDR(tv);
duk_push_int(ctx, DUK_HEAPHDR_GET_REFCOUNT(h));
return 1;
#else
return 0;
#endif
}
static void duk__dump_indented(duk_heaphdr *obj, int index) {
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_D(DUK_DPRINT(" [%ld]: %p %s (flags: 0x%08lx, ref: %ld) -> %!O",
(long) index,
(void *) obj,
(const char *) duk__get_heap_type_string(obj),
(unsigned long) DUK_HEAPHDR_GET_FLAGS(obj),
(long) DUK_HEAPHDR_GET_REFCOUNT(obj),
(duk_heaphdr *) obj));
#else
DUK_D(DUK_DPRINT(" [%ld]: %p %s (flags: 0x%08lx) -> %!O",
(long) index,
(void *) obj,
(const char *) duk__get_heap_type_string(obj),
(unsigned long) DUK_HEAPHDR_GET_FLAGS(obj),
(duk_heaphdr *) obj));
#endif
}
static void dump_indented(duk_heaphdr *obj, int index) {
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_DPRINT(" [%d]: %p %s (flags: 0x%08x, ref: %d) -> %!O",
index,
(void *) obj,
get_heap_type_string(obj),
(int) DUK_HEAPHDR_GET_FLAGS(obj),
DUK_HEAPHDR_GET_REFCOUNT(obj),
obj);
#else
DUK_DPRINT(" [%d]: %p %s (flags: 0x%08x) -> %!O",
index,
(void *) obj,
get_heap_type_string(obj),
(int) DUK_HEAPHDR_GET_FLAGS(obj),
obj);
#endif
}
/* Raw helper to extract internal information / statistics about a value.
* The return values are version specific and must not expose anything
* that would lead to security issues (e.g. exposing compiled function
* 'data' buffer might be an issue). Currently only counts and sizes and
* such are given so there should not be a security impact.
*/
duk_ret_t duk_bi_duktape_object_info(duk_context *ctx) {
duk_tval *tv;
duk_heaphdr *h;
duk_int_t i, n;
tv = duk_get_tval(ctx, 0);
DUK_ASSERT(tv != NULL); /* because arg count is 1 */
duk_push_array(ctx); /* -> [ val arr ] */
/* type tag (public) */
duk_push_int(ctx, duk_get_type(ctx, 0));
/* address */
if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
h = DUK_TVAL_GET_HEAPHDR(tv);
duk_push_pointer(ctx, (void *) h);
} else {
goto done;
}
DUK_ASSERT(h != NULL);
/* refcount */
#ifdef DUK_USE_REFERENCE_COUNTING
duk_push_int(ctx, DUK_HEAPHDR_GET_REFCOUNT(h));
#else
duk_push_undefined(ctx);
#endif
/* heaphdr size and additional allocation size, followed by
* type specific stuff (with varying value count)
*/
switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
case DUK_HTYPE_STRING: {
duk_hstring *h_str = (duk_hstring *) h;
duk_push_int(ctx, (int) (sizeof(duk_hstring) + DUK_HSTRING_GET_BYTELEN(h_str) + 1));
break;
}
case DUK_HTYPE_OBJECT: {
duk_hobject *h_obj = (duk_hobject *) h;
duk_int_t hdr_size;
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
hdr_size = (duk_int_t) sizeof(duk_hcompiledfunction);
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h_obj)) {
hdr_size = (duk_int_t) sizeof(duk_hnativefunction);
} else if (DUK_HOBJECT_IS_THREAD(h_obj)) {
hdr_size = (duk_int_t) sizeof(duk_hthread);
} else {
hdr_size = (duk_int_t) sizeof(duk_hobject);
}
duk_push_int(ctx, (int) hdr_size);
duk_push_int(ctx, (int) DUK_HOBJECT_E_ALLOC_SIZE(h_obj));
duk_push_int(ctx, (int) h_obj->e_size);
duk_push_int(ctx, (int) h_obj->e_used);
duk_push_int(ctx, (int) h_obj->a_size);
duk_push_int(ctx, (int) h_obj->h_size);
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
duk_hbuffer *h_data = ((duk_hcompiledfunction *) h_obj)->data;
if (h_data) {
duk_push_int(ctx, DUK_HBUFFER_GET_SIZE(h_data));
} else {
duk_push_int(ctx, 0);
}
}
break;
}
case DUK_HTYPE_BUFFER: {
duk_hbuffer *h_buf = (duk_hbuffer *) h;
if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) {
/* XXX: when usable_size == 0, dynamic buf ptr may now be NULL, in which case
* the second allocation does not exist.
*/
duk_hbuffer_dynamic *h_dyn = (duk_hbuffer_dynamic *) h;
duk_push_int(ctx, (int) (sizeof(duk_hbuffer_dynamic)));
duk_push_int(ctx, (int) (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h_dyn)));
} else {
duk_push_int(ctx, (int) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1));
}
break;
}
}
done:
/* set values into ret array */
/* FIXME: primitive to make array from valstack slice */
n = duk_get_top(ctx);
for (i = 2; i < n; i++) {
duk_dup(ctx, i);
duk_put_prop_index(ctx, 1, i - 2);
}
duk_dup(ctx, 1);
return 1;
}
/* Raw helper to extract internal information / statistics about a value.
* The return values are version specific and must not expose anything
* that would lead to security issues (e.g. exposing compiled function
* 'data' buffer might be an issue). Currently only counts and sizes and
* such are given so there should not be a security impact.
*/
DUK_INTERNAL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_tval *tv;
duk_heaphdr *h;
duk_int_t i, n;
DUK_UNREF(thr);
/* result array */
duk_push_array(ctx); /* -> [ val arr ] */
/* type tag (public) */
duk_push_int(ctx, duk_get_type(ctx, 0));
/* address */
tv = duk_get_tval(ctx, 0);
DUK_ASSERT(tv != NULL); /* because arg count is 1 */
if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
h = DUK_TVAL_GET_HEAPHDR(tv);
duk_push_pointer(ctx, (void *) h);
} else {
/* internal type tag */
duk_push_int(ctx, (duk_int_t) DUK_TVAL_GET_TAG(tv));
goto done;
}
DUK_ASSERT(h != NULL);
/* refcount */
#ifdef DUK_USE_REFERENCE_COUNTING
duk_push_size_t(ctx, DUK_HEAPHDR_GET_REFCOUNT(h));
#else
duk_push_undefined(ctx);
#endif
/* heaphdr size and additional allocation size, followed by
* type specific stuff (with varying value count)
*/
switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
case DUK_HTYPE_STRING: {
duk_hstring *h_str = (duk_hstring *) h;
duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hstring) + DUK_HSTRING_GET_BYTELEN(h_str) + 1));
break;
}
case DUK_HTYPE_OBJECT: {
duk_hobject *h_obj = (duk_hobject *) h;
duk_small_uint_t hdr_size;
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
hdr_size = (duk_small_uint_t) sizeof(duk_hcompiledfunction);
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h_obj)) {
hdr_size = (duk_small_uint_t) sizeof(duk_hnativefunction);
} else if (DUK_HOBJECT_IS_THREAD(h_obj)) {
hdr_size = (duk_small_uint_t) sizeof(duk_hthread);
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
} else if (DUK_HOBJECT_IS_BUFFEROBJECT(h_obj)) {
hdr_size = (duk_small_uint_t) sizeof(duk_hbufferobject);
#endif
} else {
hdr_size = (duk_small_uint_t) sizeof(duk_hobject);
}
duk_push_uint(ctx, (duk_uint_t) hdr_size);
duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_P_ALLOC_SIZE(h_obj));
duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ESIZE(h_obj));
/* Note: e_next indicates the number of gc-reachable entries
* in the entry part, and also indicates the index where the
* next new property would be inserted. It does *not* indicate
* the number of non-NULL keys present in the object. That
* value could be counted separately but requires a pass through
* the key list.
*/
duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ENEXT(h_obj));
duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ASIZE(h_obj));
duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_HSIZE(h_obj));
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
duk_hbuffer *h_data = (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, (duk_hcompiledfunction *) h_obj);
if (h_data) {
duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_data));
} else {
duk_push_uint(ctx, 0);
}
}
break;
}
case DUK_HTYPE_BUFFER: {
duk_hbuffer *h_buf = (duk_hbuffer *) h;
if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) {
if (DUK_HBUFFER_HAS_EXTERNAL(h_buf)) {
duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_external)));
} else {
/* When alloc_size == 0 the second allocation may not
* actually exist.
*/
duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_dynamic)));
}
duk_push_uint(ctx, (duk_uint_t) (DUK_HBUFFER_GET_SIZE(h_buf)));
} else {
duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1));
}
break;
}
}
done:
/* set values into ret array */
/* XXX: primitive to make array from valstack slice */
n = duk_get_top(ctx);
for (i = 2; i < n; i++) {
duk_dup(ctx, i);
duk_put_prop_index(ctx, 1, i - 2);
}
duk_dup(ctx, 1);
return 1;
}
DUK_LOCAL void duk__sweep_stringtable(duk_heap *heap, duk_size_t *out_count_keep) {
duk_hstring *h;
duk_hstring *prev;
duk_uint32_t i;
#if defined(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));
#if defined(DUK_USE_STRTAB_PTRCOMP)
if (heap->strtable16 == NULL) {
#else
if (heap->strtable == NULL) {
#endif
goto done;
}
for (i = 0; i < heap->st_size; i++) {
#if defined(DUK_USE_STRTAB_PTRCOMP)
h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
#else
h = heap->strtable[i];
#endif
prev = NULL;
while (h != NULL) {
duk_hstring *next;
next = h->hdr.h_next;
if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
count_keep++;
prev = h;
} else {
#if defined(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
/* deal with weak references first */
duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
/* remove the string from the string table */
duk_heap_strtable_unlink_prev(heap, (duk_hstring *) h, (duk_hstring *) prev);
/* free inner references (these exist e.g. when external
* strings are enabled) and the struct itself.
*/
duk_free_hstring(heap, (duk_hstring *) h);
/* don't update 'prev'; it should be last string kept */
}
h = next;
}
}
done:
#if defined(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;
}
/*
* Sweep heap
*/
DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep) {
duk_heaphdr *prev; /* last element that was left in the heap */
duk_heaphdr *curr;
duk_heaphdr *next;
#if defined(DUK_USE_DEBUG)
duk_size_t count_free = 0;
duk_size_t count_finalize = 0;
duk_size_t count_rescue = 0;
#endif
duk_size_t count_keep = 0;
DUK_UNREF(flags);
DUK_DD(DUK_DDPRINT("duk__sweep_heap: %p", (void *) heap));
prev = NULL;
curr = heap->heap_allocated;
heap->heap_allocated = NULL;
while (curr) {
/* Strings and ROM objects are never placed on the heap allocated list. */
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_STRING);
DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY(curr));
next = DUK_HEAPHDR_GET_NEXT(heap, curr);
if (DUK_HEAPHDR_HAS_REACHABLE(curr)) {
/*
* Reachable object, keep
*/
DUK_DDD(DUK_DDDPRINT("sweep, reachable: %p", (void *) curr));
if (DUK_HEAPHDR_HAS_FINALIZABLE(curr)) {
/*
* If object has been marked finalizable, move it to the
* "to be finalized" work list. It will be collected on
* the next mark-and-sweep if it is still unreachable
* after running the finalizer.
*/
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
DUK_DDD(DUK_DDDPRINT("object has finalizer, move to finalization work list: %p", (void *) curr));
#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
if (heap->finalize_list) {
DUK_HEAPHDR_SET_PREV(heap, heap->finalize_list, curr);
}
DUK_HEAPHDR_SET_PREV(heap, curr, NULL);
#endif
DUK_HEAPHDR_SET_NEXT(heap, curr, heap->finalize_list);
DUK_ASSERT_HEAPHDR_LINKS(heap, curr);
heap->finalize_list = curr;
#if defined(DUK_USE_DEBUG)
count_finalize++;
#endif
} else {
/*
* Object will be kept; queue object back to heap_allocated (to tail)
*/
if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
/*
* Object's finalizer was executed on last round, and
* object has been happily rescued.
*/
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
DUK_DD(DUK_DDPRINT("object rescued during mark-and-sweep finalization: %p", (void *) curr));
#if defined(DUK_USE_DEBUG)
count_rescue++;
#endif
} else {
/*
* Plain, boring reachable object.
*/
DUK_DD(DUK_DDPRINT("keep object: %!iO", curr));
count_keep++;
}
if (!heap->heap_allocated) {
heap->heap_allocated = curr;
}
if (prev) {
DUK_HEAPHDR_SET_NEXT(heap, prev, curr);
}
#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
DUK_HEAPHDR_SET_PREV(heap, curr, prev);
#endif
DUK_ASSERT_HEAPHDR_LINKS(heap, prev);
DUK_ASSERT_HEAPHDR_LINKS(heap, curr);
prev = curr;
}
DUK_HEAPHDR_CLEAR_REACHABLE(curr);
DUK_HEAPHDR_CLEAR_FINALIZED(curr);
DUK_HEAPHDR_CLEAR_FINALIZABLE(curr);
DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
curr = next;
} else {
/*
* Unreachable object, free
*/
DUK_DDD(DUK_DDDPRINT("sweep, not reachable: %p", (void *) curr));
#if defined(DUK_USE_REFERENCE_COUNTING)
/* Non-zero refcounts should not happen because we refcount
* finalize all unreachable objects which should cancel out
* refcounts (even for cycles).
*/
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(curr) == 0);
#endif
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
DUK_DDD(DUK_DDDPRINT("finalized object not rescued: %p", (void *) curr));
}
/* Note: object cannot be a finalizable unreachable object, as
* they have been marked temporarily reachable for this round,
* and are handled above.
*/
#if defined(DUK_USE_DEBUG)
count_free++;
#endif
/* weak refs should be handled here, but no weak refs for
* any non-string objects exist right now.
*/
/* free object and all auxiliary (non-heap) allocs */
duk_heap_free_heaphdr_raw(heap, curr);
curr = next;
}
}
if (prev) {
DUK_HEAPHDR_SET_NEXT(heap, prev, NULL);
}
DUK_ASSERT_HEAPHDR_LINKS(heap, prev);
#if defined(DUK_USE_DEBUG)
DUK_D(DUK_DPRINT("mark-and-sweep sweep objects (non-string): %ld freed, %ld kept, %ld rescued, %ld queued for finalization",
(long) count_free, (long) count_keep, (long) count_rescue, (long) count_finalize));
#endif
*out_count_keep = count_keep;
}
DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) {
duk_heaphdr *h1, *h2;
duk_heap *heap;
duk_int_t count = 0;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr->heap != NULL);
heap = thr->heap;
DUK_ASSERT(heap != NULL);
/*
* Detect recursive invocation
*/
if (DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)) {
DUK_DDD(DUK_DDDPRINT("refzero free running, skip run"));
return;
}
/*
* Churn refzero_list until empty
*/
DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap);
while (heap->refzero_list) {
duk_hobject *obj;
duk_bool_t rescued = 0;
/*
* Pick an object from the head (don't remove yet).
*/
h1 = heap->refzero_list;
obj = (duk_hobject *) h1;
DUK_DD(DUK_DDPRINT("refzero processing %p: %!O", (void *) h1, (duk_heaphdr *) h1));
DUK_ASSERT(DUK_HEAPHDR_GET_PREV(h1) == NULL);
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(h1) == DUK_HTYPE_OBJECT); /* currently, always the case */
/*
* Finalizer check.
*
* Note: running a finalizer may have arbitrary side effects, e.g.
* queue more objects on refzero_list (tail), or even trigger a
* mark-and-sweep.
*
* Note: quick reject check should match vast majority of
* objects and must be safe (not throw any errors, ever).
*/
/* XXX: If object has FINALIZED, it was finalized by mark-and-sweep on
* its previous run. Any point in running finalizer again here? If
* finalization semantics is changed so that finalizer is only run once,
* checking for FINALIZED would happen here.
*/
/* A finalizer is looked up from the object and up its prototype chain
* (which allows inherited finalizers).
*/
if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
DUK_DDD(DUK_DDDPRINT("object has a finalizer, run it"));
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0);
DUK_HEAPHDR_PREINC_REFCOUNT(h1); /* bump refcount to prevent refzero during finalizer processing */
duk_hobject_run_finalizer(thr, obj); /* must never longjmp */
DUK_HEAPHDR_PREDEC_REFCOUNT(h1); /* remove artificial bump */
DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */
if (DUK_HEAPHDR_GET_REFCOUNT(h1) != 0) {
DUK_DDD(DUK_DDDPRINT("-> object refcount after finalization non-zero, object will be rescued"));
rescued = 1;
} else {
DUK_DDD(DUK_DDDPRINT("-> object refcount still zero after finalization, object will be freed"));
}
}
/* Refzero head is still the same. This is the case even if finalizer
* inserted more refzero objects; they are inserted to the tail.
*/
DUK_ASSERT(h1 == heap->refzero_list);
/*
* Remove the object from the refzero list. This cannot be done
* before a possible finalizer has been executed; the finalizer
* may trigger a mark-and-sweep, and mark-and-sweep must be able
* to traverse a complete refzero_list.
*/
h2 = DUK_HEAPHDR_GET_NEXT(h1);
if (h2) {
DUK_HEAPHDR_SET_PREV(h2, NULL); /* not strictly necessary */
heap->refzero_list = h2;
} else {
heap->refzero_list = NULL;
heap->refzero_list_tail = NULL;
}
/*
* Rescue or free.
*/
if (rescued) {
/* yes -> move back to heap allocated */
DUK_DD(DUK_DDPRINT("object rescued during refcount finalization: %p", (void *) h1));
DUK_HEAPHDR_SET_PREV(h1, NULL);
DUK_HEAPHDR_SET_NEXT(h1, heap->heap_allocated);
heap->heap_allocated = h1;
} else {
/* no -> decref members, then free */
duk__refcount_finalize_hobject(thr, obj);
duk_heap_free_heaphdr_raw(heap, h1);
}
count++;
}
DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap);
DUK_DDD(DUK_DDDPRINT("refzero processed %ld objects", (long) count));
/*
* Once the whole refzero cascade has been freed, check for
* a voluntary mark-and-sweep.
*/
#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_VOLUNTARY_GC)
/* 'count' is more or less comparable to normal trigger counter update
* which happens in memory block (re)allocation.
*/
heap->mark_and_sweep_trigger_counter -= count;
if (heap->mark_and_sweep_trigger_counter <= 0) {
duk_bool_t rc;
duk_small_uint_t flags = 0; /* not emergency */
DUK_D(DUK_DPRINT("refcount triggering mark-and-sweep"));
rc = duk_heap_mark_and_sweep(heap, flags);
DUK_UNREF(rc);
DUK_D(DUK_DPRINT("refcount triggered mark-and-sweep => rc %ld", (long) rc));
}
#endif /* DUK_USE_MARK_AND_SWEEP && DUK_USE_VOLUNTARY_GC */
}
static void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep) {
duk_heaphdr *prev; /* last element that was left in the heap */
duk_heaphdr *curr;
duk_heaphdr *next;
#ifdef DUK_USE_DEBUG
duk_size_t count_free = 0;
duk_size_t count_finalize = 0;
duk_size_t count_rescue = 0;
#endif
duk_size_t count_keep = 0;
DUK_UNREF(flags);
DUK_DD(DUK_DDPRINT("duk__sweep_heap: %p", (void *) heap));
prev = NULL;
curr = heap->heap_allocated;
heap->heap_allocated = NULL;
while (curr) {
/* strings are never placed on the heap allocated list */
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_STRING);
next = DUK_HEAPHDR_GET_NEXT(curr);
if (DUK_HEAPHDR_HAS_REACHABLE(curr)) {
/*
* Reachable object, keep
*/
DUK_DDD(DUK_DDDPRINT("sweep, reachable: %p", (void *) curr));
if (DUK_HEAPHDR_HAS_FINALIZABLE(curr)) {
/*
* If object has been marked finalizable, move it to the
* "to be finalized" work list. It will be collected on
* the next mark-and-sweep if it is still unreachable
* after running the finalizer.
*/
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
DUK_DDD(DUK_DDDPRINT("object has finalizer, move to finalization work list: %p", (void *) curr));
#ifdef DUK_USE_DOUBLE_LINKED_HEAP
if (heap->finalize_list) {
DUK_HEAPHDR_SET_PREV(heap->finalize_list, curr);
}
DUK_HEAPHDR_SET_PREV(curr, NULL);
#endif
DUK_HEAPHDR_SET_NEXT(curr, heap->finalize_list);
heap->finalize_list = curr;
#ifdef DUK_USE_DEBUG
count_finalize++;
#endif
} else {
/*
* Object will be kept; queue object back to heap_allocated (to tail)
*/
if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
/*
* Object's finalizer was executed on last round, and
* object has been happily rescued.
*/
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
DUK_DD(DUK_DDPRINT("object rescued during mark-and-sweep finalization: %p", (void *) curr));
#ifdef DUK_USE_DEBUG
count_rescue++;
#endif
} else {
/*
* Plain, boring reachable object.
*/
count_keep++;
}
if (!heap->heap_allocated) {
heap->heap_allocated = curr;
}
if (prev) {
DUK_HEAPHDR_SET_NEXT(prev, curr);
}
#ifdef DUK_USE_DOUBLE_LINKED_HEAP
DUK_HEAPHDR_SET_PREV(curr, prev);
#endif
prev = curr;
}
DUK_HEAPHDR_CLEAR_REACHABLE(curr);
DUK_HEAPHDR_CLEAR_FINALIZED(curr);
DUK_HEAPHDR_CLEAR_FINALIZABLE(curr);
DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
curr = next;
} else {
/*
* Unreachable object, free
*/
DUK_DDD(DUK_DDDPRINT("sweep, not reachable: %p", (void *) curr));
#if defined(DUK_USE_REFERENCE_COUNTING)
/* Non-zero refcounts should not happen because we refcount
* finalize all unreachable objects which should cancel out
* refcounts (even for cycles).
*/
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(curr) == 0);
#endif
DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
DUK_DDD(DUK_DDDPRINT("finalized object not rescued: %p", (void *) curr));
}
/* Note: object cannot be a finalizable unreachable object, as
* they have been marked temporarily reachable for this round,
* and are handled above.
*/
#ifdef DUK_USE_DEBUG
count_free++;
#endif
/* weak refs should be handled here, but no weak refs for
* any non-string objects exist right now.
*/
/* free object and all auxiliary (non-heap) allocs */
duk_heap_free_heaphdr_raw(heap, curr);
curr = next;
}
}
if (prev) {
DUK_HEAPHDR_SET_NEXT(prev, NULL);
}
#ifdef DUK_USE_DEBUG
DUK_D(DUK_DPRINT("mark-and-sweep sweep objects (non-string): %d freed, %d kept, %d rescued, %d queued for finalization",
(int) count_free, (int) count_keep, (int) count_rescue, (int) count_finalize));
#endif
*out_count_keep = count_keep;
}
DUK_INTERNAL void duk_heap_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h) {
duk_heap *heap;
#if 0
DUK_DDD(DUK_DDDPRINT("heaphdr decref %p (%ld->%ld): %!O",
(void *) h,
(h != NULL ? (long) h->h_refcount : (long) 0),
(h != NULL ? (long) (h->h_refcount - 1) : (long) 0),
(duk_heaphdr *) h));
#endif
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr->heap != NULL);
if (!h) {
return;
}
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1);
if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
return;
}
heap = thr->heap;
DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h));
#ifdef DUK_USE_MARK_AND_SWEEP
/*
* If mark-and-sweep is running, don't process 'refzero' situations at all.
* They may happen because mark-and-sweep needs to finalize refcounts for
* each object it sweeps. Otherwise the target objects of swept objects
* would have incorrect refcounts.
*
* Note: mark-and-sweep could use a separate decref handler to avoid coming
* here at all. However, mark-and-sweep may also call finalizers, which
* can do arbitrary operations and would use this decref variant anyway.
*/
if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h));
return;
}
#endif
switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
case DUK_HTYPE_STRING:
/*
* Strings have no internal references but do have "weak"
* references in the string cache. Also note that strings
* are not on the heap_allocated list like other heap
* elements.
*/
duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
duk_heap_string_remove(heap, (duk_hstring *) h);
duk_heap_free_heaphdr_raw(heap, h);
break;
case DUK_HTYPE_OBJECT:
/*
* Objects have internal references. Must finalize through
* the "refzero" work list.
*/
duk_heap_remove_any_from_heap_allocated(heap, h);
duk__queue_refzero(heap, h);
duk__refzero_free_pending(thr);
break;
case DUK_HTYPE_BUFFER:
/*
* Buffers have no internal references. However, a dynamic
* buffer has a separate allocation for the buffer. This is
* freed by duk_heap_free_heaphdr_raw().
*/
duk_heap_remove_any_from_heap_allocated(heap, h);
duk_heap_free_heaphdr_raw(heap, h);
break;
default:
DUK_D(DUK_DPRINT("invalid heap type in decref: %ld", (long) DUK_HEAPHDR_GET_TYPE(h)));
DUK_UNREACHABLE();
}
}
DUK_LOCAL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h) {
duk_fixedbuffer *fb = st->fb;
duk_uint_fast32_t i;
duk_tval *tv;
duk_hstring *key;
duk_bool_t first = 1;
const char *brace1 = "{";
const char *brace2 = "}";
duk_bool_t pushed_loopstack = 0;
if (duk_fb_is_full(fb)) {
return;
}
duk__print_shared_heaphdr(st, &h->hdr);
if (h && DUK_HOBJECT_HAS_ARRAY_PART(h)) {
brace1 = "[";
brace2 = "]";
}
if (!h) {
duk_fb_put_cstring(fb, "NULL");
goto finished;
}
if (st->depth >= st->depth_limit) {
const char *subtype = "generic";
if (DUK_HOBJECT_IS_COMPFUNC(h)) {
subtype = "compfunc";
} else if (DUK_HOBJECT_IS_NATFUNC(h)) {
subtype = "natfunc";
} else if (DUK_HOBJECT_IS_THREAD(h)) {
subtype = "thread";
} else if (DUK_HOBJECT_IS_BUFOBJ(h)) {
subtype = "bufobj";
} else if (DUK_HOBJECT_IS_ARRAY(h)) {
subtype = "array";
}
duk_fb_sprintf(fb, "%sobject/%s %p%s", (const char *) brace1, subtype, (void *) h, (const char *) brace2);
return;
}
for (i = 0; i < (duk_uint_fast32_t) st->loop_stack_index; i++) {
if (st->loop_stack[i] == h) {
duk_fb_sprintf(fb, "%sLOOP:%p%s", (const char *) brace1, (void *) h, (const char *) brace2);
return;
}
}
/* after this, return paths should 'goto finished' for decrement */
st->depth++;
if (st->loop_stack_index >= st->loop_stack_limit) {
duk_fb_sprintf(fb, "%sOUT-OF-LOOP-STACK%s", (const char *) brace1, (const char *) brace2);
goto finished;
}
st->loop_stack[st->loop_stack_index++] = h;
pushed_loopstack = 1;
/*
* Notation: double underscore used for internal properties which are not
* stored in the property allocation (e.g. '__valstack').
*/
duk_fb_put_cstring(fb, brace1);
if (DUK_HOBJECT_GET_PROPS(NULL, h)) {
duk_uint32_t a_limit;
a_limit = DUK_HOBJECT_GET_ASIZE(h);
if (st->internal) {
/* dump all allocated entries, unused entries print as 'unused',
* note that these may extend beyond current 'length' and look
* a bit funny.
*/
} else {
/* leave out trailing 'unused' elements */
while (a_limit > 0) {
tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, a_limit - 1);
if (!DUK_TVAL_IS_UNUSED(tv)) {
break;
}
a_limit--;
}
}
for (i = 0; i < a_limit; i++) {
tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, i);
DUK__COMMA();
duk__print_tval(st, tv);
}
for (i = 0; i < DUK_HOBJECT_GET_ENEXT(h); i++) {
key = DUK_HOBJECT_E_GET_KEY(NULL, h, i);
if (!key) {
continue;
}
if (!st->internal && DUK_HSTRING_HAS_HIDDEN(key)) {
continue;
}
DUK__COMMA();
duk__print_hstring(st, key, 0);
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COLON);
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(NULL, h, i)) {
duk_fb_sprintf(fb, "[get:%p,set:%p]",
(void *) DUK_HOBJECT_E_GET_VALUE(NULL, h, i).a.get,
(void *) DUK_HOBJECT_E_GET_VALUE(NULL, h, i).a.set);
} else {
tv = &DUK_HOBJECT_E_GET_VALUE(NULL, h, i).v;
duk__print_tval(st, tv);
}
if (st->heavy) {
duk_fb_sprintf(fb, "<%02lx>", (unsigned long) DUK_HOBJECT_E_GET_FLAGS(NULL, h, i));
}
}
}
if (st->internal) {
if (DUK_HOBJECT_HAS_EXTENSIBLE(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__extensible:true");
}
if (DUK_HOBJECT_HAS_CONSTRUCTABLE(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__constructable:true");
}
if (DUK_HOBJECT_HAS_BOUNDFUNC(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__boundfunc:true");
}
if (DUK_HOBJECT_HAS_COMPFUNC(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__compfunc:true");
}
if (DUK_HOBJECT_HAS_NATFUNC(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__natfunc:true");
}
if (DUK_HOBJECT_HAS_BUFOBJ(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__bufobj:true");
}
if (DUK_HOBJECT_HAS_THREAD(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__thread:true");
}
if (DUK_HOBJECT_HAS_ARRAY_PART(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__array_part:true");
}
if (DUK_HOBJECT_HAS_STRICT(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__strict:true");
}
if (DUK_HOBJECT_HAS_NOTAIL(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__notail:true");
}
if (DUK_HOBJECT_HAS_NEWENV(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__newenv:true");
}
if (DUK_HOBJECT_HAS_NAMEBINDING(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__namebinding:true");
}
if (DUK_HOBJECT_HAS_CREATEARGS(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__createargs:true");
}
if (DUK_HOBJECT_HAS_ENVRECCLOSED(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__envrecclosed:true");
}
if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__exotic_array:true");
}
if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__exotic_stringobj:true");
}
if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__exotic_arguments:true");
}
if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__exotic_dukfunc:true");
}
if (DUK_HOBJECT_IS_BUFOBJ(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__exotic_bufobj:true");
}
if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)) {
DUK__COMMA(); duk_fb_sprintf(fb, "__exotic_proxyobj:true");
}
}
if (st->internal && DUK_HOBJECT_IS_ARRAY(h)) {
duk_harray *a = (duk_harray *) h;
DUK__COMMA(); duk_fb_sprintf(fb, "__length:%ld", (long) a->length);
DUK__COMMA(); duk_fb_sprintf(fb, "__length_nonwritable:%ld", (long) a->length_nonwritable);
} else if (st->internal && DUK_HOBJECT_IS_COMPFUNC(h)) {
duk_hcompfunc *f = (duk_hcompfunc *) h;
DUK__COMMA(); duk_fb_put_cstring(fb, "__data:");
duk__print_hbuffer(st, (duk_hbuffer *) DUK_HCOMPFUNC_GET_DATA(NULL, f));
DUK__COMMA(); duk_fb_put_cstring(fb, "__lexenv:"); duk__print_hobject(st, DUK_HCOMPFUNC_GET_LEXENV(NULL, f));
DUK__COMMA(); duk_fb_put_cstring(fb, "__varenv:"); duk__print_hobject(st, DUK_HCOMPFUNC_GET_VARENV(NULL, f));
DUK__COMMA(); duk_fb_sprintf(fb, "__nregs:%ld", (long) f->nregs);
DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs);
#if defined(DUK_USE_DEBUGGER_SUPPORT)
DUK__COMMA(); duk_fb_sprintf(fb, "__start_line:%ld", (long) f->start_line);
DUK__COMMA(); duk_fb_sprintf(fb, "__end_line:%ld", (long) f->end_line);
#endif
DUK__COMMA(); duk_fb_put_cstring(fb, "__data:");
duk__print_hbuffer(st, (duk_hbuffer *) DUK_HCOMPFUNC_GET_DATA(NULL, f));
} else if (st->internal && DUK_HOBJECT_IS_NATFUNC(h)) {
duk_hnatfunc *f = (duk_hnatfunc *) h;
DUK__COMMA(); duk_fb_sprintf(fb, "__func:");
duk_fb_put_funcptr(fb, (duk_uint8_t *) &f->func, sizeof(f->func));
DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs);
DUK__COMMA(); duk_fb_sprintf(fb, "__magic:%ld", (long) f->magic);
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
} else if (st->internal && DUK_HOBJECT_IS_BUFOBJ(h)) {
duk_hbufobj *b = (duk_hbufobj *) h;
DUK__COMMA(); duk_fb_sprintf(fb, "__buf:");
duk__print_hbuffer(st, (duk_hbuffer *) b->buf);
DUK__COMMA(); duk_fb_sprintf(fb, "__buf_prop:");
duk__print_hobject(st, (duk_hobject *) b->buf_prop);
DUK__COMMA(); duk_fb_sprintf(fb, "__offset:%ld", (long) b->offset);
DUK__COMMA(); duk_fb_sprintf(fb, "__length:%ld", (long) b->length);
DUK__COMMA(); duk_fb_sprintf(fb, "__shift:%ld", (long) b->shift);
DUK__COMMA(); duk_fb_sprintf(fb, "__elemtype:%ld", (long) b->elem_type);
#endif
} else if (st->internal && DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
DUK__COMMA(); duk_fb_sprintf(fb, "__strict:%ld", (long) t->strict);
DUK__COMMA(); duk_fb_sprintf(fb, "__state:%ld", (long) t->state);
DUK__COMMA(); duk_fb_sprintf(fb, "__unused1:%ld", (long) t->unused1);
DUK__COMMA(); duk_fb_sprintf(fb, "__unused2:%ld", (long) t->unused2);
DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_max:%ld", (long) t->valstack_max);
DUK__COMMA(); duk_fb_sprintf(fb, "__callstack_max:%ld", (long) t->callstack_max);
DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_max:%ld", (long) t->catchstack_max);
DUK__COMMA(); duk_fb_sprintf(fb, "__valstack:%p", (void *) t->valstack);
DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_end:%p/%ld", (void *) t->valstack_end, (long) (t->valstack_end - t->valstack));
DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_bottom:%p/%ld", (void *) t->valstack_bottom, (long) (t->valstack_bottom - t->valstack));
DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_top:%p/%ld", (void *) t->valstack_top, (long) (t->valstack_top - t->valstack));
DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack:%p", (void *) t->catchstack);
DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_size:%ld", (long) t->catchstack_size);
DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_top:%ld", (long) t->catchstack_top);
DUK__COMMA(); duk_fb_sprintf(fb, "__resumer:"); duk__print_hobject(st, (duk_hobject *) t->resumer);
/* XXX: print built-ins array? */
}
#if defined(DUK_USE_REFERENCE_COUNTING)
if (st->internal) {
DUK__COMMA(); duk_fb_sprintf(fb, "__refcount:%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h));
}
#endif
if (st->internal) {
DUK__COMMA(); duk_fb_sprintf(fb, "__class:%ld", (long) DUK_HOBJECT_GET_CLASS_NUMBER(h));
}
DUK__COMMA(); duk_fb_sprintf(fb, "__heapptr:%p", (void *) h); /* own pointer */
/* prototype should be last, for readability */
if (DUK_HOBJECT_GET_PROTOTYPE(NULL, h)) {
if (st->follow_proto) {
DUK__COMMA(); duk_fb_put_cstring(fb, "__prototype:"); duk__print_hobject(st, DUK_HOBJECT_GET_PROTOTYPE(NULL, h));
} else {
DUK__COMMA(); duk_fb_sprintf(fb, "__prototype:%p", (void *) DUK_HOBJECT_GET_PROTOTYPE(NULL, h));
}
}
duk_fb_put_cstring(fb, brace2);
#if defined(DUK_USE_HOBJECT_HASH_PART)
if (st->heavy && DUK_HOBJECT_GET_HSIZE(h) > 0) {
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LANGLE);
for (i = 0; i < DUK_HOBJECT_GET_HSIZE(h); i++) {
duk_uint_t h_idx = DUK_HOBJECT_H_GET_INDEX(NULL, h, i);
if (i > 0) {
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COMMA);
}
if (h_idx == DUK_HOBJECT_HASHIDX_UNUSED) {
duk_fb_sprintf(fb, "u");
} else if (h_idx == DUK_HOBJECT_HASHIDX_DELETED) {
duk_fb_sprintf(fb, "d");
} else {
duk_fb_sprintf(fb, "%ld", (long) h_idx);
}
}
duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RANGLE);
}
#endif
finished:
st->depth--;
if (pushed_loopstack) {
st->loop_stack_index--;
st->loop_stack[st->loop_stack_index] = NULL;
}
}
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;
}
