static void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, const char *filename, duk_int_t line, duk_bool_t noblame_fileline) {
duk_context *ctx = (duk_context *) thr;
duk_small_uint_t depth;
duk_int_t i, i_min;
duk_uarridx_t arr_idx;
duk_double_t d;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr_callstack != NULL);
DUK_ASSERT(ctx != NULL);
/* [ ... error ] */
/*
* The traceback format is pretty arcane in an attempt to keep it compact
* and cheap to create. It may change arbitrarily from version to version.
* It should be decoded/accessed through version specific accessors only.
*
* See doc/error-objects.txt.
*/
DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
(duk_tval *) duk_get_tval(ctx, -1)));
duk_push_array(ctx); /* XXX: specify array size, as we know it */
arr_idx = 0;
/* filename/line from C macros (__FILE__, __LINE__) are added as an
* entry with a special format: (string, number). The number contains
* the line and flags.
*/
/* XXX: optimize: allocate an array part to the necessary size (upwards
* estimate) and fill in the values directly into the array part; finally
* update 'length'.
*/
/* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype
* has write-protected array index named properties. This was seen as DoubleErrors
* in e.g. some test262 test cases. Using duk_def_prop_index() is better but heavier.
* The best fix is to fill in the tracedata directly into the array part.
*/
/* [ ... error arr ] */
if (filename) {
duk_push_string(ctx, filename);
duk_def_prop_index_wec(ctx, -2, arr_idx);
arr_idx++;
d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
(duk_double_t) line;
duk_push_number(ctx, d);
duk_def_prop_index_wec(ctx, -2, arr_idx);
arr_idx++;
}
/* traceback depth doesn't take into account the filename/line
* special handling above (intentional)
*/
depth = DUK_USE_TRACEBACK_DEPTH;
i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
DUK_ASSERT(i_min >= 0);
/* [ ... error arr ] */
DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX); /* callstack limits */
for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
duk_uint32_t pc;
/*
* Note: each API operation potentially resizes the callstack,
* so be careful to re-lookup after every operation. Currently
* these is no issue because we don't store a temporary 'act'
* pointer at all. (This would be a non-issue if we operated
* directly on the array part.)
*/
/* [... arr] */
DUK_ASSERT(thr_callstack->callstack[i].func != NULL);
DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0); /* unsigned */
/* add function */
duk_push_hobject(ctx, thr_callstack->callstack[i].func); /* -> [... arr func] */
duk_def_prop_index_wec(ctx, -2, arr_idx);
arr_idx++;
/* add a number containing: pc, activation flags */
/* Add a number containing: pc, activation flag
*
* PC points to next instruction, find offending PC. Note that
* PC == 0 for native code.
*/
pc = thr_callstack->callstack[i].pc;
if (pc > 0) {
pc--;
}
DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */
DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */
d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc;
duk_push_number(ctx, d); /* -> [... arr num] */
duk_def_prop_index_wec(ctx, -2, arr_idx);
arr_idx++;
}
/* XXX: set with duk_hobject_set_length() when tracedata is filled directly */
duk_push_uint(ctx, (duk_uint_t) arr_idx);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC);
/* [ ... error arr ] */
duk_def_prop_stridx_wec(ctx, -2, DUK_STRIDX_TRACEDATA); /* -> [ ... error ] */
}
DUK_INTERNAL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize) {
void *res;
duk_bool_t rc;
duk_small_int_t i;
DUK_ASSERT(heap != NULL);
DUK_ASSERT_DISABLE(newsize >= 0);
/*
* Voluntary periodic GC (if enabled)
*/
DUK__VOLUNTARY_PERIODIC_GC(heap);
/*
* First attempt
*/
#if defined(DUK_USE_GC_TORTURE)
/* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first indirect realloc attempt fails"));
res = NULL;
DUK_UNREF(res);
goto skip_attempt;
}
#endif
res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
if (res || newsize == 0) {
/* for zero size allocations NULL is allowed */
return res;
}
#if defined(DUK_USE_GC_TORTURE)
skip_attempt:
#endif
DUK_D(DUK_DPRINT("first indirect realloc attempt failed, attempt to gc and retry"));
/*
* Avoid a GC if GC is already running. See duk_heap_mem_alloc().
*/
if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
return NULL;
}
/*
* Retry with several GC attempts. Initial attempts are made without
* emergency mode; later attempts use emergency mode which minimizes
* memory allocations forcibly.
*/
for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
duk_small_uint_t flags;
#if defined(DUK_USE_ASSERTIONS)
void *ptr_pre; /* ptr before mark-and-sweep */
void *ptr_post;
#endif
#if defined(DUK_USE_ASSERTIONS)
ptr_pre = cb(heap, ud);
#endif
flags = 0;
if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
flags |= DUK_MS_FLAG_EMERGENCY;
}
rc = duk_heap_mark_and_sweep(heap, flags);
DUK_UNREF(rc);
#if defined(DUK_USE_ASSERTIONS)
ptr_post = cb(heap, ud);
if (ptr_pre != ptr_post) {
/* useful for debugging */
DUK_DD(DUK_DDPRINT("note: base pointer changed by mark-and-sweep: %p -> %p",
(void *) ptr_pre, (void *) ptr_post));
}
#endif
/* Note: key issue here is to re-lookup the base pointer on every attempt.
* The pointer being reallocated may change after every mark-and-sweep.
*/
res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
if (res || newsize == 0) {
DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() succeeded after gc (pass %ld), alloc size %ld",
(long) (i + 1), (long) newsize));
return res;
}
}
DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed even after gc, alloc size %ld", (long) newsize));
return NULL;
}
DUK_INTERNAL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size) {
void *res;
duk_bool_t rc;
duk_small_int_t i;
DUK_ASSERT(heap != NULL);
DUK_ASSERT_DISABLE(size >= 0);
/*
* Voluntary periodic GC (if enabled)
*/
DUK__VOLUNTARY_PERIODIC_GC(heap);
/*
* First attempt
*/
#if defined(DUK_USE_GC_TORTURE)
/* simulate alloc failure on every alloc (except when mark-and-sweep is running) */
if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first alloc attempt fails"));
res = NULL;
DUK_UNREF(res);
goto skip_attempt;
}
#endif
res = heap->alloc_func(heap->heap_udata, size);
if (res || size == 0) {
/* for zero size allocations NULL is allowed */
return res;
}
#if defined(DUK_USE_GC_TORTURE)
skip_attempt:
#endif
DUK_D(DUK_DPRINT("first alloc attempt failed, attempt to gc and retry"));
/*
* Avoid a GC if GC is already running. This can happen at a late
* stage in a GC when we try to e.g. resize the stringtable
* or compact objects.
*/
if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed, gc in progress (gc skipped), alloc size %ld", (long) size));
return NULL;
}
/*
* Retry with several GC attempts. Initial attempts are made without
* emergency mode; later attempts use emergency mode which minimizes
* memory allocations forcibly.
*/
for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
duk_small_uint_t flags;
flags = 0;
if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
flags |= DUK_MS_FLAG_EMERGENCY;
}
rc = duk_heap_mark_and_sweep(heap, flags);
DUK_UNREF(rc);
res = heap->alloc_func(heap->heap_udata, size);
if (res) {
DUK_D(DUK_DPRINT("duk_heap_mem_alloc() succeeded after gc (pass %ld), alloc size %ld",
(long) (i + 1), (long) size));
return res;
}
}
DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed even after gc, alloc size %ld", (long) size));
return NULL;
}
void duk_hbuffer_insert_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, size_t dst_offset, size_t src_offset, size_t length) {
char *p;
size_t src_end_offset; /* source end (exclusive) in initial buffer */
size_t len;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(buf != NULL);
DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
DUK_ASSERT_DISABLE(dst_offset >= 0); /* always true */
DUK_ASSERT(dst_offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */
DUK_ASSERT_DISABLE(src_offset >= 0); /* always true */
DUK_ASSERT(src_offset <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */
DUK_ASSERT_DISABLE(length >= 0); /* always true */
DUK_ASSERT(src_offset + length <= DUK_HBUFFER_GET_SIZE(buf)); /* allow equality */
if (length == 0) {
return;
}
if (DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) < length) {
duk_hbuffer_resize(thr,
buf,
DUK_HBUFFER_GET_SIZE(buf),
duk__add_spare(DUK_HBUFFER_GET_SIZE(buf) + length));
}
DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) >= length);
p = (char *) DUK_HBUFFER_DYNAMIC_GET_CURR_DATA_PTR(buf);
/*
* src_offset and dst_offset refer to the state of the buffer
* before any changes are made. This must be taken into account
* when moving data around; in particular, the source data may
* "straddle" the dst_offset, so the insert may need to be handled
* in two pieces.
*/
src_end_offset = src_offset + length;
/* create a hole for the insert */
len = DUK_HBUFFER_GET_SIZE(buf) - dst_offset;
if (len > 0) {
DUK_MEMMOVE(p + dst_offset + length,
p + dst_offset,
len);
}
if (src_offset < dst_offset) {
if (src_end_offset <= dst_offset) {
/* entire source is before 'dst_offset' */
DUK_MEMCPY(p + dst_offset,
p + src_offset,
length);
} else {
/* part of the source is before 'dst_offset'; straddles */
len = dst_offset - src_offset;
DUK_ASSERT(len >= 1 && len < length);
DUK_ASSERT(length - len >= 1);
DUK_MEMCPY(p + dst_offset,
p + src_offset,
len);
DUK_MEMCPY(p + dst_offset + len,
p + src_offset + length + len, /* take above memmove() into account */
length - len);
}
} else {
/* entire source is after 'dst_offset' */
DUK_MEMCPY(p + dst_offset,
p + src_offset + length, /* take above memmove() into account */
length);
}
buf->size += length;
}
/* intern built-in strings from precooked data (genstrings.py) */
DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) {
duk_bitdecoder_ctx bd_ctx;
duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
duk_small_uint_t i, j;
DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
bd->data = (const duk_uint8_t *) duk_strings_data;
bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH;
for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN];
duk_hstring *h;
duk_small_uint_t len;
duk_small_uint_t mode;
duk_small_uint_t t;
len = duk_bd_decode(bd, 5);
mode = 32; /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */
for (j = 0; j < len; j++) {
t = duk_bd_decode(bd, 5);
if (t < DUK__BITPACK_LETTER_LIMIT) {
t = t + DUK_ASC_UC_A + mode;
} else if (t == DUK__BITPACK_UNDERSCORE) {
t = DUK_ASC_UNDERSCORE;
} else if (t == DUK__BITPACK_FF) {
/* Internal keys are prefixed with 0xFF in the stringtable
* (which makes them invalid UTF-8 on purpose).
*/
t = 0xff;
} else if (t == DUK__BITPACK_SWITCH1) {
t = duk_bd_decode(bd, 5);
DUK_ASSERT_DISABLE(t >= 0); /* unsigned */
DUK_ASSERT(t <= 25);
t = t + DUK_ASC_UC_A + (mode ^ 32);
} else if (t == DUK__BITPACK_SWITCH) {
mode = mode ^ 32;
t = duk_bd_decode(bd, 5);
DUK_ASSERT_DISABLE(t >= 0);
DUK_ASSERT(t <= 25);
t = t + DUK_ASC_UC_A + mode;
} else if (t == DUK__BITPACK_SEVENBIT) {
t = duk_bd_decode(bd, 7);
}
tmp[j] = (duk_uint8_t) t;
}
/* No need to length check string: it will never exceed even
* the 16-bit length maximum.
*/
DUK_ASSERT(len <= 0xffffUL);
DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i));
h = duk_heap_string_intern(heap, tmp, len);
if (!h) {
goto error;
}
/* Special flags checks. Since these strings are always
* reachable and a string cannot appear twice in the string
* table, there's no need to check/set these flags elsewhere.
* The 'internal' flag is set by string intern code.
*/
if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) {
DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h);
}
if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) {
DUK_HSTRING_SET_RESERVED_WORD(h);
if (i >= DUK_STRIDX_START_STRICT_RESERVED) {
DUK_HSTRING_SET_STRICT_RESERVED_WORD(h);
}
}
DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h));
/* XXX: The incref macro takes a thread pointer but doesn't
* use it right now.
*/
DUK_HSTRING_INCREF(_never_referenced_, h);
#if defined(DUK_USE_HEAPPTR16)
heap->strs16[i] = DUK_USE_HEAPPTR_ENC16((void *) h);
#else
heap->strs[i] = h;
#endif
}
return 1;
error:
return 0;
}
DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb) {
duk_context *ctx = (duk_context *) thr;
duk_tval *tv_hnd;
duk_small_uint_t call_flags;
duk_int_t rc;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr->heap != NULL);
DUK_ASSERT_DISABLE(stridx_cb >= 0); /* unsigned */
DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS);
if (DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)) {
DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore"));
return;
}
/*
* Check whether or not we have an error handler.
*
* We must be careful of not triggering an error when looking up the
* property. For instance, if the property is a getter, we don't want
* to call it, only plain values are allowed. The value, if it exists,
* is not checked. If the value is not a function, a TypeError happens
* when it is called and that error replaces the original one.
*/
DUK_ASSERT_VALSTACK_SPACE(thr, 4); /* 3 entries actually needed below */
/* [ ... errval ] */
if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) {
/* When creating built-ins, some of the built-ins may not be set
* and we want to tolerate that when throwing errors.
*/
DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring"));
return;
}
tv_hnd = duk_hobject_find_existing_entry_tval_ptr(thr->heap,
thr->builtins[DUK_BIDX_DUKTAPE],
DUK_HTHREAD_GET_STRING(thr, stridx_cb));
if (tv_hnd == NULL) {
DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T",
(duk_tval *) tv_hnd));
return;
}
DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T",
(duk_tval *) tv_hnd));
duk_push_tval(ctx, tv_hnd);
/* [ ... errval errhandler ] */
duk_insert(ctx, -2); /* -> [ ... errhandler errval ] */
duk_push_undefined(ctx);
duk_insert(ctx, -2); /* -> [ ... errhandler undefined(= this) errval ] */
/* [ ... errhandler undefined errval ] */
/*
* DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C
* recursion depth limit (and won't increase it either). This is
* dangerous, but useful because it allows the error handler to run
* even if the original error is caused by C recursion depth limit.
*
* The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the
* duration of the error handler and cleared afterwards. This flag
* prevents the error handler from running recursively. The flag is
* heap level so that the flag properly controls even coroutines
* launched by an error handler. Since the flag is heap level, it is
* critical to restore it correctly.
*
* We ignore errors now: a success return and an error value both
* replace the original error value. (This would be easy to change.)
*/
DUK_ASSERT(!DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)); /* since no recursive error handler calls */
DUK_HEAP_SET_ERRHANDLER_RUNNING(thr->heap);
call_flags = DUK_CALL_FLAG_PROTECTED |
DUK_CALL_FLAG_IGNORE_RECLIMIT; /* protected, ignore reclimit, not constructor */
rc = duk_handle_call(thr,
1, /* num args */
call_flags); /* call_flags */
DUK_UNREF(rc); /* no need to check now: both success and error are OK */
DUK_ASSERT(DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));
DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(thr->heap);
/* [ ... errval ] */
}
static 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(h1->h_refcount == 0);
h1->h_refcount++; /* bump refcount to prevent refzero during finalizer processing */
duk_hobject_run_finalizer(thr, obj); /* must never longjmp */
h1->h_refcount--; /* remove artificial bump */
DUK_ASSERT_DISABLE(h1->h_refcount >= 0); /* refcount is unsigned, so always true */
if (h1->h_refcount != 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 */
}
void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, size_t newsize) {
void *res;
int rc;
int i;
DUK_ASSERT(heap != NULL);
/* ptr may be NULL */
DUK_ASSERT_DISABLE(newsize >= 0);
/*
* Voluntary periodic GC (if enabled)
*/
DUK__VOLUNTARY_PERIODIC_GC(heap);
/*
* First attempt
*/
#ifdef DUK_USE_GC_TORTURE
/* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first realloc attempt fails"));
res = NULL;
DUK_UNREF(res);
goto skip_attempt;
}
#endif
res = heap->realloc_func(heap->alloc_udata, ptr, newsize);
if (res || newsize == 0) {
/* for zero size allocations NULL is allowed */
return res;
}
#ifdef DUK_USE_GC_TORTURE
skip_attempt:
#endif
DUK_D(DUK_DPRINT("first realloc attempt failed, attempt to gc and retry"));
/*
* Avoid a GC if GC is already running. See duk_heap_mem_alloc().
*/
if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed, gc in progress (gc skipped), alloc size %d", newsize));
return NULL;
}
/*
* Retry with several GC attempts. Initial attempts are made without
* emergency mode; later attempts use emergency mode which minimizes
* memory allocations forcibly.
*/
for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
int flags;
flags = 0;
if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
flags |= DUK_MS_FLAG_EMERGENCY;
}
rc = duk_heap_mark_and_sweep(heap, flags);
DUK_UNREF(rc);
res = heap->realloc_func(heap->alloc_udata, ptr, newsize);
if (res) {
DUK_D(DUK_DPRINT("duk_heap_mem_realloc() succeeded after gc (pass %d), alloc size %d",
i + 1, newsize));
return res;
}
}
DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed even after gc, alloc size %d", newsize));
return NULL;
}
DUK_LOCAL void duk__err_augment_builtin_throw(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) {
duk_context *ctx = (duk_context *) thr;
#ifdef DUK_USE_ASSERTIONS
duk_int_t entry_top;
#endif
#ifdef DUK_USE_ASSERTIONS
entry_top = duk_get_top(ctx);
#endif
DUK_ASSERT(obj != NULL);
DUK_UNREF(obj); /* unreferenced w/o tracebacks */
DUK_UNREF(ctx); /* unreferenced w/ tracebacks */
#ifdef DUK_USE_TRACEBACKS
/*
* If tracebacks are enabled, the '_Tracedata' property is the only
* thing we need: 'fileName' and 'lineNumber' are virtual properties
* which use '_Tracedata'.
*/
if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_TRACEDATA(thr))) {
DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it"));
} else {
duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline);
}
#else
/*
* If tracebacks are disabled, 'fileName' and 'lineNumber' are added
* as plain own properties. Since Error.prototype has accessors of
* the same name, we need to define own properties directly (cannot
* just use e.g. duk_put_prop_stridx). Existing properties are not
* overwritten in case they already exist.
*/
if (c_filename && !noblame_fileline) {
/* XXX: file/line is disabled in minimal builds, so disable this too
* when appropriate.
*/
duk_push_string(ctx, c_filename);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
duk_push_int(ctx, c_line);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
} else if (thr_callstack->callstack_top > 0) {
duk_activation *act;
duk_hobject *func;
act = thr_callstack->callstack + thr_callstack->callstack_top - 1;
DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size);
func = DUK_ACT_GET_FUNC(act);
if (func) {
duk_uint32_t pc;
/* PC points to next instruction, find offending PC. Note that
* PC == 0 for native code.
*/
pc = act->pc;
if (pc > 0) {
pc--;
}
DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */
DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */
act = NULL; /* invalidated by pushes, so get out of the way */
duk_push_hobject(ctx, func);
/* [ ... error func ] */
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
#if defined(DUK_USE_PC2LINE)
if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
duk_uint32_t ecma_line;
#if 0
duk_push_u32(ctx, pc);
duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PC, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAGS_NO_OVERWRITE);
#endif
ecma_line = duk_hobject_pc2line_query(ctx, -1, (duk_uint_fast32_t) pc);
if (ecma_line > 0) {
duk_push_u32(ctx, (duk_uint32_t) ecma_line); /* -> [ ... error func line ] */
duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
}
} else {
/* Native function, no relevant lineNumber. */
}
#endif /* DUK_USE_PC2LINE */
duk_pop(ctx);
}
}
#endif /* DUK_USE_TRACEBACKS */
#ifdef DUK_USE_ASSERTIONS
DUK_ASSERT(duk_get_top(ctx) == entry_top);
#endif
}
DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) {
duk_context *ctx = (duk_context *) thr;
duk_bitdecoder_ctx bd_ctx;
duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */
duk_hobject *h;
duk_small_uint_t i, j;
DUK_D(DUK_DPRINT("INITBUILTINS BEGIN"));
DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
bd->data = (const duk_uint8_t *) duk_builtins_data;
bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
/*
* First create all built-in bare objects on the empty valstack.
* During init, their indices will correspond to built-in indices.
*
* Built-ins will be reachable from both valstack and thr->builtins.
*/
/* XXX: there is no need to resize valstack because builtin count
* is much less than the default space; assert for it.
*/
DUK_DD(DUK_DDPRINT("create empty built-ins"));
DUK_ASSERT_TOP(ctx, 0);
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_small_uint_t class_num;
duk_small_int_t len = -1; /* must be signed */
class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS);
len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
duk_small_uint_t natidx;
duk_small_uint_t stridx;
duk_int_t c_nargs; /* must hold DUK_VARARGS */
duk_c_function c_func;
duk_int16_t magic;
DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len));
DUK_ASSERT(len >= 0);
natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
c_func = duk_bi_native_functions[natidx];
c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
c_nargs = DUK_VARARGS;
}
/* XXX: set magic directly here? (it could share the c_nargs arg) */
duk_push_c_function_noexotic(ctx, c_func, c_nargs);
h = duk_require_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
/* Currently all built-in native functions are strict.
* duk_push_c_function() now sets strict flag, so
* assert for it.
*/
DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h));
/* XXX: function properties */
duk_push_hstring_stridx(ctx, stridx);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
/* Almost all global level Function objects are constructable
* but not all: Function.prototype is a non-constructable,
* callable Function.
*/
if (duk_bd_decode_flag(bd)) {
DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h));
} else {
DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h);
}
/* Cast converts magic to 16-bit signed value */
magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
((duk_hnativefunction *) h)->magic = magic;
} else {
/* XXX: ARRAY_PART for Array prototype? */
duk_push_object_helper(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE,
-1); /* no prototype or class yet */
h = duk_require_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
}
DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
thr->builtins[i] = h;
DUK_HOBJECT_INCREF(thr, &h->hdr);
if (len >= 0) {
/*
* For top-level objects, 'length' property has the following
* default attributes: non-writable, non-enumerable, non-configurable
* (E5 Section 15).
*
* However, 'length' property for Array.prototype has attributes
* expected of an Array instance which are different: writable,
* non-enumerable, non-configurable (E5 Section 15.4.5.2).
*
* This is currently determined implicitly based on class; there are
* no attribute flags in the init data.
*/
duk_push_int(ctx, len);
duk_xdef_prop_stridx(ctx,
-2,
DUK_STRIDX_LENGTH,
(class_num == DUK_HOBJECT_CLASS_ARRAY ? /* only Array.prototype matches */
DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE));
}
/* enable exotic behaviors last */
if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
DUK_HOBJECT_SET_EXOTIC_ARRAY(h);
}
if (class_num == DUK_HOBJECT_CLASS_STRING) {
DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h);
}
/* some assertions */
DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h));
/* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h));
/* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h)); /* currently, even for Array.prototype */
/* DUK_HOBJECT_FLAG_STRICT varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) || /* all native functions have NEWENV */
DUK_HOBJECT_HAS_NEWENV(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h));
DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h));
/* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */
/* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */
DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h));
DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len));
}
/*
* Then decode the builtins init data (see genbuiltins.py) to
* init objects
*/
DUK_DD(DUK_DDPRINT("initialize built-in object properties"));
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_small_uint_t t;
duk_small_uint_t num;
DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i));
h = thr->builtins[i];
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t));
DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[t]);
}
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
/* 'prototype' property for all built-in objects (which have it) has attributes:
* [[Writable]] = false,
* [[Enumerable]] = false,
* [[Configurable]] = false
*/
DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t));
duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE);
}
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
if (t != DUK__NO_BIDX_MARKER) {
/* 'constructor' property for all built-in objects (which have it) has attributes:
* [[Writable]] = true,
* [[Enumerable]] = false,
* [[Configurable]] = true
*/
DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t));
duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC);
}
/* normal valued properties */
num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS);
DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num));
for (j = 0; j < num; j++) {
duk_small_uint_t stridx;
duk_small_uint_t prop_flags;
stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
/*
* Property attribute defaults are defined in E5 Section 15 (first
* few pages); there is a default for all properties and a special
* default for 'length' properties. Variation from the defaults is
* signaled using a single flag bit in the bitstream.
*/
if (duk_bd_decode_flag(bd)) {
prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS);
} else {
if (stridx == DUK_STRIDX_LENGTH) {
prop_flags = DUK_PROPDESC_FLAGS_NONE;
} else {
prop_flags = DUK_PROPDESC_FLAGS_WC;
}
}
t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS);
DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, stridx %ld, flags 0x%02lx, type %ld",
(long) i, (long) j, (long) stridx, (unsigned long) prop_flags, (long) t));
switch (t) {
case DUK__PROP_TYPE_DOUBLE: {
duk_double_union du;
duk_small_uint_t k;
for (k = 0; k < 8; k++) {
/* Encoding endianness must match target memory layout,
* build scripts and genbuiltins.py must ensure this.
*/
du.uc[k] = (duk_uint8_t) duk_bd_decode(bd, 8);
}
duk_push_number(ctx, du.d); /* push operation normalizes NaNs */
break;
}
case DUK__PROP_TYPE_STRING: {
duk_small_uint_t n;
duk_small_uint_t k;
duk_uint8_t *p;
n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRING_LENGTH_BITS);
p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, n);
for (k = 0; k < n; k++) {
*p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
}
duk_to_string(ctx, -1);
break;
}
case DUK__PROP_TYPE_STRIDX: {
duk_small_uint_t n;
n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
DUK_ASSERT_DISABLE(n >= 0); /* unsigned */
DUK_ASSERT(n < DUK_HEAP_NUM_STRINGS);
duk_push_hstring_stridx(ctx, n);
break;
}
case DUK__PROP_TYPE_BUILTIN: {
duk_small_uint_t bidx;
bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER);
duk_dup(ctx, (duk_idx_t) bidx);
break;
}
case DUK__PROP_TYPE_UNDEFINED: {
duk_push_undefined(ctx);
break;
}
case DUK__PROP_TYPE_BOOLEAN_TRUE: {
duk_push_true(ctx);
break;
}
case DUK__PROP_TYPE_BOOLEAN_FALSE: {
duk_push_false(ctx);
break;
}
case DUK__PROP_TYPE_ACCESSOR: {
duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
duk_c_function c_func_getter;
duk_c_function c_func_setter;
/* XXX: this is a bit awkward because there is no exposed helper
* in the API style, only this internal helper.
*/
DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, stridx=%ld, getteridx=%ld, setteridx=%ld, flags=0x%04lx",
(long) i, (long) stridx, (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags));
c_func_getter = duk_bi_native_functions[natidx_getter];
c_func_setter = duk_bi_native_functions[natidx_setter];
duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0); /* always 0 args */
duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1); /* always 1 arg */
/* XXX: magic for getter/setter? */
prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */
duk_hobject_define_accessor_internal(thr,
duk_require_hobject(ctx, i),
DUK_HTHREAD_GET_STRING(thr, stridx),
duk_require_hobject(ctx, -2),
duk_require_hobject(ctx, -1),
prop_flags);
duk_pop_2(ctx); /* getter and setter, now reachable through object */
goto skip_value;
}
default: {
/* exhaustive */
DUK_UNREACHABLE();
}
}
DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
duk_xdef_prop_stridx(ctx, i, stridx, prop_flags);
skip_value:
continue; /* avoid empty label at the end of a compound statement */
}
/* native function properties */
num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS);
DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num));
for (j = 0; j < num; j++) {
duk_small_uint_t stridx;
duk_small_uint_t natidx;
duk_int_t c_nargs; /* must hold DUK_VARARGS */
duk_small_uint_t c_length;
duk_int16_t magic;
duk_c_function c_func;
duk_hnativefunction *h_func;
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
duk_small_int_t lightfunc_eligible;
#endif
stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS);
c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
c_nargs = DUK_VARARGS;
}
c_func = duk_bi_native_functions[natidx];
DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, stridx %ld, natidx %ld, length %ld, nargs %ld",
(long) i, (long) j, (long) stridx, (long) natidx, (long) c_length,
(c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs)));
/* Cast converts magic to 16-bit signed value */
magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
lightfunc_eligible =
((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) &&
(c_length <= DUK_LFUNC_LENGTH_MAX) &&
(magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX);
if (stridx == DUK_STRIDX_EVAL ||
stridx == DUK_STRIDX_YIELD ||
stridx == DUK_STRIDX_RESUME ||
stridx == DUK_STRIDX_REQUIRE) {
/* These functions have trouble working as lightfuncs.
* Some of them have specific asserts and some may have
* additional properties (e.g. 'require.id' may be written).
*/
DUK_D(DUK_DPRINT("reject as lightfunc: stridx=%d, i=%d, j=%d", (int) stridx, (int) i, (int) j));
lightfunc_eligible = 0;
}
if (lightfunc_eligible) {
duk_tval tv_lfunc;
duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs);
duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs);
DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags);
duk_push_tval(ctx, &tv_lfunc);
DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1)));
goto lightfunc_skip;
}
DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic));
#endif /* DUK_USE_LIGHTFUNC_BUILTINS */
/* [ (builtin objects) ] */
duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs);
h_func = duk_require_hnativefunction(ctx, -1);
DUK_UNREF(h_func);
/* Currently all built-in native functions are strict.
* This doesn't matter for many functions, but e.g.
* String.prototype.charAt (and other string functions)
* rely on being strict so that their 'this' binding is
* not automatically coerced.
*/
DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func);
/* No built-in functions are constructable except the top
* level ones (Number, etc).
*/
DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func));
/* XXX: any way to avoid decoding magic bit; there are quite
* many function properties and relatively few with magic values.
*/
h_func->magic = magic;
/* [ (builtin objects) func ] */
duk_push_int(ctx, c_length);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
duk_push_hstring_stridx(ctx, stridx);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
/* XXX: other properties of function instances; 'arguments', 'caller'. */
DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T",
(long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1)));
/* [ (builtin objects) func ] */
/*
* The default property attributes are correct for all
* function valued properties of built-in objects now.
*/
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
lightfunc_skip:
#endif
duk_xdef_prop_stridx(ctx, i, stridx, DUK_PROPDESC_FLAGS_WC);
/* [ (builtin objects) ] */
}
}
/*
* Special post-tweaks, for cases not covered by the init data format.
*
* - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
* toGMTString is required to have the same Function object as
* toUTCString in E5 Section B.2.6. Note that while Smjs respects
* this, V8 does not (the Function objects are distinct).
*
* - Make DoubleError non-extensible.
*
* - Add info about most important effective compile options to Duktape.
*
* - Possibly remove some properties (values or methods) which are not
* desirable with current feature options but are not currently
* conditional in init data.
*/
duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING);
duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC);
h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR);
DUK_ASSERT(h != NULL);
DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY)
DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features"));
(void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW);
#endif
#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF)
DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features"));
(void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW);
#endif
duk_push_string(ctx,
/* Endianness indicator */
#if defined(DUK_USE_INTEGER_LE)
"l"
#elif defined(DUK_USE_INTEGER_BE)
"b"
#elif defined(DUK_USE_INTEGER_ME) /* integer mixed endian not really used now */
"m"
#else
"?"
#endif
#if defined(DUK_USE_DOUBLE_LE)
"l"
#elif defined(DUK_USE_DOUBLE_BE)
"b"
#elif defined(DUK_USE_DOUBLE_ME)
"m"
#else
"?"
#endif
#if defined(DUK_USE_BYTEORDER_FORCED)
"f"
#endif
" "
/* Packed or unpacked tval */
#if defined(DUK_USE_PACKED_TVAL)
"p"
#else
"u"
#endif
#if defined(DUK_USE_FASTINT)
"f"
#endif
" "
/* Low memory options */
#if defined(DUK_USE_STRTAB_CHAIN)
"c" /* chain */
#elif defined(DUK_USE_STRTAB_PROBE)
"p" /* probe */
#else
"?"
#endif
#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16)
"n"
#endif
#if defined(DUK_USE_HEAPPTR16)
"h"
#endif
#if defined(DUK_USE_DATAPTR16)
"d"
#endif
#if defined(DUK_USE_FUNCPTR16)
"f"
#endif
#if defined(DUK_USE_REFCOUNT16)
"R"
#endif
#if defined(DUK_USE_STRHASH16)
"H"
#endif
#if defined(DUK_USE_STRLEN16)
"S"
#endif
#if defined(DUK_USE_BUFLEN16)
"B"
#endif
#if defined(DUK_USE_OBJSIZES16)
"O"
#endif
#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
"L"
#endif
" "
/* Object property allocation layout */
#if defined(DUK_USE_HOBJECT_LAYOUT_1)
"p1"
#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
"p2"
#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
"p3"
#else
"p?"
#endif
" "
/* Alignment guarantee */
#if defined(DUK_USE_ALIGN_4)
"a4"
#elif defined(DUK_USE_ALIGN_8)
"a8"
#else
"a1"
#endif
" "
/* Architecture, OS, and compiler strings */
DUK_USE_ARCH_STRING
" "
DUK_USE_OS_STRING
" "
DUK_USE_COMPILER_STRING);
duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC);
/*
* InitJS code - Ecmascript code evaluated from a built-in source
* which provides e.g. backward compatibility. User can also provide
* JS code to be evaluated at startup.
*/
#ifdef DUK_USE_BUILTIN_INITJS
/* XXX: compression */
DUK_DD(DUK_DDPRINT("running built-in initjs"));
duk_eval_string(ctx, (const char *) duk_initjs_data); /* initjs data is NUL terminated */
duk_pop(ctx);
#endif /* DUK_USE_BUILTIN_INITJS */
#ifdef DUK_USE_USER_INITJS
/* XXX: compression (as an option) */
DUK_DD(DUK_DDPRINT("running user initjs"));
duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS);
#endif /* DUK_USE_USER_INITJS */
/*
* Since built-ins are not often extended, compact them.
*/
DUK_DD(DUK_DDPRINT("compact built-ins"));
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
duk_hobject_compact_props(thr, thr->builtins[i]);
}
DUK_D(DUK_DPRINT("INITBUILTINS END"));
#ifdef DUK_USE_DDPRINT
for (i = 0; i < DUK_NUM_BUILTINS; i++) {
DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO",
(long) i, (duk_heaphdr *) thr->builtins[i]));
}
#endif
/*
* Pop built-ins from stack: they are now INCREF'd and
* reachable from the builtins[] array.
*/
duk_pop_n(ctx, DUK_NUM_BUILTINS);
DUK_ASSERT_TOP(ctx, 0);
}
/*
* Compared to a direct macro expansion this wrapper saves a few
* instructions because no heap dereferencing is required.
*/
void *duk_heap_mem_alloc(duk_heap *heap, size_t size) {
DUK_ASSERT(heap != NULL);
DUK_ASSERT_DISABLE(size >= 0);
return heap->alloc_func(heap->alloc_udata, size);
}
DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top) {
duk_size_t idx;
DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld",
(void *) thr,
(thr != NULL ? (long) thr->catchstack_top : (long) -1),
(long) new_top));
DUK_ASSERT(thr);
DUK_ASSERT(thr->heap);
DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */
DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top); /* cannot grow */
/*
* Since there are no references in the catcher structure,
* unwinding is quite simple. The only thing we need to
* look out for is popping a possible lexical environment
* established for an active catch clause.
*/
idx = thr->catchstack_top;
while (idx > new_top) {
duk_catcher *p;
duk_activation *act;
duk_hobject *env;
idx--;
DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */
DUK_ASSERT((duk_size_t) idx < thr->catchstack_size);
p = thr->catchstack + idx;
if (DUK_CAT_HAS_LEXENV_ACTIVE(p)) {
DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active",
(long) idx, (long) p->callstack_index, (long) thr->callstack_top));
/* XXX: Here we have a nasty dependency: the need to manipulate
* the callstack means that catchstack must always be unwound by
* the caller before unwinding the callstack. This should be fixed
* later.
*/
/* Note that multiple catchstack entries may refer to the same
* callstack entry.
*/
act = thr->callstack + p->callstack_index;
DUK_ASSERT(act >= thr->callstack);
DUK_ASSERT(act < thr->callstack + thr->callstack_top);
DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO",
(long) idx, (long) p->callstack_index,
(duk_heaphdr *) act->lex_env));
env = act->lex_env; /* current lex_env of the activation (created for catcher) */
DUK_ASSERT(env != NULL); /* must be, since env was created when catcher was created */
act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, env); /* prototype is lex_env before catcher created */
DUK_HOBJECT_DECREF(thr, env);
/* There is no need to decref anything else than 'env': if 'env'
* becomes unreachable, refzero will handle decref'ing its prototype.
*/
}
}
thr->catchstack_top = new_top;
/* note: any entries above the catchstack top are garbage and not zeroed */
}
DUK_INTERNAL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top) {
duk_size_t idx;
DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld",
(void *) thr,
(thr != NULL ? (long) thr->callstack_top : (long) -1),
(long) new_top));
DUK_ASSERT(thr);
DUK_ASSERT(thr->heap);
DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */
DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top); /* cannot grow */
/*
* The loop below must avoid issues with potential callstack
* reallocations. A resize (and other side effects) may happen
* e.g. due to finalizer/errhandler calls caused by a refzero or
* mark-and-sweep. Arbitrary finalizers may run, because when
* an environment record is refzero'd, it may refer to arbitrary
* values which also become refzero'd.
*
* So, the pointer 'p' is re-looked-up below whenever a side effect
* might have changed it.
*/
idx = thr->callstack_top;
while (idx > new_top) {
duk_activation *act;
duk_hobject *func;
#ifdef DUK_USE_REFERENCE_COUNTING
duk_hobject *tmp;
#endif
#ifdef DUK_USE_DEBUGGER_SUPPORT
duk_heap *heap;
#endif
idx--;
DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */
DUK_ASSERT((duk_size_t) idx < thr->callstack_size); /* true, despite side effect resizes */
act = thr->callstack + idx;
/* With lightfuncs, act 'func' may be NULL */
#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
/*
* Restore 'caller' property for non-strict callee functions.
*/
func = DUK_ACT_GET_FUNC(act);
if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) {
duk_tval *tv_caller;
duk_tval tv_tmp;
duk_hobject *h_tmp;
tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr));
/* The act->prev_caller should only be set if the entry for 'caller'
* exists (as it is only set in that case, and the property is not
* configurable), but handle all the cases anyway.
*/
if (tv_caller) {
DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller);
if (act->prev_caller) {
/* Just transfer the refcount from act->prev_caller to tv_caller,
* so no need for a refcount update. This is the expected case.
*/
DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller);
act->prev_caller = NULL;
} else {
DUK_TVAL_SET_NULL(tv_caller); /* no incref needed */
DUK_ASSERT(act->prev_caller == NULL);
}
DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */
} else {
h_tmp = act->prev_caller;
if (h_tmp) {
act->prev_caller = NULL;
DUK_HOBJECT_DECREF(thr, h_tmp); /* side effects */
}
}
act = thr->callstack + idx; /* avoid side effects */
DUK_ASSERT(act->prev_caller == NULL);
}
#endif
/*
* Unwind debugger state. If we unwind while stepping
* (either step over or step into), pause execution.
*/
#if defined(DUK_USE_DEBUGGER_SUPPORT)
heap = thr->heap;
if (heap->dbg_step_thread == thr &&
heap->dbg_step_csindex == idx) {
/* Pause for all step types: step into, step over, step out.
* This is the only place explicitly handling a step out.
*/
DUK_HEAP_SET_PAUSED(heap);
DUK_ASSERT(heap->dbg_step_thread == NULL);
}
#endif
/*
* Close environment record(s) if they exist.
*
* Only variable environments are closed. If lex_env != var_env, it
* cannot currently contain any register bound declarations.
*
* Only environments created for a NEWENV function are closed. If an
* environment is created for e.g. an eval call, it must not be closed.
*/
func = DUK_ACT_GET_FUNC(act);
if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) {
DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation"));
goto skip_env_close;
}
/* func is NULL for lightfunc */
DUK_ASSERT(act->lex_env == act->var_env);
if (act->var_env != NULL) {
DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O",
(void *) act->var_env, (duk_heaphdr *) act->var_env));
duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom);
act = thr->callstack + idx; /* avoid side effect issues */
}
#if 0
if (act->lex_env != NULL) {
if (act->lex_env == act->var_env) {
/* common case, already closed, so skip */
DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env "
"already closed -> skip closing lex_env"));
;
} else {
DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O",
(void *) act->lex_env, (duk_heaphdr *) act->lex_env));
duk_js_close_environment_record(thr, act->lex_env, DUK_ACT_GET_FUNC(act), act->idx_bottom);
act = thr->callstack + idx; /* avoid side effect issues */
}
}
#endif
DUK_ASSERT((act->lex_env == NULL) ||
((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
(duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
(duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
(duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
DUK_ASSERT((act->var_env == NULL) ||
((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
(duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
(duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
(duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
skip_env_close:
/*
* Update preventcount
*/
if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
DUK_ASSERT(thr->callstack_preventcount >= 1);
thr->callstack_preventcount--;
}
/*
* Reference count updates
*
* Note: careful manipulation of refcounts. The top is
* not updated yet, so all the activations are reachable
* for mark-and-sweep (which may be triggered by decref).
* However, the pointers are NULL so this is not an issue.
*/
#ifdef DUK_USE_REFERENCE_COUNTING
tmp = act->var_env;
#endif
act->var_env = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
act = thr->callstack + idx; /* avoid side effect issues */
#endif
#ifdef DUK_USE_REFERENCE_COUNTING
tmp = act->lex_env;
#endif
act->lex_env = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
act = thr->callstack + idx; /* avoid side effect issues */
#endif
/* Note: this may cause a corner case situation where a finalizer
* may see a currently reachable activation whose 'func' is NULL.
*/
#ifdef DUK_USE_REFERENCE_COUNTING
tmp = DUK_ACT_GET_FUNC(act);
#endif
act->func = NULL;
#ifdef DUK_USE_REFERENCE_COUNTING
DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
act = thr->callstack + idx; /* avoid side effect issues */
DUK_UNREF(act);
#endif
}
thr->callstack_top = new_top;
/*
* We could clear the book-keeping variables for the topmost activation,
* but don't do so now.
*/
#if 0
if (thr->callstack_top > 0) {
duk_activation *act = thr->callstack + thr->callstack_top - 1;
act->idx_retval = 0;
}
#endif
/* Note: any entries above the callstack top are garbage and not zeroed.
* Also topmost activation idx_retval is garbage (not zeroed), and must
* be ignored.
*/
}
DUK_INTERNAL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h) {
duk_heap *heap;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(h != NULL);
heap = thr->heap;
DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h));
/*
* Refzero handling is skipped entirely if (1) mark-and-sweep is
* running or (2) execution is paused in the debugger. The objects
* are left in the heap, and will be freed by mark-and-sweep or
* eventual heap destruction.
*
* This is necessary during mark-and-sweep because refcounts are also
* updated during the sweep phase (otherwise objects referenced by a
* swept object would have incorrect refcounts) which then calls here.
* This could be avoided by using separate decref macros in
* mark-and-sweep; however, mark-and-sweep also calls finalizers which
* would use the ordinary decref macros anyway and still call this
* function.
*
* This check must be enabled also when mark-and-sweep support has been
* disabled: the flag is also used in heap destruction when running
* finalizers for remaining objects, and the flag prevents objects from
* being moved around in heap linked lists.
*/
/* XXX: ideally this would be just one flag (maybe a derived one) so
* that a single bit test is sufficient to check the condition.
*/
#if defined(DUK_USE_DEBUGGER_SUPPORT)
if (DUK_UNLIKELY(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap) || DUK_HEAP_IS_PAUSED(heap))) {
#else
if (DUK_UNLIKELY(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap))) {
#endif
DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h));
return;
}
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();
}
}
#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
DUK_INTERNAL void duk_tval_incref(duk_tval *tv) {
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(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);
}
}
DUK_LOCAL void duk__add_fileline(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
duk_context *ctx;
#if defined(DUK_USE_ASSERTIONS)
duk_int_t entry_top;
#endif
ctx = (duk_context *) thr;
#if defined(DUK_USE_ASSERTIONS)
entry_top = duk_get_top(ctx);
#endif
/*
* If tracebacks are disabled, 'fileName' and 'lineNumber' are added
* as plain own properties. Since Error.prototype has accessors of
* the same name, we need to define own properties directly (cannot
* just use e.g. duk_put_prop_stridx). Existing properties are not
* overwritten in case they already exist.
*/
if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
/* Compiler SyntaxError (or other error) gets the primary blame.
* Currently no flag to prevent blaming.
*/
duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);
duk_push_hstring(ctx, thr->compile_ctx->h_filename);
} else if (c_filename && !noblame_fileline) {
/* C call site gets blamed next, unless flagged not to do so.
* XXX: file/line is disabled in minimal builds, so disable this
* too when appropriate.
*/
duk_push_int(ctx, c_line);
duk_push_string(ctx, c_filename);
} else {
/* Finally, blame the innermost callstack entry which has a
* .fileName property.
*/
duk_small_uint_t depth;
duk_int_t i, i_min;
duk_uint32_t ecma_line;
depth = DUK_USE_TRACEBACK_DEPTH;
i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
DUK_ASSERT(i_min >= 0);
DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX); /* callstack limits */
for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
duk_activation *act;
duk_hobject *func;
duk_uint32_t pc;
DUK_UNREF(pc);
act = thr_callstack->callstack + i;
DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size);
func = DUK_ACT_GET_FUNC(act);
if (func == NULL) {
/* Lightfunc, not blamed now. */
continue;
}
/* PC points to next instruction, find offending PC,
* PC == 0 for native code.
*/
pc = duk_hthread_get_act_prev_pc(thr, act); /* thr argument only used for thr->heap, so specific thread doesn't matter */
DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */
DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */
act = NULL; /* invalidated by pushes, so get out of the way */
duk_push_hobject(ctx, func);
/* [ ... error func ] */
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
if (!duk_is_string(ctx, -1)) {
duk_pop_2(ctx);
continue;
}
/* [ ... error func fileName ] */
ecma_line = 0;
#if defined(DUK_USE_PC2LINE)
if (DUK_HOBJECT_IS_COMPFUNC(func)) {
ecma_line = duk_hobject_pc2line_query(ctx, -2, (duk_uint_fast32_t) pc);
} else {
/* Native function, no relevant lineNumber. */
}
#endif /* DUK_USE_PC2LINE */
duk_push_u32(ctx, ecma_line);
/* [ ... error func fileName lineNumber ] */
duk_replace(ctx, -3);
/* [ ... error lineNumber fileName ] */
goto define_props;
}
/* No activation matches, use undefined for both .fileName and
* .lineNumber (matches what we do with a _Tracedata based
* no-match lookup.
*/
duk_push_undefined(ctx);
duk_push_undefined(ctx);
}
define_props:
/* [ ... error lineNumber fileName ] */
#if defined(DUK_USE_ASSERTIONS)
DUK_ASSERT(duk_get_top(ctx) == entry_top + 2);
#endif
duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
}
DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
duk_context *ctx = (duk_context *) thr;
duk_small_uint_t depth;
duk_int_t i, i_min;
duk_int_t arr_size;
duk_harray *a;
duk_tval *tv;
duk_hstring *s;
duk_uint32_t u32;
duk_double_t d;
DUK_ASSERT(thr != NULL);
DUK_ASSERT(thr_callstack != NULL);
DUK_ASSERT(ctx != NULL);
/* [ ... error ] */
/*
* The traceback format is pretty arcane in an attempt to keep it compact
* and cheap to create. It may change arbitrarily from version to version.
* It should be decoded/accessed through version specific accessors only.
*
* See doc/error-objects.rst.
*/
DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
(duk_tval *) duk_get_tval(ctx, -1)));
/* Preallocate array to correct size, so that we can just write out
* the _Tracedata values into the array part.
*/
depth = DUK_USE_TRACEBACK_DEPTH;
arr_size = (duk_int_t) (thr_callstack->callstack_top <= depth ? thr_callstack->callstack_top : depth) * 2;
if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
arr_size += 2;
}
if (c_filename) {
/* We need the C filename to be interned before getting the
* array part pointer to avoid any GC interference while the
* array part is populated.
*/
duk_push_string(ctx, c_filename);
arr_size += 2;
}
DUK_D(DUK_DPRINT("preallocated _Tracedata to %ld items", (long) arr_size));
a = duk_push_harray_with_size(ctx, (duk_uint32_t) arr_size); /* XXX: call which returns array part pointer directly */
DUK_ASSERT(a != NULL);
tv = DUK_HOBJECT_A_GET_BASE(thr->heap, (duk_hobject *) a);
DUK_ASSERT(tv != NULL || arr_size == 0);
/* Compiler SyntaxErrors (and other errors) come first, and are
* blamed by default (not flagged "noblame").
*/
if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
s = thr->compile_ctx->h_filename;
DUK_TVAL_SET_STRING(tv, s);
DUK_HSTRING_INCREF(thr, s);
tv++;
u32 = (duk_uint32_t) thr->compile_ctx->curr_token.start_line; /* (flags<<32) + (line), flags = 0 */
DUK_TVAL_SET_U32(tv, u32);
tv++;
}
/* Filename/line from C macros (__FILE__, __LINE__) are added as an
* entry with a special format: (string, number). The number contains
* the line and flags.
*/
/* [ ... error c_filename? arr ] */
if (c_filename) {
DUK_ASSERT(DUK_TVAL_IS_STRING(thr->valstack_top - 2));
s = DUK_TVAL_GET_STRING(thr->valstack_top - 2); /* interned c_filename */
DUK_ASSERT(s != NULL);
DUK_TVAL_SET_STRING(tv, s);
DUK_HSTRING_INCREF(thr, s);
tv++;
d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
(duk_double_t) c_line;
DUK_TVAL_SET_DOUBLE(tv, d);
tv++;
}
/* traceback depth doesn't take into account the filename/line
* special handling above (intentional)
*/
depth = DUK_USE_TRACEBACK_DEPTH;
i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
DUK_ASSERT(i_min >= 0);
/* [ ... error c_filename? arr ] */
DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX); /* callstack limits */
for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
duk_uint32_t pc;
duk_tval *tv_src;
/*
* Note: each API operation potentially resizes the callstack,
* so be careful to re-lookup after every operation. Currently
* these is no issue because we don't store a temporary 'act'
* pointer at all. (This would be a non-issue if we operated
* directly on the array part.)
*/
/* [... arr] */
DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0); /* unsigned */
/* Add function object. */
tv_src = &(thr_callstack->callstack + i)->tv_func; /* object (function) or lightfunc */
DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_src) || DUK_TVAL_IS_LIGHTFUNC(tv_src));
DUK_TVAL_SET_TVAL(tv, tv_src);
DUK_TVAL_INCREF(thr, tv);
tv++;
/* Add a number containing: pc, activation flags.
*
* PC points to next instruction, find offending PC. Note that
* PC == 0 for native code.
*/
pc = duk_hthread_get_act_prev_pc(thr_callstack, thr_callstack->callstack + i);
DUK_ASSERT_DISABLE(pc >= 0); /* unsigned */
DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32); /* assume PC is at most 32 bits and non-negative */
d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc;
DUK_TVAL_SET_DOUBLE(tv, d);
tv++;
}
DUK_ASSERT((duk_uint32_t) (tv - DUK_HOBJECT_A_GET_BASE(thr->heap, (duk_hobject *) a)) == a->length);
DUK_ASSERT(a->length == (duk_uint32_t) arr_size);
/* [ ... error c_filename? arr ] */
if (c_filename) {
duk_remove(ctx, -2);
}
/* [ ... error arr ] */
duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_TRACEDATA); /* -> [ ... error ] */
}
