--- /dev/null
+/*
+ * 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 */
projects / ceph.git / blobdiff