/* 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;
}
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]);
}
}
}
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);
}
}
duk_ret_t duk_bi_thread_resume(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hthread *thr_resume;
duk_tval tv_tmp;
duk_tval *tv;
duk_hobject *func;
duk_small_int_t is_error;
DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T",
duk_get_tval(ctx, 0),
duk_get_tval(ctx, 1),
duk_get_tval(ctx, 2));
DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
DUK_ASSERT(thr->heap->curr_thread == thr);
thr_resume = duk_require_hthread(ctx, 0);
is_error = (duk_small_int_t) duk_to_boolean(ctx, 2);
duk_set_top(ctx, 2);
/* [ thread value ] */
/*
* Thread state and calling context checks
*/
if (thr->callstack_top < 2) {
DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)");
goto state_error;
}
DUK_ASSERT((thr->callstack + thr->callstack_top - 1)->func != NULL); /* us */
DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION((thr->callstack + thr->callstack_top - 1)->func));
DUK_ASSERT((thr->callstack + thr->callstack_top - 2)->func != NULL); /* caller */
if (!DUK_HOBJECT_IS_COMPILEDFUNCTION((thr->callstack + thr->callstack_top - 2)->func)) {
DUK_DDPRINT("resume state invalid: caller must be Ecmascript code");
goto state_error;
}
/* Note: there is no requirement that: 'thr->callstack_preventcount == 1'
* like for yield.
*/
if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE &&
thr_resume->state != DUK_HTHREAD_STATE_YIELDED) {
DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED");
goto state_error;
}
DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE ||
thr_resume->state == DUK_HTHREAD_STATE_YIELDED);
/* Further state-dependent pre-checks */
if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
/* no pre-checks now, assume a previous yield() has left things in
* tip-top shape (longjmp handler will assert for these).
*/
} else {
DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE);
if ((thr_resume->callstack_top != 0) ||
(thr_resume->valstack_top - thr_resume->valstack != 1)) {
goto state_invalid_initial;
}
tv = &thr_resume->valstack_top[-1];
DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top);
if (!DUK_TVAL_IS_OBJECT(tv)) {
goto state_invalid_initial;
}
func = DUK_TVAL_GET_OBJECT(tv);
DUK_ASSERT(func != NULL);
if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
/* Note: cannot be a bound function either right now,
* this would be easy to relax though.
*/
goto state_invalid_initial;
}
}
/*
* The error object has been augmented with a traceback and other
* info from its creation point -- usually another thread. The
* error handler is called here right before throwing, but it also
* runs in the resumer's thread. It might be nice to get a traceback
* from the resumee but this is not the case now.
*/
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
if (is_error) {
DUK_ASSERT_TOP(ctx, 2); /* value (error) is at stack top */
duk_err_augment_error_throw(thr); /* in resumer's context */
}
#endif
#ifdef DUK_USE_DEBUG /* debug logging */
if (is_error) {
DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T",
duk_get_tval(ctx, 0),
duk_get_tval(ctx, 1));
} else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T",
duk_get_tval(ctx, 0),
duk_get_tval(ctx, 1));
} else {
DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T",
duk_get_tval(ctx, 0),
duk_get_tval(ctx, 1));
}
#endif
thr->heap->lj.type = DUK_LJ_TYPE_RESUME;
/* lj value2: thread */
DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2);
DUK_TVAL_SET_TVAL(&thr->heap->lj.value2, &thr->valstack_bottom[0]);
DUK_TVAL_INCREF(thr, &thr->heap->lj.value2);
DUK_TVAL_DECREF(thr, &tv_tmp);
/* lj value1: value */
DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top);
DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[1]);
DUK_TVAL_INCREF(thr, &thr->heap->lj.value1);
DUK_TVAL_DECREF(thr, &tv_tmp);
thr->heap->lj.iserror = is_error;
DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* call is from executor, so we know we have a jmpbuf */
duk_err_longjmp(thr); /* execution resumes in bytecode executor */
return 0; /* never here */
state_invalid_initial:
DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid initial thread state/stack");
return 0; /* never here */
state_error:
DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid state for resume");
return 0; /* never here */
}
duk_ret_t duk_bi_thread_yield(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_tval tv_tmp;
duk_small_int_t is_error;
DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T",
duk_get_tval(ctx, 0),
duk_get_tval(ctx, 1));
DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
DUK_ASSERT(thr->heap->curr_thread == thr);
is_error = (duk_small_int_t) duk_to_boolean(ctx, 1);
duk_set_top(ctx, 1);
/* [ value ] */
/*
* Thread state and calling context checks
*/
if (!thr->resumer) {
DUK_DDPRINT("yield state invalid: current thread must have a resumer");
goto state_error;
}
DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
if (thr->callstack_top < 2) {
DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)");
goto state_error;
}
DUK_ASSERT((thr->callstack + thr->callstack_top - 1)->func != NULL); /* us */
DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION((thr->callstack + thr->callstack_top - 1)->func));
DUK_ASSERT((thr->callstack + thr->callstack_top - 2)->func != NULL); /* caller */
if (!DUK_HOBJECT_IS_COMPILEDFUNCTION((thr->callstack + thr->callstack_top - 2)->func)) {
DUK_DDPRINT("yield state invalid: caller must be Ecmascript code");
goto state_error;
}
DUK_ASSERT(thr->callstack_preventcount >= 1); /* should never be zero, because we (Duktape.Thread.yield) are on the stack */
if (thr->callstack_preventcount != 1) {
/* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */
DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %d)",
(int) thr->callstack_preventcount);
goto state_error;
}
/*
* The error object has been augmented with a traceback and other
* info from its creation point -- usually the current thread.
* The error handler, however, is called right before throwing
* and runs in the yielder's thread.
*/
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
if (is_error) {
DUK_ASSERT_TOP(ctx, 1); /* value (error) is at stack top */
duk_err_augment_error_throw(thr); /* in yielder's context */
}
#endif
#ifdef DUK_USE_DEBUG
if (is_error) {
DUK_DDDPRINT("YIELD ERROR: value=%!T",
duk_get_tval(ctx, 0));
} else {
DUK_DDDPRINT("YIELD NORMAL: value=%!T",
duk_get_tval(ctx, 0));
}
#endif
/*
* Process yield
*
* After longjmp(), processing continues in bytecode executor longjmp
* handler, which will e.g. update thr->resumer to NULL.
*/
thr->heap->lj.type = DUK_LJ_TYPE_YIELD;
/* lj value1: value */
DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[0]);
DUK_TVAL_INCREF(thr, &thr->heap->lj.value1);
DUK_TVAL_DECREF(thr, &tv_tmp);
thr->heap->lj.iserror = is_error;
DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL); /* call is from executor, so we know we have a jmpbuf */
duk_err_longjmp(thr); /* execution resumes in bytecode executor */
return 0; /* never here */
state_error:
DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid state for yield");
return 0; /* never here */
}
/* 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_INTERNAL void duk_debug_dump_hobject(duk_hobject *obj) {
duk_uint_fast32_t i;
const char *str_empty = "";
const char *str_excl = "!";
DUK_UNREF(str_empty);
DUK_UNREF(str_excl);
DUK_UNREF(duk__class_names);
DUK_D(DUK_DPRINT("=== hobject %p ===", (void *) obj));
if (!obj) {
return;
}
DUK_D(DUK_DPRINT(" %sextensible", (const char *) (DUK_HOBJECT_HAS_EXTENSIBLE(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sconstructable", (const char *) (DUK_HOBJECT_HAS_CONSTRUCTABLE(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sbound", (const char *) (DUK_HOBJECT_HAS_BOUND(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %scompiledfunction", (const char *) (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %snativefunction", (const char *) (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sthread", (const char *) (DUK_HOBJECT_HAS_THREAD(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sarray_part", (const char *) (DUK_HOBJECT_HAS_ARRAY_PART(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sstrict", (const char *) (DUK_HOBJECT_HAS_STRICT(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %snewenv", (const char *) (DUK_HOBJECT_HAS_NEWENV(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %snamebinding", (const char *) (DUK_HOBJECT_HAS_NAMEBINDING(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %screateargs", (const char *) (DUK_HOBJECT_HAS_CREATEARGS(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %senvrecclosed", (const char *) (DUK_HOBJECT_HAS_ENVRECCLOSED(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sexotic_array", (const char *) (DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sexotic_stringobj", (const char *) (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sexotic_arguments", (const char *) (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sexotic_dukfunc", (const char *) (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sexotic_bufferobj", (const char *) (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" %sexotic_proxyobj", (const char *) (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj) ? str_empty : str_excl)));
DUK_D(DUK_DPRINT(" class: number %ld -> %s",
(long) DUK_HOBJECT_GET_CLASS_NUMBER(obj),
(const char *) (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=%ld, e_next=%ld, a_size=%ld, h_size=%ld",
(void *) obj->p,
(long) obj->e_size,
(long) obj->e_next,
(long) obj->a_size,
(long) 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", (duk_heaphdr *) h->data));
DUK_D(DUK_DPRINT(" nregs: %ld", (long) h->nregs));
DUK_D(DUK_DPRINT(" nargs: %ld", (long) h->nargs));
if (h->data && DUK_HBUFFER_HAS_DYNAMIC(h->data) && DUK_HBUFFER_GET_DATA_PTR(h->data)) {
DUK_D(DUK_DPRINT(" consts: %p (%ld, %ld bytes)",
(void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(h),
(long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(h),
(long) DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(h)));
DUK_D(DUK_DPRINT(" funcs: %p (%ld, %ld bytes)",
(void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(h),
(long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(h),
(long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(h)));
DUK_D(DUK_DPRINT(" bytecode: %p (%ld, %ld bytes)",
(void *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(h),
(long) DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(h),
(long) 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_UNREF(h);
DUK_D(DUK_DPRINT(" hnativefunction"));
/* XXX: h->func, cannot print function pointers portably */
DUK_D(DUK_DPRINT(" nargs: %ld", (long) 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: %ld", (long) thr->strict));
DUK_D(DUK_DPRINT(" state: %ld", (long) thr->state));
DUK_D(DUK_DPRINT(" valstack_max: %ld, callstack_max: %ld, catchstack_max: %ld",
(long) thr->valstack_max, (long) thr->callstack_max, (long) thr->catchstack_max));
DUK_D(DUK_DPRINT(" callstack: ptr %p, size %ld, top %ld, preventcount %ld, used size %ld entries (%ld bytes), alloc size %ld entries (%ld bytes)",
(void *) thr->callstack,
(long) thr->callstack_size,
(long) thr->callstack_top,
(long) thr->callstack_preventcount,
(long) thr->callstack_top,
(long) (thr->callstack_top * sizeof(duk_activation)),
(long) thr->callstack_size,
(long) (thr->callstack_size * sizeof(duk_activation))));
DUK_DEBUG_SUMMARY_INIT();
DUK_DEBUG_SUMMARY_CHAR('[');
for (i = 0; i <= (duk_uint_fast32_t) 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 (%ld), bottom %p (%ld), top %p (%ld), used size %ld entries (%ld bytes), alloc size %ld entries (%ld bytes)",
(void *) thr->valstack,
(void *) thr->valstack_end,
(long) (thr->valstack_end - thr->valstack),
(void *) thr->valstack_bottom,
(long) (thr->valstack_bottom - thr->valstack),
(void *) thr->valstack_top,
(long) (thr->valstack_top - thr->valstack),
(long) (thr->valstack_top - thr->valstack),
(long) (thr->valstack_top - thr->valstack) * sizeof(duk_tval),
(long) (thr->valstack_end - thr->valstack),
(long) (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 %ld, top %ld, used size %ld entries (%ld bytes), alloc size %ld entries (%ld bytes)",
(void *) thr->catchstack,
(long) thr->catchstack_size,
(long) thr->catchstack_top,
(long) thr->catchstack_top,
(long) (thr->catchstack_top * sizeof(duk_catcher)),
(long) thr->catchstack_size,
(long) (thr->catchstack_size * sizeof(duk_catcher))));
DUK_DEBUG_SUMMARY_INIT();
DUK_DEBUG_SUMMARY_CHAR('[');
for (i = 0; i <= (duk_uint_fast32_t) 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[%ld] -> %!@O", (long) i, (duk_heaphdr *) thr->builtins[i]));
}
#endif
}
if (obj->p) {
DUK_D(DUK_DPRINT(" props alloc size: %ld",
(long) 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 < (duk_uint_fast32_t) 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);
DUK_UNREF(v);
if (i >= obj->e_next) {
DUK_D(DUK_DPRINT(" [%ld]: UNUSED", (long) i));
continue;
}
if (!k) {
DUK_D(DUK_DPRINT(" [%ld]: NULL", (long) i));
continue;
}
if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(obj, i)) {
DUK_D(DUK_DPRINT(" [%ld]: [w=%ld e=%ld c=%ld a=%ld] %!O -> get:%p set:%p; get %!O; set %!O",
(long) i,
(long) (DUK_HOBJECT_E_SLOT_IS_WRITABLE(obj, i) ? 1 : 0),
(long) (DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(obj, i) ? 1 : 0),
(long) (DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(obj, i) ? 1 : 0),
(long) (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(obj, i) ? 1 : 0),
(duk_heaphdr *) k,
(void *) v->a.get,
(void *) v->a.set,
(duk_heaphdr *) v->a.get,
(duk_heaphdr *) v->a.set));
} else {
DUK_D(DUK_DPRINT(" [%ld]: [w=%ld e=%ld c=%ld a=%ld] %!O -> %!T",
(long) i,
(long) (DUK_HOBJECT_E_SLOT_IS_WRITABLE(obj, i) ? 1 : 0),
(long) (DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(obj, i) ? 1 : 0),
(long) (DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(obj, i) ? 1 : 0),
(long) (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(obj, i) ? 1 : 0),
(duk_heaphdr *) k,
(duk_tval *) &v->v));
}
}
DUK_D(DUK_DPRINT(" array entries:"));
for (i = 0; i < (duk_uint_fast32_t) obj->a_size; i++) {
DUK_D(DUK_DPRINT(" [%ld]: [w=%ld e=%ld c=%ld a=%ld] %ld -> %!T",
(long) i,
(long) 1, /* implicit attributes */
(long) 1,
(long) 1,
(long) 0,
(long) i,
(duk_tval *) DUK_HOBJECT_A_GET_VALUE_PTR(obj, i)));
}
DUK_D(DUK_DPRINT(" hash entries:"));
for (i = 0; i < (duk_uint_fast32_t) 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(" [%ld]: unused", (long) i));
} else if (t == DUK_HOBJECT_HASHIDX_DELETED) {
DUK_D(DUK_DPRINT(" [%ld]: deleted", (long) i));
} else {
DUK_D(DUK_DPRINT(" [%ld]: %ld", (long) i, (long) t));
}
}
}