duktape-1.8.0/src-separate/duk_heap.h

Go to the documentation of this file.

/*
 *  Heap structure.
 *
 *  Heap contains allocated heap objects, interned strings, and built-in
 *  strings for one or more threads.
 */
 
#ifndef DUK_HEAP_H_INCLUDED
#define DUK_HEAP_H_INCLUDED
 
/* alloc function typedefs in duktape.h */
 
/*
 *  Heap flags
 */
 
#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING                     (1 << 0)  /* mark-and-sweep is currently running */
#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED            (1 << 1)  /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
#define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING                     (1 << 2)  /* refcount code is processing refzero list */
#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING                       (1 << 3)  /* an error handler (user callback to augment/replace error) is running */
#define DUK_HEAP_FLAG_INTERRUPT_RUNNING                        (1 << 4)  /* executor interrupt running (used to avoid nested interrupts) */
#define DUK_HEAP_FLAG_FINALIZER_NORESCUE                       (1 << 5)  /* heap destruction ongoing, finalizer rescue no longer possible */
 
#define DUK__HEAP_HAS_FLAGS(heap,bits)               ((heap)->flags & (bits))
#define DUK__HEAP_SET_FLAGS(heap,bits)  do { \
        (heap)->flags |= (bits); \
    } while (0)
#define DUK__HEAP_CLEAR_FLAGS(heap,bits)  do { \
        (heap)->flags &= ~(bits); \
    } while (0)
 
#define DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)            DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)
#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
#define DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)            DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)
#define DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap)              DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)
#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap)               DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)              DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
 
#define DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap)            DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)
#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
#define DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap)            DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)
#define DUK_HEAP_SET_ERRHANDLER_RUNNING(heap)              DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)
#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap)               DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap)              DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
 
#define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap)          DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)
#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
#define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap)          DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)
#define DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(heap)            DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)
#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap)             DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE(heap)            DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
 
/*
 *  Longjmp types, also double as identifying continuation type for a rethrow (in 'finally')
 */
 
#define DUK_LJ_TYPE_UNKNOWN      0    /* unused */
#define DUK_LJ_TYPE_THROW        1    /* value1 -> error object */
#define DUK_LJ_TYPE_YIELD        2    /* value1 -> yield value, iserror -> error / normal */
#define DUK_LJ_TYPE_RESUME       3    /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */
#define DUK_LJ_TYPE_BREAK        4    /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */
#define DUK_LJ_TYPE_CONTINUE     5    /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */
#define DUK_LJ_TYPE_RETURN       6    /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */
#define DUK_LJ_TYPE_NORMAL       7    /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */
 
/*
 *  Mark-and-sweep flags
 *
 *  These are separate from heap level flags now but could be merged.
 *  The heap structure only contains a 'base mark-and-sweep flags'
 *  field and the GC caller can impose further flags.
 */
 
#define DUK_MS_FLAG_EMERGENCY                (1 << 0)   /* emergency mode: try extra hard */
#define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE    (1 << 1)   /* don't resize stringtable (but may sweep it); needed during stringtable resize */
#define DUK_MS_FLAG_NO_OBJECT_COMPACTION     (1 << 2)   /* don't compact objects; needed during object property allocation resize */
#define DUK_MS_FLAG_NO_FINALIZERS            (1 << 3)   /* don't run finalizers; leave finalizable objects in finalize_list for next round */
#define DUK_MS_FLAG_SKIP_FINALIZERS          (1 << 4)   /* don't run finalizers; queue finalizable objects back to heap_allocated */
 
/*
 *  Thread switching
 *
 *  To switch heap->curr_thread, use the macro below so that interrupt counters
 *  get updated correctly.  The macro allows a NULL target thread because that
 *  happens e.g. in call handling.
 */
 
#if defined(DUK_USE_INTERRUPT_COUNTER)
#define DUK_HEAP_SWITCH_THREAD(heap,newthr)  duk_heap_switch_thread((heap), (newthr))
#else
#define DUK_HEAP_SWITCH_THREAD(heap,newthr)  do { \
        (heap)->curr_thread = (newthr); \
    } while (0)
#endif
 
/*
 *  Other heap related defines
 */
 
/* Mark-and-sweep interval is relative to combined count of objects and
 * strings kept in the heap during the latest mark-and-sweep pass.
 * Fixed point .8 multiplier and .0 adder.  Trigger count (interval) is
 * decreased by each (re)allocation attempt (regardless of size), and each
 * refzero processed object.
 *
 * 'SKIP' indicates how many (re)allocations to wait until a retry if
 * GC is skipped because there is no thread do it with yet (happens
 * only during init phases).
 */
#if defined(DUK_USE_MARK_AND_SWEEP)
#if defined(DUK_USE_REFERENCE_COUNTING)
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT              12800L  /* 50x heap size */
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD               1024L
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP              256L
#else
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT              256L    /* 1x heap size */
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD               1024L
#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP              256L
#endif
#endif
 
/* Stringcache is used for speeding up char-offset-to-byte-offset
 * translations for non-ASCII strings.
 */
#define DUK_HEAP_STRCACHE_SIZE                            4
#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT                16  /* strings up to the this length are not cached */
 
/* helper to insert a (non-string) heap object into heap allocated list */
#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap,hdr)     duk_heap_insert_into_heap_allocated((heap),(hdr))
 
/*
 *  Stringtable
 */
 
/* initial stringtable size, must be prime and higher than DUK_UTIL_MIN_HASH_PRIME */
#define DUK_STRTAB_INITIAL_SIZE            17
 
/* indicates a deleted string; any fixed non-NULL, non-hstring pointer works */
#define DUK_STRTAB_DELETED_MARKER(heap)    ((duk_hstring *) heap)
 
/* resizing parameters */
#define DUK_STRTAB_MIN_FREE_DIVISOR        4                /* load factor max 75% */
#define DUK_STRTAB_MIN_USED_DIVISOR        4                /* load factor min 25% */
#define DUK_STRTAB_GROW_ST_SIZE(n)         ((n) + (n))      /* used entries + approx 100% -> reset load to 50% */
 
#define DUK_STRTAB_U32_MAX_STRLEN          10               /* 4'294'967'295 */
#define DUK_STRTAB_HIGHEST_32BIT_PRIME     0xfffffffbUL
 
/* probe sequence (open addressing) */
#define DUK_STRTAB_HASH_INITIAL(hash,h_size)    ((hash) % (h_size))
#define DUK_STRTAB_HASH_PROBE_STEP(hash)        DUK_UTIL_GET_HASH_PROBE_STEP((hash))
 
/* fixed top level hashtable size (separate chaining) */
#define DUK_STRTAB_CHAIN_SIZE              DUK_USE_STRTAB_CHAIN_SIZE
 
/*
 *  Built-in strings
 */
 
/* heap string indices are autogenerated in duk_strings.h */
#if defined(DUK_USE_ROM_STRINGS)
#define DUK_HEAP_GET_STRING(heap,idx) \
    ((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)]))
#else  /* DUK_USE_ROM_STRINGS */
#if defined(DUK_USE_HEAPPTR16)
#define DUK_HEAP_GET_STRING(heap,idx) \
    ((duk_hstring *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (heap)->strs16[(idx)]))
#else
#define DUK_HEAP_GET_STRING(heap,idx) \
    ((heap)->strs[(idx)])
#endif
#endif  /* DUK_USE_ROM_STRINGS */
 
/*
 *  Raw memory calls: relative to heap, but no GC interaction
 */
 
#define DUK_ALLOC_RAW(heap,size) \
    ((heap)->alloc_func((heap)->heap_udata, (size)))
 
#define DUK_REALLOC_RAW(heap,ptr,newsize) \
    ((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize)))
 
#define DUK_FREE_RAW(heap,ptr) \
    ((heap)->free_func((heap)->heap_udata, (void *) (ptr)))
 
/*
 *  Memory calls: relative to heap, GC interaction, but no error throwing.
 *
 *  XXX: Currently a mark-and-sweep triggered by memory allocation will run
 *  using the heap->heap_thread.  This thread is also used for running
 *  mark-and-sweep finalization; this is not ideal because it breaks the
 *  isolation between multiple global environments.
 *
 *  Notes:
 *
 *    - DUK_FREE() is required to ignore NULL and any other possible return
 *      value of a zero-sized alloc/realloc (same as ANSI C free()).
 *
 *    - There is no DUK_REALLOC_ZEROED because we don't assume to know the
 *      old size.  Caller must zero the reallocated memory.
 *
 *    - DUK_REALLOC_INDIRECT() must be used when a mark-and-sweep triggered
 *      by an allocation failure might invalidate the original 'ptr', thus
 *      causing a realloc retry to use an invalid pointer.  Example: we're
 *      reallocating the value stack and a finalizer resizes the same value
 *      stack during mark-and-sweep.  The indirect variant requests for the
 *      current location of the pointer being reallocated using a callback
 *      right before every realloc attempt; this circuitous approach is used
 *      to avoid strict aliasing issues in a more straightforward indirect
 *      pointer (void **) approach.  Note: the pointer in the storage
 *      location is read but is NOT updated; the caller must do that.
 */
 
/* callback for indirect reallocs, request for current pointer */
typedef void *(*duk_mem_getptr)(duk_heap *heap, void *ud);
 
#define DUK_ALLOC(heap,size)                            duk_heap_mem_alloc((heap), (size))
#define DUK_ALLOC_ZEROED(heap,size)                     duk_heap_mem_alloc_zeroed((heap), (size))
#define DUK_REALLOC(heap,ptr,newsize)                   duk_heap_mem_realloc((heap), (ptr), (newsize))
#define DUK_REALLOC_INDIRECT(heap,cb,ud,newsize)        duk_heap_mem_realloc_indirect((heap), (cb), (ud), (newsize))
#define DUK_FREE(heap,ptr)                              duk_heap_mem_free((heap), (ptr))
 
/*
 *  Memory constants
 */
 
#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT           5   /* Retry allocation after mark-and-sweep for this
                                                              * many times.  A single mark-and-sweep round is
                                                              * not guaranteed to free all unreferenced memory
                                                              * because of finalization (in fact, ANY number of
                                                              * rounds is strictly not enough).
                                                              */
 
#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT  3  /* Starting from this round, use emergency mode
                                                              * for mark-and-sweep.
                                                              */
 
/*
 *  Debugger support
 */
 
/* Maximum number of breakpoints.  Only breakpoints that are set are
 * consulted so increasing this has no performance impact.
 */
#define DUK_HEAP_MAX_BREAKPOINTS          16
 
/* Opcode interval for a Date-based status/peek rate limit check.  Only
 * relevant when debugger is attached.  Requesting a timestamp may be a
 * slow operation on some platforms so this shouldn't be too low.  On the
 * other hand a high value makes Duktape react to a pause request slowly.
 */
#define DUK_HEAP_DBG_RATELIMIT_OPCODES    4000
 
/* Milliseconds between status notify and transport peeks. */
#define DUK_HEAP_DBG_RATELIMIT_MILLISECS  200
 
/* Step types */
#define DUK_STEP_TYPE_NONE  0
#define DUK_STEP_TYPE_INTO  1
#define DUK_STEP_TYPE_OVER  2
#define DUK_STEP_TYPE_OUT   3
 
struct duk_breakpoint {
    duk_hstring *filename;
    duk_uint32_t line;
};
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
#define DUK_HEAP_IS_DEBUGGER_ATTACHED(heap) ((heap)->dbg_read_cb != NULL)
#define DUK_HEAP_CLEAR_STEP_STATE(heap) do { \
        (heap)->dbg_step_type = DUK_STEP_TYPE_NONE; \
        (heap)->dbg_step_thread = NULL; \
        (heap)->dbg_step_csindex = 0; \
        (heap)->dbg_step_startline = 0; \
    } while (0)
#define DUK_HEAP_SET_PAUSED(heap) do { \
        (heap)->dbg_paused = 1; \
        (heap)->dbg_state_dirty = 1; \
        DUK_HEAP_CLEAR_STEP_STATE((heap)); \
    } while (0)
#define DUK_HEAP_CLEAR_PAUSED(heap) do { \
        (heap)->dbg_paused = 0; \
        (heap)->dbg_state_dirty = 1; \
        DUK_HEAP_CLEAR_STEP_STATE((heap)); \
    } while (0)
#define DUK_HEAP_IS_PAUSED(heap) ((heap)->dbg_paused)
#endif  /* DUK_USE_DEBUGGER_SUPPORT */
 
/*
 *  String cache should ideally be at duk_hthread level, but that would
 *  cause string finalization to slow down relative to the number of
 *  threads; string finalization must check the string cache for "weak"
 *  references to the string being finalized to avoid dead pointers.
 *
 *  Thus, string caches are now at the heap level now.
 */
 
struct duk_strcache {
    duk_hstring *h;
    duk_uint32_t bidx;
    duk_uint32_t cidx;
};
 
/*
 *  Longjmp state, contains the information needed to perform a longjmp.
 *  Longjmp related values are written to value1, value2, and iserror.
 */
 
struct duk_ljstate {
    duk_jmpbuf *jmpbuf_ptr;   /* current setjmp() catchpoint */
    duk_small_uint_t type;    /* longjmp type */
    duk_bool_t iserror;       /* isError flag for yield */
    duk_tval value1;          /* 1st related value (type specific) */
    duk_tval value2;          /* 2nd related value (type specific) */
};
 
/*
 *  Stringtable entry for fixed size stringtable
 */
 
struct duk_strtab_entry {
#if defined(DUK_USE_HEAPPTR16)
    /* A 16-bit listlen makes sense with 16-bit heap pointers: there
     * won't be space for 64k strings anyway.
     */
    duk_uint16_t listlen;  /* if 0, 'str16' used, if > 0, 'strlist16' used */
    union {
        duk_uint16_t strlist16;
        duk_uint16_t str16;
    } u;
#else
    duk_size_t listlen;  /* if 0, 'str' used, if > 0, 'strlist' used */
    union {
        duk_hstring **strlist;
        duk_hstring *str;
    } u;
#endif
};
 
/*
 *  Main heap structure
 */
 
struct duk_heap {
    duk_small_uint_t flags;
 
    /* Allocator functions. */
    duk_alloc_function alloc_func;
    duk_realloc_function realloc_func;
    duk_free_function free_func;
 
    /* Heap udata, used for allocator functions but also for other heap
     * level callbacks like pointer compression, etc.
     */
    void *heap_udata;
 
    /* Precomputed pointers when using 16-bit heap pointer packing. */
#if defined(DUK_USE_HEAPPTR16)
    duk_uint16_t heapptr_null16;
    duk_uint16_t heapptr_deleted16;
#endif
 
    /* Fatal error handling, called e.g. when a longjmp() is needed but
     * lj.jmpbuf_ptr is NULL.  fatal_func must never return; it's not
     * declared as "noreturn" because doing that for typedefs is a bit
     * challenging portability-wise.
     */
    duk_fatal_function fatal_func;
 
    /* allocated heap objects */
    duk_heaphdr *heap_allocated;
 
    /* work list for objects whose refcounts are zero but which have not been
     * "finalized"; avoids recursive C calls when refcounts go to zero in a
     * chain of objects.
     */
#if defined(DUK_USE_REFERENCE_COUNTING)
    duk_heaphdr *refzero_list;
    duk_heaphdr *refzero_list_tail;
#endif
 
#if defined(DUK_USE_MARK_AND_SWEEP)
    /* mark-and-sweep control */
#if defined(DUK_USE_VOLUNTARY_GC)
    duk_int_t mark_and_sweep_trigger_counter;
#endif
    duk_int_t mark_and_sweep_recursion_depth;
 
    /* mark-and-sweep flags automatically active (used for critical sections) */
    duk_small_uint_t mark_and_sweep_base_flags;
 
    /* work list for objects to be finalized (by mark-and-sweep) */
    duk_heaphdr *finalize_list;
#endif
 
    /* longjmp state */
    duk_ljstate lj;
 
    /* marker for detecting internal "double faults", see duk_error_throw.c */
    duk_bool_t handling_error;
 
    /* heap thread, used internally and for finalization */
    duk_hthread *heap_thread;
 
    /* current thread */
    duk_hthread *curr_thread;  /* currently running thread */
 
    /* heap level "stash" object (e.g., various reachability roots) */
    duk_hobject *heap_object;
 
    /* duk_handle_call / duk_handle_safe_call recursion depth limiting */
    duk_int_t call_recursion_depth;
    duk_int_t call_recursion_limit;
 
    /* mix-in value for computing string hashes; should be reasonably unpredictable */
    duk_uint32_t hash_seed;
 
    /* rnd_state for duk_util_tinyrandom.c */
    duk_uint32_t rnd_state;
 
    /* For manual debugging: instruction count based on executor and
     * interrupt counter book-keeping.  Inspect debug logs to see how
     * they match up.
     */
#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG)
    duk_int_t inst_count_exec;
    duk_int_t inst_count_interrupt;
#endif
 
    /* debugger */
 
#if defined(DUK_USE_DEBUGGER_SUPPORT)
    /* callbacks and udata; dbg_read_cb != NULL is used to indicate attached state */
    duk_debug_read_function dbg_read_cb;                /* required, NULL implies detached */
    duk_debug_write_function dbg_write_cb;              /* required */
    duk_debug_peek_function dbg_peek_cb;
    duk_debug_read_flush_function dbg_read_flush_cb;
    duk_debug_write_flush_function dbg_write_flush_cb;
    duk_debug_request_function dbg_request_cb;
    duk_debug_detached_function dbg_detached_cb;
    void *dbg_udata;
 
    /* debugger state, only relevant when attached */
    duk_bool_t dbg_processing;              /* currently processing messages or breakpoints: don't enter message processing recursively (e.g. no breakpoints when processing debugger eval) */
    duk_bool_t dbg_paused;                  /* currently paused: talk with debug client until step/resume */
    duk_bool_t dbg_state_dirty;             /* resend state next time executor is about to run */
    duk_bool_t dbg_force_restart;           /* force executor restart to recheck breakpoints; used to handle function returns (see GH-303) */
    duk_bool_t dbg_detaching;               /* debugger detaching; used to avoid calling detach handler recursively */
    duk_small_uint_t dbg_step_type;         /* step type: none, step into, step over, step out */
    duk_hthread *dbg_step_thread;           /* borrowed; NULL if no step state (NULLed in unwind) */
    duk_size_t dbg_step_csindex;            /* callstack index */
    duk_uint32_t dbg_step_startline;        /* starting line number */
    duk_breakpoint dbg_breakpoints[DUK_HEAP_MAX_BREAKPOINTS];  /* breakpoints: [0,breakpoint_count[ gc reachable */
    duk_small_uint_t dbg_breakpoint_count;
    duk_breakpoint *dbg_breakpoints_active[DUK_HEAP_MAX_BREAKPOINTS + 1];  /* currently active breakpoints: NULL term, borrowed pointers */
    /* XXX: make active breakpoints actual copies instead of pointers? */
 
    /* These are for rate limiting Status notifications and transport peeking. */
    duk_uint32_t dbg_exec_counter;          /* cumulative opcode execution count (overflows are OK) */
    duk_uint32_t dbg_last_counter;          /* value of dbg_exec_counter when we last did a Date-based check */
    duk_double_t dbg_last_time;             /* time when status/peek was last done (Date-based rate limit) */
 
    /* Used to support single-byte stream lookahead. */
    duk_bool_t dbg_have_next_byte;
    duk_uint8_t dbg_next_byte;
#endif
 
    /* string intern table (weak refs) */
#if defined(DUK_USE_STRTAB_PROBE)
#if defined(DUK_USE_HEAPPTR16)
    duk_uint16_t *strtable16;
#else
    duk_hstring **strtable;
#endif
    duk_uint32_t st_size;     /* alloc size in elements */
    duk_uint32_t st_used;     /* used elements (includes DELETED) */
#endif
 
    /* XXX: static alloc is OK until separate chaining stringtable
     * resizing is implemented.
     */
#if defined(DUK_USE_STRTAB_CHAIN)
    duk_strtab_entry strtable[DUK_STRTAB_CHAIN_SIZE];
#endif
 
    /* string access cache (codepoint offset -> byte offset) for fast string
     * character looping; 'weak' reference which needs special handling in GC.
     */
    duk_strcache strcache[DUK_HEAP_STRCACHE_SIZE];
 
    /* built-in strings */
#if defined(DUK_USE_ROM_STRINGS)
    /* No field needed when strings are in ROM. */
#else
#if defined(DUK_USE_HEAPPTR16)
    duk_uint16_t strs16[DUK_HEAP_NUM_STRINGS];
#else
    duk_hstring *strs[DUK_HEAP_NUM_STRINGS];
#endif
#endif
};
 
/*
 *  Prototypes
 */
 
DUK_INTERNAL_DECL
duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
                         duk_realloc_function realloc_func,
                         duk_free_function free_func,
                         void *heap_udata,
                         duk_fatal_function fatal_func);
DUK_INTERNAL_DECL void duk_heap_free(duk_heap *heap);
DUK_INTERNAL_DECL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h);
DUK_INTERNAL_DECL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h);
DUK_INTERNAL_DECL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h);
DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr);
 
DUK_INTERNAL_DECL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphdr *hdr);
#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_REFERENCE_COUNTING)
DUK_INTERNAL_DECL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr);
#endif
#if defined(DUK_USE_INTERRUPT_COUNTER)
DUK_INTERNAL_DECL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr);
#endif
 
#if 0  /*unused*/
DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen);
#endif
DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen);
DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len);
#if 0  /*unused*/
DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val);
#endif
DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val);
DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val);
#if defined(DUK_USE_REFERENCE_COUNTING)
DUK_INTERNAL_DECL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h);
#endif
#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE)
DUK_INTERNAL_DECL void duk_heap_force_strtab_resize(duk_heap *heap);
#endif
DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap);
#if defined(DUK_USE_DEBUG)
DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap);
#endif
 
 
DUK_INTERNAL_DECL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h);
DUK_INTERNAL_DECL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset);
 
#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS)
DUK_INTERNAL_DECL void *duk_default_alloc_function(void *udata, duk_size_t size);
DUK_INTERNAL_DECL void *duk_default_realloc_function(void *udata, void *ptr, duk_size_t newsize);
DUK_INTERNAL_DECL void duk_default_free_function(void *udata, void *ptr);
#endif
 
DUK_INTERNAL_DECL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size);
DUK_INTERNAL_DECL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size);
DUK_INTERNAL_DECL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize);
DUK_INTERNAL_DECL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize);
DUK_INTERNAL_DECL void duk_heap_mem_free(duk_heap *heap, void *ptr);
 
#ifdef DUK_USE_REFERENCE_COUNTING
#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
DUK_INTERNAL_DECL void duk_tval_incref(duk_tval *tv);
#endif
#if 0  /* unused */
DUK_INTERNAL_DECL void duk_tval_incref_allownull(duk_tval *tv);
#endif
DUK_INTERNAL_DECL void duk_tval_decref(duk_hthread *thr, duk_tval *tv);
#if 0  /* unused */
DUK_INTERNAL_DECL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv);
#endif
#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
DUK_INTERNAL_DECL void duk_heaphdr_incref(duk_heaphdr *h);
#endif
#if 0  /* unused */
DUK_INTERNAL_DECL void duk_heaphdr_incref_allownull(duk_heaphdr *h);
#endif
DUK_INTERNAL_DECL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h);
DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h);
DUK_INTERNAL_DECL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h);
DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *hdr);
#else
/* no refcounting */
#endif
 
#if defined(DUK_USE_MARK_AND_SWEEP)
DUK_INTERNAL_DECL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags);
#endif
 
DUK_INTERNAL_DECL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len);
 
#endif  /* DUK_HEAP_H_INCLUDED */