static void duk__free_hobject_inner(duk_heap *heap, duk_hobject *h) {
DUK_ASSERT(heap != NULL);
DUK_ASSERT(h != NULL);
DUK_FREE(heap, h->p);
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
DUK_UNREF(f);
/* Currently nothing to free; 'data' is a heap object */
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
duk_hnativefunction *f = (duk_hnativefunction *) h;
DUK_UNREF(f);
/* Currently nothing to free */
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
DUK_FREE(heap, t->valstack);
DUK_FREE(heap, t->callstack);
DUK_FREE(heap, t->catchstack);
/* Don't free h->resumer because it exists in the heap.
* Callstack entries also contain function pointers which
* are not freed for the same reason.
*/
/* XXX: with 'caller' property the callstack would need
* to be unwound to update the 'caller' properties of
* functions in the callstack.
*/
}
}
/* for thread dumping */
static char duk__get_tval_summary_char(duk_tval *tv) {
switch (DUK_TVAL_GET_TAG(tv)) {
case DUK_TAG_UNDEFINED:
if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
return '.';
}
return 'u';
case DUK_TAG_NULL:
return 'n';
case DUK_TAG_BOOLEAN:
return 'b';
case DUK_TAG_STRING:
return 's';
case DUK_TAG_OBJECT: {
duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
if (DUK_HOBJECT_IS_ARRAY(h)) {
return 'A';
} else if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
return 'C';
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
return 'N';
} else if (DUK_HOBJECT_IS_THREAD(h)) {
return 'T';
}
return 'O';
}
case DUK_TAG_BUFFER: {
return 'B';
}
case DUK_TAG_POINTER: {
return 'P';
}
default:
DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
return 'd';
}
DUK_UNREACHABLE();
}
static void free_hobject_inner(duk_heap *heap, duk_hobject *h) {
DUK_ASSERT(heap != NULL);
DUK_ASSERT(h != NULL);
DUK_FREE(heap, h->p);
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
DUK_UNREF(f);
/* Currently nothing to free; 'data' is a heap object */
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
duk_hnativefunction *f = (duk_hnativefunction *) h;
DUK_UNREF(f);
/* Currently nothing to free */
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
DUK_FREE(heap, t->valstack);
DUK_FREE(heap, t->callstack);
DUK_FREE(heap, t->catchstack);
/* don't free h->resumer, because it exists in the heap */
}
}
void duk_debug_dump_hobject(duk_hobject *obj) {
duk_uint_fast32_t i;
const char *str_empty = "";
const char *str_excl = "!";
DUK_D(DUK_DPRINT("=== hobject %p ===", (void *) obj));
if (!obj) {
return;
}
DUK_D(DUK_DPRINT(" %sextensible", DUK_HOBJECT_HAS_EXTENSIBLE(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sconstructable", DUK_HOBJECT_HAS_CONSTRUCTABLE(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sbound", DUK_HOBJECT_HAS_BOUND(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %scompiledfunction", DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %snativefunction", DUK_HOBJECT_HAS_NATIVEFUNCTION(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sthread", DUK_HOBJECT_HAS_THREAD(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sarray_part", DUK_HOBJECT_HAS_ARRAY_PART(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sstrict", DUK_HOBJECT_HAS_STRICT(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %snewenv", DUK_HOBJECT_HAS_NEWENV(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %snamebinding", DUK_HOBJECT_HAS_NAMEBINDING(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %screateargs", DUK_HOBJECT_HAS_CREATEARGS(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %senvrecclosed", DUK_HOBJECT_HAS_ENVRECCLOSED(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sexotic_array", DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sexotic_stringobj", DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sexotic_arguments", DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sexotic_dukfunc", DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sexotic_bufferobj", DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" %sexotic_proxyobj", DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj) ? str_empty : str_excl));
DUK_D(DUK_DPRINT(" class: number %d -> %s",
(int) DUK_HOBJECT_GET_CLASS_NUMBER(obj),
duk__class_names[(DUK_HOBJECT_GET_CLASS_NUMBER(obj)) & ((1 << DUK_HOBJECT_FLAG_CLASS_BITS) - 1)]));
DUK_D(DUK_DPRINT(" prototype: %p -> %!O",
(void *) obj->prototype,
(duk_heaphdr *) obj->prototype));
DUK_D(DUK_DPRINT(" props: p=%p, e_size=%d, e_used=%d, a_size=%d, h_size=%d",
(void *) obj->p,
(int) obj->e_size,
(int) obj->e_used,
(int) obj->a_size,
(int) obj->h_size));
/*
* Object (struct layout) specific dumping. Inline code here
* instead of helpers, to ensure debug line prefix is identical.
*/
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(obj)) {
duk_hcompiledfunction *h = (duk_hcompiledfunction *) obj;
DUK_D(DUK_DPRINT(" hcompiledfunction"));
DUK_D(DUK_DPRINT(" data: %!O", h->data));
DUK_D(DUK_DPRINT(" nregs: %d", (int) h->nregs));
DUK_D(DUK_DPRINT(" nargs: %d", (int) h->nargs));
if (h->data && DUK_HBUFFER_HAS_DYNAMIC(h->data) && DUK_HBUFFER_GET_DATA_PTR(h->data)) {
DUK_D(DUK_DPRINT(" consts: %p (%d, %d bytes)",
(void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(h),
(int) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(h),
(int) DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(h)));
DUK_D(DUK_DPRINT(" funcs: %p (%d, %d bytes)",
(void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(h),
(int) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(h),
(int) DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(h)));
DUK_D(DUK_DPRINT(" bytecode: %p (%d, %d bytes)",
(void *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(h),
(int) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(h),
(int) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(h)));
} else {
DUK_D(DUK_DPRINT(" consts: ???"));
DUK_D(DUK_DPRINT(" funcs: ???"));
DUK_D(DUK_DPRINT(" bytecode: ???"));
}
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(obj)) {
duk_hnativefunction *h = (duk_hnativefunction *) obj;
DUK_D(DUK_DPRINT(" hnativefunction"));
/* XXX: h->func, cannot print function pointers portably */
DUK_D(DUK_DPRINT(" nargs: %d", (int) h->nargs));
} else if (DUK_HOBJECT_IS_THREAD(obj)) {
duk_hthread *thr = (duk_hthread *) obj;
duk_tval *p;
DUK_D(DUK_DPRINT(" hthread"));
DUK_D(DUK_DPRINT(" strict: %d", (int) thr->strict));
DUK_D(DUK_DPRINT(" state: %d", (int) thr->state));
DUK_D(DUK_DPRINT(" valstack_max: %d, callstack_max:%d, catchstack_max: %d",
thr->valstack_max, thr->callstack_max, thr->catchstack_max));
DUK_D(DUK_DPRINT(" callstack: ptr %p, size %d, top %d, preventcount %d, used size %d entries (%d bytes), alloc size %d entries (%d bytes)",
(void *) thr->callstack,
thr->callstack_size,
thr->callstack_top,
thr->callstack_preventcount,
thr->callstack_top,
thr->callstack_top * sizeof(duk_activation),
thr->callstack_size,
thr->callstack_size * sizeof(duk_activation)));
DUK_DEBUG_SUMMARY_INIT();
DUK_DEBUG_SUMMARY_CHAR('[');
for (i = 0; i <= thr->callstack_size; i++) {
if (i == thr->callstack_top) {
DUK_DEBUG_SUMMARY_CHAR('|');
}
if (!thr->callstack) {
DUK_DEBUG_SUMMARY_CHAR('@');
} else if (i < thr->callstack_size) {
if (i < thr->callstack_top) {
/* tailcalling is nice to see immediately; other flags (e.g. strict)
* not that important.
*/
if (thr->callstack[i].flags & DUK_ACT_FLAG_TAILCALLED) {
DUK_DEBUG_SUMMARY_CHAR('/');
}
DUK_DEBUG_SUMMARY_CHAR(duk__get_act_summary_char(&thr->callstack[i]));
} else {
DUK_DEBUG_SUMMARY_CHAR('.');
}
}
}
DUK_DEBUG_SUMMARY_CHAR(']');
DUK_DEBUG_SUMMARY_FINISH();
DUK_D(DUK_DPRINT(" valstack: ptr %p, end %p (%d), bottom %p (%d), top %p (%d), used size %d entries (%d bytes), alloc size %d entries (%d bytes)",
(void *) thr->valstack,
(void *) thr->valstack_end,
(int) (thr->valstack_end - thr->valstack),
(void *) thr->valstack_bottom,
(int) (thr->valstack_bottom - thr->valstack),
(void *) thr->valstack_top,
(int) (thr->valstack_top - thr->valstack),
(int) (thr->valstack_top - thr->valstack),
(int) (thr->valstack_top - thr->valstack) * sizeof(duk_tval),
(int) (thr->valstack_end - thr->valstack),
(int) (thr->valstack_end - thr->valstack) * sizeof(duk_tval)));
DUK_DEBUG_SUMMARY_INIT();
DUK_DEBUG_SUMMARY_CHAR('[');
p = thr->valstack;
while (p <= thr->valstack_end) {
i = (duk_uint_fast32_t) (p - thr->valstack);
if (thr->callstack &&
thr->callstack_top > 0 &&
i == (duk_size_t) (thr->callstack + thr->callstack_top - 1)->idx_bottom) {
DUK_DEBUG_SUMMARY_CHAR('>');
}
if (p == thr->valstack_top) {
DUK_DEBUG_SUMMARY_CHAR('|');
}
if (p < thr->valstack_end) {
if (p < thr->valstack_top) {
DUK_DEBUG_SUMMARY_CHAR(duk__get_tval_summary_char(p));
} else {
/* XXX: safe printer for these? would be nice, because
* we could visualize whether the values are in proper
* state.
*/
DUK_DEBUG_SUMMARY_CHAR('.');
}
}
p++;
}
DUK_DEBUG_SUMMARY_CHAR(']');
DUK_DEBUG_SUMMARY_FINISH();
DUK_D(DUK_DPRINT(" catchstack: ptr %p, size %d, top %d, used size %d entries (%d bytes), alloc size %d entries (%d bytes)",
(void *) thr->catchstack,
thr->catchstack_size,
thr->catchstack_top,
thr->catchstack_top,
thr->catchstack_top * sizeof(duk_catcher),
thr->catchstack_size,
thr->catchstack_size * sizeof(duk_catcher)));
DUK_DEBUG_SUMMARY_INIT();
DUK_DEBUG_SUMMARY_CHAR('[');
for (i = 0; i <= thr->catchstack_size; i++) {
if (i == thr->catchstack_top) {
DUK_DEBUG_SUMMARY_CHAR('|');
}
if (!thr->catchstack) {
DUK_DEBUG_SUMMARY_CHAR('@');
} else if (i < thr->catchstack_size) {
if (i < thr->catchstack_top) {
DUK_DEBUG_SUMMARY_CHAR(duk__get_cat_summary_char(&thr->catchstack[i]));
} else {
DUK_DEBUG_SUMMARY_CHAR('.');
}
}
}
DUK_DEBUG_SUMMARY_CHAR(']');
DUK_DEBUG_SUMMARY_FINISH();
DUK_D(DUK_DPRINT(" resumer: ptr %p",
(void *) thr->resumer));
#if 0 /* worth dumping? */
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
DUK_D(DUK_DPRINT(" builtins[%d] -> %!@O", i, thr->builtins[i]));
}
#endif
}
if (obj->p) {
DUK_D(DUK_DPRINT(" props alloc size: %d",
(int) DUK_HOBJECT_P_COMPUTE_SIZE(obj->e_size, obj->a_size, obj->h_size)));
} else {
DUK_D(DUK_DPRINT(" props alloc size: n/a"));
}
DUK_D(DUK_DPRINT(" prop entries:"));
for (i = 0; i < obj->e_size; i++) {
duk_hstring *k;
duk_propvalue *v;
k = DUK_HOBJECT_E_GET_KEY(obj, i);
v = DUK_HOBJECT_E_GET_VALUE_PTR(obj, i);
if (i >= obj->e_used) {
DUK_D(DUK_DPRINT(" [%d]: UNUSED", i));
continue;
}
if (!k) {
DUK_D(DUK_DPRINT(" [%d]: NULL", i));
continue;
}
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(obj, i)) {
DUK_D(DUK_DPRINT(" [%d]: [w=%d e=%d c=%d a=%d] %!O -> get:%p set:%p; get %!O; set %!O",
i,
DUK_HOBJECT_E_SLOT_IS_WRITABLE(obj, i),
DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(obj, i),
DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(obj, i),
DUK_HOBJECT_E_SLOT_IS_ACCESSOR(obj, i),
k,
(void *) v->a.get,
(void *) v->a.set,
(duk_heaphdr *) v->a.get,
(duk_heaphdr *) v->a.set));
} else {
DUK_D(DUK_DPRINT(" [%d]: [w=%d e=%d c=%d a=%d] %!O -> %!T",
i,
DUK_HOBJECT_E_SLOT_IS_WRITABLE(obj, i),
DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(obj, i),
DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(obj, i),
DUK_HOBJECT_E_SLOT_IS_ACCESSOR(obj, i),
k,
&v->v));
}
}
DUK_D(DUK_DPRINT(" array entries:"));
for (i = 0; i < obj->a_size; i++) {
DUK_D(DUK_DPRINT(" [%d]: [w=%d e=%d c=%d a=%d] %d -> %!T",
i,
1, /* implicit attributes */
1,
1,
0,
i,
DUK_HOBJECT_A_GET_VALUE_PTR(obj, i)));
}
DUK_D(DUK_DPRINT(" hash entries:"));
for (i = 0; i < obj->h_size; i++) {
duk_uint32_t t = DUK_HOBJECT_H_GET_INDEX(obj, i);
if (t == DUK_HOBJECT_HASHIDX_UNUSED) {
DUK_D(DUK_DPRINT(" [%d]: unused", i));
} else if (t == DUK_HOBJECT_HASHIDX_DELETED) {
DUK_D(DUK_DPRINT(" [%d]: deleted", i));
} else {
DUK_D(DUK_DPRINT(" [%d]: %d",
i,
(int) t));
}
}
}
/* 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;
}
DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h) {
duk_uint_fast32_t i;
DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h));
DUK_ASSERT(h);
/* XXX: use advancing pointers instead of index macros -> faster and smaller? */
for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
duk_hstring *key = DUK_HOBJECT_E_GET_KEY(heap, h, i);
if (!key) {
continue;
}
duk__mark_heaphdr(heap, (duk_heaphdr *) key);
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) {
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get);
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set);
} else {
duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v);
}
}
for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
duk__mark_tval(heap, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i));
}
/* hash part is a 'weak reference' and does not contribute */
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h));
/* XXX: rearrange bits to allow a switch case to be used here? */
/* XXX: add a fast path for objects (and arrays)? */
/* DUK_HOBJECT_IS_ARRAY(h): needs no special handling now as there are
* no extra fields in need of marking.
*/
if (DUK_HOBJECT_IS_COMPFUNC(h)) {
duk_hcompfunc *f = (duk_hcompfunc *) h;
duk_tval *tv, *tv_end;
duk_hobject **fn, **fn_end;
/* 'data' is reachable through every compiled function which
* contains a reference.
*/
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPFUNC_GET_DATA(heap, f));
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPFUNC_GET_LEXENV(heap, f));
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPFUNC_GET_VARENV(heap, f));
if (DUK_HCOMPFUNC_GET_DATA(heap, f) != NULL) {
tv = DUK_HCOMPFUNC_GET_CONSTS_BASE(heap, f);
tv_end = DUK_HCOMPFUNC_GET_CONSTS_END(heap, f);
while (tv < tv_end) {
duk__mark_tval(heap, tv);
tv++;
}
fn = DUK_HCOMPFUNC_GET_FUNCS_BASE(heap, f);
fn_end = DUK_HCOMPFUNC_GET_FUNCS_END(heap, f);
while (fn < fn_end) {
duk__mark_heaphdr(heap, (duk_heaphdr *) *fn);
fn++;
}
} else {
/* May happen in some out-of-memory corner cases. */
DUK_D(DUK_DPRINT("duk_hcompfunc 'data' is NULL, skipping marking"));
}
} else if (DUK_HOBJECT_IS_NATFUNC(h)) {
duk_hnatfunc *f = (duk_hnatfunc *) h;
DUK_UNREF(f);
/* nothing to mark */
#if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
} else if (DUK_HOBJECT_IS_BUFOBJ(h)) {
duk_hbufobj *b = (duk_hbufobj *) h;
duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf);
duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf_prop);
#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
duk_tval *tv;
tv = t->valstack;
while (tv < t->valstack_top) {
duk__mark_tval(heap, tv);
tv++;
}
for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
duk_activation *act = t->callstack + i;
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env);
duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env);
#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller);
#endif
}
#if 0 /* nothing now */
for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) {
duk_catcher *cat = t->catchstack + i;
}
#endif
duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer);
/* XXX: duk_small_uint_t would be enough for this loop */
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]);
}
}
}
static void duk__refcount_finalize_hobject(duk_hthread *thr, duk_hobject *h) {
duk_uint_fast32_t i;
DUK_ASSERT(h);
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h) == DUK_HTYPE_OBJECT);
/* XXX: better to get base and walk forwards? */
for (i = 0; i < (duk_uint_fast32_t) h->e_next; i++) {
duk_hstring *key = DUK_HOBJECT_E_GET_KEY(h, i);
if (!key) {
continue;
}
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) key);
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(h, i)) {
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_GETTER(h, i));
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_SETTER(h, i));
} else {
duk_heap_tval_decref(thr, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(h, i));
}
}
for (i = 0; i < (duk_uint_fast32_t) h->a_size; i++) {
duk_heap_tval_decref(thr, DUK_HOBJECT_A_GET_VALUE_PTR(h, i));
}
/* hash part is a 'weak reference' and does not contribute */
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) h->prototype);
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
duk_tval *tv, *tv_end;
duk_hobject **funcs, **funcs_end;
DUK_ASSERT(f->data != NULL); /* compiled functions must be created 'atomically' */
tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(f);
tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(f);
while (tv < tv_end) {
duk_heap_tval_decref(thr, tv);
tv++;
}
funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(f);
funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(f);
while (funcs < funcs_end) {
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) *funcs);
funcs++;
}
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) f->data);
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
duk_hnativefunction *f = (duk_hnativefunction *) h;
DUK_UNREF(f);
/* nothing to finalize */
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
duk_tval *tv;
tv = t->valstack;
while (tv < t->valstack_end) {
duk_heap_tval_decref(thr, tv);
tv++;
}
for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
duk_activation *act = t->callstack + i;
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) act->func);
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) act->var_env);
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) act->lex_env);
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) act->prev_caller);
#endif
}
#if 0 /* nothing now */
for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) {
duk_catcher *cat = t->catchstack + i;
}
#endif
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) t->builtins[i]);
}
duk_heap_heaphdr_decref(thr, (duk_heaphdr *) t->resumer);
}
}
static void duk__mark_hobject(duk_heap *heap, duk_hobject *h) {
duk_uint_fast32_t i;
DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h));
DUK_ASSERT(h);
/* XXX: use advancing pointers instead of index macros -> faster and smaller? */
for (i = 0; i < h->e_used; i++) {
duk_hstring *key = DUK_HOBJECT_E_GET_KEY(h, i);
if (!key) {
continue;
}
duk__mark_heaphdr(heap, (duk_heaphdr *) key);
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(h, i)) {
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(h, i)->a.get);
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(h, i)->a.set);
} else {
duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(h, i)->v);
}
}
for (i = 0; i < h->a_size; i++) {
duk__mark_tval(heap, DUK_HOBJECT_A_GET_VALUE_PTR(h, i));
}
/* hash part is a 'weak reference' and does not contribute */
duk__mark_heaphdr(heap, (duk_heaphdr *) h->prototype);
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
duk_tval *tv, *tv_end;
duk_hobject **funcs, **funcs_end;
/* 'data' is reachable through every compiled function which
* contains a reference.
*/
duk__mark_heaphdr(heap, (duk_heaphdr *) f->data);
tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(f);
tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(f);
while (tv < tv_end) {
duk__mark_tval(heap, tv);
tv++;
}
funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(f);
funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(f);
while (funcs < funcs_end) {
duk__mark_heaphdr(heap, (duk_heaphdr *) *funcs);
funcs++;
}
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
duk_hnativefunction *f = (duk_hnativefunction *) h;
DUK_UNREF(f);
/* nothing to mark */
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
duk_tval *tv;
tv = t->valstack;
while (tv < t->valstack_end) {
duk__mark_tval(heap, tv);
tv++;
}
for (i = 0; i < t->callstack_top; i++) {
duk_activation *act = &t->callstack[i];
duk__mark_heaphdr(heap, (duk_heaphdr *) act->func);
duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env);
duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env);
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller);
#endif
}
#if 0 /* nothing now */
for (i = 0; i < t->catchstack_top; i++) {
duk_catcher *cat = &t->catchstack[i];
}
#endif
duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer);
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]);
}
}
}
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;
}
}
/* 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__mark_hobject(duk_heap *heap, duk_hobject *h) {
duk_uint_fast32_t i;
DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h));
DUK_ASSERT(h);
/* XXX: use advancing pointers instead of index macros -> faster and smaller? */
for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
duk_hstring *key = DUK_HOBJECT_E_GET_KEY(heap, h, i);
if (!key) {
continue;
}
duk__mark_heaphdr(heap, (duk_heaphdr *) key);
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) {
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get);
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set);
} else {
duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v);
}
}
for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
duk__mark_tval(heap, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i));
}
/* hash part is a 'weak reference' and does not contribute */
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h));
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
duk_tval *tv, *tv_end;
duk_hobject **fn, **fn_end;
/* 'data' is reachable through every compiled function which
* contains a reference.
*/
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(heap, f));
tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, f);
tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, f);
while (tv < tv_end) {
duk__mark_tval(heap, tv);
tv++;
}
fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, f);
fn_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f);
while (fn < fn_end) {
duk__mark_heaphdr(heap, (duk_heaphdr *) *fn);
fn++;
}
} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
duk_hnativefunction *f = (duk_hnativefunction *) h;
DUK_UNREF(f);
/* nothing to mark */
} else if (DUK_HOBJECT_IS_BUFFEROBJECT(h)) {
duk_hbufferobject *b = (duk_hbufferobject *) h;
duk__mark_heaphdr(heap, (duk_heaphdr *) b->buf);
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
duk_tval *tv;
tv = t->valstack;
while (tv < t->valstack_top) {
duk__mark_tval(heap, tv);
tv++;
}
for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
duk_activation *act = t->callstack + i;
duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env);
duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env);
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller);
#endif
}
#if 0 /* nothing now */
for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) {
duk_catcher *cat = t->catchstack + i;
}
#endif
duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer);
/* XXX: duk_small_uint_t would be enough for this loop */
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]);
}
}
}
DUK_LOCAL void duk__refcount_finalize_hobject(duk_hthread *thr, duk_hobject *h) {
duk_uint_fast32_t i;
DUK_ASSERT(h);
DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h) == DUK_HTYPE_OBJECT);
/* XXX: better to get base and walk forwards? */
for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
duk_hstring *key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
if (!key) {
continue;
}
duk_heaphdr_decref(thr, (duk_heaphdr *) key);
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)) {
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, h, i));
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, h, i));
} else {
duk_tval_decref(thr, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i));
}
}
for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
duk_tval_decref(thr, DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i));
}
/* hash part is a 'weak reference' and does not contribute */
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h));
/* XXX: rearrange bits to allow a switch case to be used here? */
/* XXX: add a fast path for objects (and arrays)? */
/* DUK_HOBJECT_IS_ARRAY(h): needs no special handling now as there are
* no extra fields in need of decref.
*/
if (DUK_HOBJECT_IS_COMPFUNC(h)) {
duk_hcompfunc *f = (duk_hcompfunc *) h;
duk_tval *tv, *tv_end;
duk_hobject **funcs, **funcs_end;
DUK_ASSERT(DUK_HCOMPFUNC_GET_DATA(thr->heap, f) != NULL); /* compiled functions must be created 'atomically' */
tv = DUK_HCOMPFUNC_GET_CONSTS_BASE(thr->heap, f);
tv_end = DUK_HCOMPFUNC_GET_CONSTS_END(thr->heap, f);
while (tv < tv_end) {
duk_tval_decref(thr, tv);
tv++;
}
funcs = DUK_HCOMPFUNC_GET_FUNCS_BASE(thr->heap, f);
funcs_end = DUK_HCOMPFUNC_GET_FUNCS_END(thr->heap, f);
while (funcs < funcs_end) {
duk_heaphdr_decref(thr, (duk_heaphdr *) *funcs);
funcs++;
}
duk_heaphdr_decref(thr, (duk_heaphdr *) DUK_HCOMPFUNC_GET_DATA(thr->heap, f));
} else if (DUK_HOBJECT_IS_NATFUNC(h)) {
duk_hnatfunc *f = (duk_hnatfunc *) h;
DUK_UNREF(f);
/* nothing to finalize */
} else if (DUK_HOBJECT_IS_BUFOBJ(h)) {
duk_hbufobj *b = (duk_hbufobj *) h;
if (b->buf) {
duk_heaphdr_decref(thr, (duk_heaphdr *) b->buf);
}
} else if (DUK_HOBJECT_IS_THREAD(h)) {
duk_hthread *t = (duk_hthread *) h;
duk_tval *tv;
tv = t->valstack;
while (tv < t->valstack_top) {
duk_tval_decref(thr, tv);
tv++;
}
for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
duk_activation *act = t->callstack + i;
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->var_env);
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->lex_env);
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->prev_caller);
#endif
}
#if 0 /* nothing now */
for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) {
duk_catcher *cat = t->catchstack + i;
}
#endif
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->builtins[i]);
}
duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->resumer);
}
}
