duk_hthread_stacks.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
DUK_INTERNAL void	duk_hthread_callstack_grow (duk_hthread *thr)
DUK_INTERNAL void	duk_hthread_callstack_shrink_check (duk_hthread *thr)
DUK_INTERNAL void	duk_hthread_callstack_unwind (duk_hthread *thr, duk_size_t new_top)
DUK_INTERNAL void	duk_hthread_catchstack_grow (duk_hthread *thr)
DUK_INTERNAL void	duk_hthread_catchstack_shrink_check (duk_hthread *thr)
DUK_INTERNAL void	duk_hthread_catchstack_unwind (duk_hthread *thr, duk_size_t new_top)

Function Documentation

duk_hthread_callstack_grow()

DUK_INTERNAL void duk_hthread_callstack_grow

(

duk_hthread *

thr

)

Definition at line 26 of file duktape-1.5.2/src-separate/duk_hthread_stacks.c.

                                                               {
    duk_activation *new_ptr;
    duk_size_t old_size;
    duk_size_t new_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);   /* avoid warning (unsigned) */
    DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
 
    if (thr->callstack_top < thr->callstack_size) {
        return;
    }
 
    old_size = thr->callstack_size;
    new_size = old_size + DUK_CALLSTACK_GROW_STEP;
 
    /* this is a bit approximate (errors out before max is reached); this is OK */
    if (new_size >= thr->callstack_max) {
        DUK_ERROR_RANGE(thr, DUK_STR_CALLSTACK_LIMIT);
    }
 
    DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.
     */
 
    DUK_ASSERT(new_size > 0);
    new_ptr = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size);
    if (!new_ptr) {
        /* No need for a NULL/zero-size check because new_size > 0) */
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    thr->callstack = new_ptr;
    thr->callstack_size = new_size;
 
    /* note: any entries above the callstack top are garbage and not zeroed */
}

References duk_hthread::callstack, duk_hthread::callstack_max, duk_hthread::callstack_size, duk_hthread::callstack_top, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CALLSTACK_GROW_STEP, DUK_DD, DUK_DDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_RANGE, duk_hthread_get_callstack_ptr(), DUK_REALLOC_INDIRECT, DUK_STR_CALLSTACK_LIMIT, duk_hthread::heap, and NULL.

duk_hthread_callstack_shrink_check()

DUK_INTERNAL void duk_hthread_callstack_shrink_check

(

duk_hthread *

thr

)

Definition at line 66 of file duktape-1.5.2/src-separate/duk_hthread_stacks.c.

                                                                       {
    duk_size_t new_size;
    duk_activation *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
 
    if (thr->callstack_size - thr->callstack_top < DUK_CALLSTACK_SHRINK_THRESHOLD) {
        return;
    }
 
    new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE;
    DUK_ASSERT(new_size >= thr->callstack_top);
 
    DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.
     */
 
    /* shrink failure is not fatal */
    p = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size);
    if (p) {
        thr->callstack = p;
        thr->callstack_size = new_size;
    } else {
        /* Because new_size != 0, if condition doesn't need to be
         * (p != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("callstack shrink failed, ignoring"));
    }
 
    /* note: any entries above the callstack top are garbage and not zeroed */
}

References duk_hthread::callstack, duk_hthread::callstack_size, duk_hthread::callstack_top, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CALLSTACK_SHRINK_SPARE, DUK_CALLSTACK_SHRINK_THRESHOLD, DUK_D, DUK_DD, DUK_DDPRINT, DUK_DPRINT, duk_hthread_get_callstack_ptr(), DUK_REALLOC_INDIRECT, duk_hthread::heap, and NULL.

duk_hthread_callstack_unwind()

DUK_INTERNAL void duk_hthread_callstack_unwind	(	duk_hthread *	thr,
		duk_size_t	new_top )

Definition at line 104 of file duktape-1.5.2/src-separate/duk_hthread_stacks.c.

                                                                                     {
    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.
     */
}

References duk_hthread::callstack, duk_hthread::callstack_preventcount, duk_hthread::callstack_top, DUK_ACT_FLAG_PREVENT_YIELD, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, DUK_HOBJECT_DECREF, DUK_HOBJECT_DECREF_ALLOWNULL, duk_hobject_find_existing_entry_tval_ptr(), DUK_HOBJECT_HAS_NEWENV, DUK_HOBJECT_HAS_STRICT, DUK_HTHREAD_STRING_CALLER, DUK_HTHREAD_STRING_INT_CALLEE, DUK_HTHREAD_STRING_INT_REGBASE, DUK_HTHREAD_STRING_INT_THREAD, DUK_HTHREAD_STRING_INT_VARMAP, duk_js_close_environment_record(), DUK_TVAL_DECREF, DUK_TVAL_SET_NULL, DUK_TVAL_SET_OBJECT, DUK_TVAL_SET_TVAL, DUK_UNREF, duk_activation::flags, duk_activation::func, duk_hthread::heap, duk_activation::idx_bottom, duk_activation::idx_retval, duk_activation::lex_env, NULL, and duk_activation::var_env.

duk_hthread_catchstack_grow()

DUK_INTERNAL void duk_hthread_catchstack_grow

(

duk_hthread *

thr

)

Definition at line 331 of file duktape-1.5.2/src-separate/duk_hthread_stacks.c.

                                                                {
    duk_catcher *new_ptr;
    duk_size_t old_size;
    duk_size_t new_size;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->catchstack_top);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
 
    if (thr->catchstack_top < thr->catchstack_size) {
        return;
    }
 
    old_size = thr->catchstack_size;
    new_size = old_size + DUK_CATCHSTACK_GROW_STEP;
 
    /* this is a bit approximate (errors out before max is reached); this is OK */
    if (new_size >= thr->catchstack_max) {
        DUK_ERROR_RANGE(thr, DUK_STR_CATCHSTACK_LIMIT);
    }
 
    DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.
     */
 
    DUK_ASSERT(new_size > 0);
    new_ptr = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size);
    if (!new_ptr) {
        /* No need for a NULL/zero-size check because new_size > 0) */
        DUK_ERROR_ALLOC_DEFMSG(thr);
    }
    thr->catchstack = new_ptr;
    thr->catchstack_size = new_size;
 
    /* note: any entries above the catchstack top are garbage and not zeroed */
}

References duk_hthread::catchstack, duk_hthread::catchstack_max, duk_hthread::catchstack_size, duk_hthread::catchstack_top, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CATCHSTACK_GROW_STEP, DUK_DD, DUK_DDPRINT, DUK_ERROR_ALLOC_DEFMSG, DUK_ERROR_RANGE, duk_hthread_get_catchstack_ptr(), DUK_REALLOC_INDIRECT, DUK_STR_CATCHSTACK_LIMIT, duk_hthread::heap, and NULL.

duk_hthread_catchstack_shrink_check()

DUK_INTERNAL void duk_hthread_catchstack_shrink_check

(

duk_hthread *

thr

)

Definition at line 371 of file duktape-1.5.2/src-separate/duk_hthread_stacks.c.

                                                                        {
    duk_size_t new_size;
    duk_catcher *p;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT_DISABLE(thr->catchstack_top >= 0);  /* avoid warning (unsigned) */
    DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
 
    if (thr->catchstack_size - thr->catchstack_top < DUK_CATCHSTACK_SHRINK_THRESHOLD) {
        return;
    }
 
    new_size = thr->catchstack_top + DUK_CATCHSTACK_SHRINK_SPARE;
    DUK_ASSERT(new_size >= thr->catchstack_top);
 
    DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size));
 
    /*
     *  Note: must use indirect variant of DUK_REALLOC() because underlying
     *  pointer may be changed by mark-and-sweep.
     */
 
    /* shrink failure is not fatal */
    p = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size);
    if (p) {
        thr->catchstack = p;
        thr->catchstack_size = new_size;
    } else {
        /* Because new_size != 0, if condition doesn't need to be
         * (p != NULL || new_size == 0).
         */
        DUK_ASSERT(new_size != 0);
        DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring"));
    }
 
    /* note: any entries above the catchstack top are garbage and not zeroed */
}

References duk_hthread::catchstack, duk_hthread::catchstack_size, duk_hthread::catchstack_top, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CATCHSTACK_SHRINK_SPARE, DUK_CATCHSTACK_SHRINK_THRESHOLD, DUK_D, DUK_DD, DUK_DDPRINT, DUK_DPRINT, duk_hthread_get_catchstack_ptr(), DUK_REALLOC_INDIRECT, duk_hthread::heap, and NULL.

duk_hthread_catchstack_unwind()

DUK_INTERNAL void duk_hthread_catchstack_unwind	(	duk_hthread *	thr,
		duk_size_t	new_top )

Definition at line 409 of file duktape-1.5.2/src-separate/duk_hthread_stacks.c.

                                                                                      {
    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 */
}

References duk_hthread::callstack, duk_catcher::callstack_index, duk_hthread::callstack_top, duk_hthread::catchstack, duk_hthread::catchstack_top, DUK_ASSERT, DUK_ASSERT_DISABLE, DUK_CAT_HAS_LEXENV_ACTIVE, DUK_DDD, DUK_DDDPRINT, DUK_HOBJECT_DECREF, DUK_HOBJECT_GET_PROTOTYPE, duk_hthread::heap, duk_activation::lex_env, and NULL.