github
/
duktape
mirror of https://github.com/svaarala/duktape.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7036 Commits
65 Branches
60 Tags
84 MiB
Tree: 44f80fea8d
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '44f80fea8d'
${ noResults }
duktape/src-input/duk_heaphdr.h

831 lines
36 KiB
Raw Normal View History

add a set of heap object headers
12 years ago
/*
* Heap header definition and assorted macros, including ref counting.
* Access all fields through the accessor macros.
*/
fix include guard names, don't use leading underscores as they are reserved
12 years ago
#ifndef DUK_HEAPHDR_H_INCLUDED
#define DUK_HEAPHDR_H_INCLUDED
add a set of heap object headers
12 years ago
/*
* Common heap header
*
* All heap objects share the same flags and refcount fields. Objects other
* than strings also need to have a single or double linked list pointers
* for insertion into the "heap allocated" list. Strings are held in the
* heap-wide string table so they don't need link pointers.
*
* Technically, 'h_refcount' must be wide enough to guarantee that it cannot
* wrap (otherwise objects might be freed incorrectly after wrapping). This
* means essentially that the refcount field must be as wide as data pointers.
* On 64-bit platforms this means that the refcount needs to be 64 bits even
* if an 'int' is 32 bits. This is a bit unfortunate, and compromising on
* this might be reasonable in the future.
*
* Heap header size on 32-bit platforms: 8 bytes without reference counting,
* 16 bytes with reference counting.
*/
struct duk_heaphdr {
typedef C99 'wrapper' types like duk_uint32_t; bulk replacement of duk_u32 with duk_uint32_t, and other type usage replacements
11 years ago
duk_uint32_t h_flags;
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
add a set of heap object headers
12 years ago
#if defined(DUK_USE_REFERENCE_COUNTING)
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#if defined(DUK_USE_REFCOUNT16)
duk_uint16_t h_refcount16;
#else
A round of internal typing fixes (midcommit)
11 years ago
duk_size_t h_refcount;
add a set of heap object headers
12 years ago
#endif
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#endif
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t h_next16;
#else
add a set of heap object headers
12 years ago
duk_heaphdr *h_next;
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#endif
add a set of heap object headers
12 years ago
#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
/* refcounting requires direct heap frees, which in turn requires a dual linked heap */
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t h_prev16;
#else
add a set of heap object headers
12 years ago
duk_heaphdr *h_prev;
#endif
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#endif
/* When DUK_USE_HEAPPTR16 (and DUK_USE_REFCOUNT16) is in use, the
* struct won't align nicely to 4 bytes. This 16-bit extra field
* is added to make the alignment clean; the field can be used by
* heap objects when 16-bit packing is used. This field is now
* conditional to DUK_USE_HEAPPTR16 only, but it is intended to be
* used with DUK_USE_REFCOUNT16 and DUK_USE_DOUBLE_LINKED_HEAP;
* this only matter to low memory environments anyway.
*/
#if defined(DUK_USE_HEAPPTR16)
duk_uint16_t h_extra16;
#endif
add a set of heap object headers
12 years ago
};
struct duk_heaphdr_string {
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
/* 16 bits would be enough for shared heaphdr flags and duk_hstring
* flags. The initial parts of duk_heaphdr_string and duk_heaphdr
* must match so changing the flags field size here would be quite
* awkward. However, to minimize struct size, we can pack at least
* 16 bits of duk_hstring data into the flags field.
*/
typedef C99 'wrapper' types like duk_uint32_t; bulk replacement of duk_u32 with duk_uint32_t, and other type usage replacements
11 years ago
duk_uint32_t h_flags;
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
add a set of heap object headers
12 years ago
#if defined(DUK_USE_REFERENCE_COUNTING)
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#if defined(DUK_USE_REFCOUNT16)
duk_uint16_t h_refcount16;
Reduce duk_hstring pointer compressed size to 8 b.
9 years ago
duk_uint16_t h_strextra16; /* round out to 8 bytes */
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#else
A round of internal typing fixes (midcommit)
11 years ago
duk_size_t h_refcount;
add a set of heap object headers
12 years ago
#endif
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it's not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for 'strs' built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -> DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer "usable_size" to "alloc_size" throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject 'p' to 'props', heap->st to heap->strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don't properly check for sizes) - Other minor cleanups
10 years ago
#endif
add a set of heap object headers
12 years ago
};
make room for more hobject bits in heaphdr; bit allocation is now tight and 4 bits are available for hobject
11 years ago
#define DUK_HEAPHDR_FLAGS_TYPE_MASK 0x00000003UL
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_FLAGS_FLAG_MASK (~DUK_HEAPHDR_FLAGS_TYPE_MASK)
make room for more hobject bits in heaphdr; bit allocation is now tight and 4 bits are available for hobject
11 years ago
/* 2 bits for heap type */
Changes for ROM string/object support
9 years ago
#define DUK_HEAPHDR_FLAGS_HEAP_START 2 /* 5 heap flags */
#define DUK_HEAPHDR_FLAGS_USER_START 7 /* 25 user flags */
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_HEAP_FLAG_NUMBER(n) (DUK_HEAPHDR_FLAGS_HEAP_START + (n))
#define DUK_HEAPHDR_USER_FLAG_NUMBER(n) (DUK_HEAPHDR_FLAGS_USER_START + (n))
A round of internal typing fixes (midcommit)
11 years ago
#define DUK_HEAPHDR_HEAP_FLAG(n) (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n)))
#define DUK_HEAPHDR_USER_FLAG(n) (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n)))
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_FLAG_REACHABLE DUK_HEAPHDR_HEAP_FLAG(0) /* mark-and-sweep: reachable */
#define DUK_HEAPHDR_FLAG_TEMPROOT DUK_HEAPHDR_HEAP_FLAG(1) /* mark-and-sweep: children not processed */
#define DUK_HEAPHDR_FLAG_FINALIZABLE DUK_HEAPHDR_HEAP_FLAG(2) /* mark-and-sweep: finalizable (on current pass) */
#define DUK_HEAPHDR_FLAG_FINALIZED DUK_HEAPHDR_HEAP_FLAG(3) /* mark-and-sweep: finalized (on previous pass) */
Changes for ROM string/object support
9 years ago
#define DUK_HEAPHDR_FLAG_READONLY DUK_HEAPHDR_HEAP_FLAG(4) /* read-only object, in code section */
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HTYPE_MIN 0
#define DUK_HTYPE_STRING 0
#define DUK_HTYPE_OBJECT 1
#define DUK_HTYPE_BUFFER 2
#define DUK_HTYPE_MAX 2
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
#if defined(DUK_USE_HEAPPTR16)
ENC16/DEC16/EXTSTR udata changes Also remove mostly unused old debug code. Debug code doesn&#39;t have access to &#39;heap&#39; so it cannot decode pointers. Cause an #error for now if both debug prints and pointer compression are enabled at the same time. Remove duk_debug_hobject.c from make and dist. It was out of date and not used in practice anymore.
10 years ago
#define DUK_HEAPHDR_GET_NEXT(heap,h) \
((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_next16))
#define DUK_HEAPHDR_SET_NEXT(heap,h,val) do { \
(h)->h_next16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) val); \
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
} while (0)
#else
ENC16/DEC16/EXTSTR udata changes Also remove mostly unused old debug code. Debug code doesn&#39;t have access to &#39;heap&#39; so it cannot decode pointers. Cause an #error for now if both debug prints and pointer compression are enabled at the same time. Remove duk_debug_hobject.c from make and dist. It was out of date and not used in practice anymore.
10 years ago
#define DUK_HEAPHDR_GET_NEXT(heap,h) ((h)->h_next)
#define DUK_HEAPHDR_SET_NEXT(heap,h,val) do { \
add a set of heap object headers
12 years ago
(h)->h_next = (val); \
} while (0)
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
#endif
add a set of heap object headers
12 years ago
#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
#if defined(DUK_USE_HEAPPTR16)
ENC16/DEC16/EXTSTR udata changes Also remove mostly unused old debug code. Debug code doesn&#39;t have access to &#39;heap&#39; so it cannot decode pointers. Cause an #error for now if both debug prints and pointer compression are enabled at the same time. Remove duk_debug_hobject.c from make and dist. It was out of date and not used in practice anymore.
10 years ago
#define DUK_HEAPHDR_GET_PREV(heap,h) \
((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_prev16))
#define DUK_HEAPHDR_SET_PREV(heap,h,val) do { \
(h)->h_prev16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (val)); \
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
} while (0)
#else
ENC16/DEC16/EXTSTR udata changes Also remove mostly unused old debug code. Debug code doesn&#39;t have access to &#39;heap&#39; so it cannot decode pointers. Cause an #error for now if both debug prints and pointer compression are enabled at the same time. Remove duk_debug_hobject.c from make and dist. It was out of date and not used in practice anymore.
10 years ago
#define DUK_HEAPHDR_GET_PREV(heap,h) ((h)->h_prev)
#define DUK_HEAPHDR_SET_PREV(heap,h,val) do { \
add a set of heap object headers
12 years ago
(h)->h_prev = (val); \
} while (0)
#endif
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
#endif
add a set of heap object headers
12 years ago
#if defined(DUK_USE_REFERENCE_COUNTING)
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
#if defined(DUK_USE_REFCOUNT16)
#define DUK_HEAPHDR_GET_REFCOUNT(h) ((h)->h_refcount16)
#define DUK_HEAPHDR_SET_REFCOUNT(h,val) do { \
(h)->h_refcount16 = (val); \
} while (0)
#define DUK_HEAPHDR_PREINC_REFCOUNT(h) (++(h)->h_refcount16) /* result: updated refcount */
#define DUK_HEAPHDR_PREDEC_REFCOUNT(h) (--(h)->h_refcount16) /* result: updated refcount */
#else
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_GET_REFCOUNT(h) ((h)->h_refcount)
#define DUK_HEAPHDR_SET_REFCOUNT(h,val) do { \
add a set of heap object headers
12 years ago
(h)->h_refcount = (val); \
} while (0)
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
#define DUK_HEAPHDR_PREINC_REFCOUNT(h) (++(h)->h_refcount) /* result: updated refcount */
#define DUK_HEAPHDR_PREDEC_REFCOUNT(h) (--(h)->h_refcount) /* result: updated refcount */
#endif
add a set of heap object headers
12 years ago
#else
/* refcount macros not defined without refcounting, caller must #ifdef now */
#endif /* DUK_USE_REFERENCE_COUNTING */
/*
* Note: type is treated as a field separate from flags, so some masking is
* involved in the macros below.
*/
Add debugger support to core engine
10 years ago
#define DUK_HEAPHDR_GET_FLAGS_RAW(h) ((h)->h_flags)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_GET_FLAGS(h) ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)
#define DUK_HEAPHDR_SET_FLAGS(h,val) do { \
add a set of heap object headers
12 years ago
(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
} while (0)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_GET_TYPE(h) ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK)
#define DUK_HEAPHDR_SET_TYPE(h,val) do { \
add a set of heap object headers
12 years ago
(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
/* Comparison for type >= DUK_HTYPE_MIN skipped; because DUK_HTYPE_MIN is zero
* and the comparison is unsigned, it's always true and generates warnings.
*/
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_HTYPE_VALID(h) ( \
add a set of heap object headers
12 years ago
DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval) do { \
add a set of heap object headers
12 years ago
(h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
} while (0)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits) do { \
add a set of heap object headers
12 years ago
DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
(h)->h_flags |= (bits); \
} while (0)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits) do { \
add a set of heap object headers
12 years ago
DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
(h)->h_flags &= ~((bits)); \
} while (0)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_CHECK_FLAG_BITS(h,bits) (((h)->h_flags & (bits)) != 0)
add a set of heap object headers
12 years ago
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_REACHABLE(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
#define DUK_HEAPHDR_CLEAR_REACHABLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
#define DUK_HEAPHDR_HAS_REACHABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
add a set of heap object headers
12 years ago
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_TEMPROOT(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
#define DUK_HEAPHDR_CLEAR_TEMPROOT(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
#define DUK_HEAPHDR_HAS_TEMPROOT(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
add a set of heap object headers
12 years ago
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_FINALIZABLE(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
#define DUK_HEAPHDR_CLEAR_FINALIZABLE(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
#define DUK_HEAPHDR_HAS_FINALIZABLE(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
add a set of heap object headers
12 years ago
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_FINALIZED(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
#define DUK_HEAPHDR_CLEAR_FINALIZED(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
#define DUK_HEAPHDR_HAS_FINALIZED(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
add a set of heap object headers
12 years ago
Changes for ROM string/object support
9 years ago
#define DUK_HEAPHDR_SET_READONLY(h) DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
#define DUK_HEAPHDR_CLEAR_READONLY(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
#define DUK_HEAPHDR_HAS_READONLY(h) DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
add a set of heap object headers
12 years ago
/* get or set a range of flags; m=first bit number, n=number of bits */
A round of internal typing fixes (midcommit)
11 years ago
#define DUK_HEAPHDR_GET_FLAG_RANGE(h,m,n) (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL))
add a set of heap object headers
12 years ago
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v) do { \
add a set of heap object headers
12 years ago
(h)->h_flags = \
Avoid some signed shift issues with clang
9 years ago
((h)->h_flags & (~(((1UL << (n)) - 1UL) << (m)))) \
add a set of heap object headers
12 years ago
| ((v) << (m)); \
} while (0)
/* init pointer fields to null */
#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_INIT_NULLS(h) do { \
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
add a set of heap object headers
12 years ago
} while (0)
#else
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_INIT_NULLS(h) do { \
16-bit fields and heap pointer compression work Memory optimization work for very low memory devices (96 to 256kB system RAM). Overall changes are: - 16-bit fields for various internal structures to reduce their size - Heap pointer compression to reduce pointer size to 16 bits When DUK_OPT_LIGHTFUNC_BUILTINS and the new low memory options are enabled, Duktape initial heap memory usage is about 23kB (compared to baseline of about 45kB) on x86. Unless low memory feature options are enabled, there should be no visible changes to Duktape behavior. More detailed changes: - 16-bit changes for duk_heaphdr: pointer compression, refcount - 16-bit changes for duk_hstring: hash, blen, and clen can all be 16 bits, use 0xFFFF as string byte length limit (call sites ensure this limit is never exceeded) - 16-bit changes for duk_hbuffer, use 0xFFFF as buffer length limit - 16-bit fields for hobject size (entry part, array part), drop hash part since it&#39;s not usually needed for extremely low memory environments - 16-bit changes for duk_hcompiledfunction - Heap pointer packing for stringtable - Heap pointer packing for &#39;strs&#39; built-in strings list (saves around 600 to 700 bytes but may not be a good tradeoff because call site size will increase) Other changes: - Heaphdr NULL init fix. The original macros were broken: the double/single linked macro variants were the wrong way around. Now sets through macro to work properly with compressed pointers. - Rename duk_hbuffer CURR_DATA_PTR -&gt; DATA_PTR to reduce macro length (previous name was tediously long) - Rename buffer &#34;usable_size&#34; to &#34;alloc_size&#34; throughout as they have been the same for a while now (they used to differ when buffer had an extra NUL). - Add memory optimization markers to Duktape.env (pointer compression and individual 16-bit field options) - Rename a few internal fields for clarity: duk_hobject &#39;p&#39; to &#39;props&#39;, heap-&gt;st to heap-&gt;strtable - Add a safety check for buffer alloc size (should not be triggered but prevents wrapping if call sites don&#39;t properly check for sizes) - Other minor cleanups
10 years ago
DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
add a set of heap object headers
12 years ago
} while (0)
#endif
clean up #define, #undef, #ifdef etc to have a single space after the directive
11 years ago
#define DUK_HEAPHDR_STRING_INIT_NULLS(h) /* currently nop */
add a set of heap object headers
12 years ago
Add heaphdr linked list consistency asserts
9 years ago
/*
* Assert helpers
*/
/* Check that prev/next links are consistent: if e.g. h->prev is != NULL,
* h->prev->next should point back to h.
*/
Avoid compile warning from linked list asserts
9 years ago
#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_ASSERTIONS)
Add heaphdr linked list consistency asserts
9 years ago
#define DUK_ASSERT_HEAPHDR_LINKS(heap,h) do { \
if ((h) != NULL) { \
duk_heaphdr *h__prev, *h__next; \
h__prev = DUK_HEAPHDR_GET_PREV((heap), (h)); \
h__next = DUK_HEAPHDR_GET_NEXT((heap), (h)); \
DUK_ASSERT(h__prev == NULL || (DUK_HEAPHDR_GET_NEXT((heap), h__prev) == (h))); \
DUK_ASSERT(h__next == NULL || (DUK_HEAPHDR_GET_PREV((heap), h__next) == (h))); \
} \
} while (0)
#else
#define DUK_ASSERT_HEAPHDR_LINKS(heap,h) do {} while (0)
#endif
add a set of heap object headers
12 years ago
/*
* Reference counting helper macros. The macros take a thread argument
* and must thus always be executed in a specific thread context. The
* thread argument is needed for features like finalization. Currently
* it is not required for INCREF, but it is included just in case.
*
* Note that 'raw' macros such as DUK_HEAPHDR_GET_REFCOUNT() are not
* defined without DUK_USE_REFERENCE_COUNTING, so caller must #ifdef
* around them.
*/
#if defined(DUK_USE_REFERENCE_COUNTING)
Changes for ROM string/object support
9 years ago
#if defined(DUK_USE_ROM_OBJECTS)
/* With ROM objects "needs refcount update" is true when the value is
* heap allocated and is not a ROM object.
*/
/* XXX: double evaluation for 'tv' argument. */
#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv) \
(DUK_TVAL_IS_HEAP_ALLOCATED((tv)) && !DUK_HEAPHDR_HAS_READONLY(DUK_TVAL_GET_HEAPHDR((tv))))
#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h) (!DUK_HEAPHDR_HAS_READONLY((h)))
#else /* DUK_USE_ROM_OBJECTS */
/* Without ROM objects "needs refcount update" == is heap allocated. */
#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv) DUK_TVAL_IS_HEAP_ALLOCATED((tv))
#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h) 1
#endif /* DUK_USE_ROM_OBJECTS */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
/* Fast variants, inline refcount operations except for refzero handling.
* Can be used explicitly when speed is always more important than size.
* For a good compiler and a single file build, these are basically the
* same as a forced inline.
*/
#define DUK_TVAL_INCREF_FAST(thr,tv) do { \
duk_tval *duk__tv = (tv); \
DUK_ASSERT(duk__tv != NULL); \
Changes for ROM string/object support
9 years ago
if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
DUK_ASSERT(duk__h != NULL); \
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
} \
} while (0)
#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
duk_tval *duk__tv = (tv); \
DUK_ASSERT(duk__tv != NULL); \
Changes for ROM string/object support
9 years ago
if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
DUK_ASSERT(duk__h != NULL); \
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
Trivial code fixes from review - Add parens for &#39;thr&#39; inside macro body - Remove misplaced assert - Indent trivia in macro body - XXX note on LDINTX
10 years ago
duk_heaphdr_refzero((thr), duk__h); \
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
} \
} \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ_FAST(thr,tv) do { \
duk_tval *duk__tv = (tv); \
DUK_ASSERT(duk__tv != NULL); \
if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
DUK_ASSERT(duk__h != NULL); \
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
duk_heaphdr_refzero_norz((thr), duk__h); \
} \
} \
} while (0)
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
DUK_ASSERT(duk__h != NULL); \
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
Changes for ROM string/object support
9 years ago
if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
} \
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
} while (0)
#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \
duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
DUK_ASSERT(duk__h != NULL); \
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
Changes for ROM string/object support
9 years ago
if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
duk_heaphdr_refzero((thr), duk__h); \
} \
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
} \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ_FAST(thr,h) do { \
duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
DUK_ASSERT(duk__h != NULL); \
DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
duk_heaphdr_refzero_norz((thr), duk__h); \
} \
} while (0)
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
/* Slow variants, call to a helper to reduce code size.
* Can be used explicitly when size is always more important than speed.
*/
#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \
duk_tval_incref((tv)); \
} while (0)
#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \
duk_tval_decref((thr), (tv)); \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ_SLOW(thr,tv) do { \
duk_tval_decref_norz((thr), (tv)); \
} while (0)
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \
duk_heaphdr_incref((duk_heaphdr *) (h)); \
} while (0)
#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \
duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ_SLOW(thr,h) do { \
duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); \
} while (0)
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
/* Default variants. Selection depends on speed/size preference.
* Concretely: with gcc 4.8.1 -Os x64 the difference in final binary
* is about +1kB for _FAST variants.
*/
#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
#define DUK_TVAL_INCREF(thr,tv) DUK_TVAL_INCREF_FAST((thr),(tv))
#define DUK_TVAL_DECREF(thr,tv) DUK_TVAL_DECREF_FAST((thr),(tv))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ(thr,tv) DUK_TVAL_DECREF_NORZ_FAST((thr),(tv))
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF(thr,h) DUK_HEAPHDR_INCREF_FAST((thr),(h))
#define DUK_HEAPHDR_DECREF(thr,h) DUK_HEAPHDR_DECREF_FAST((thr),(h))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ_FAST((thr),(h))
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#else
#define DUK_TVAL_INCREF(thr,tv) DUK_TVAL_INCREF_SLOW((thr),(tv))
#define DUK_TVAL_DECREF(thr,tv) DUK_TVAL_DECREF_SLOW((thr),(tv))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ(thr,tv) DUK_TVAL_DECREF_NORZ_SLOW((thr),(tv))
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF(thr,h) DUK_HEAPHDR_INCREF_SLOW((thr),(h))
#define DUK_HEAPHDR_DECREF(thr,h) DUK_HEAPHDR_DECREF_SLOW((thr),(h))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ_SLOW((thr),(h))
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#endif
/* Casting convenience. */
#define DUK_HSTRING_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
#define DUK_HSTRING_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HSTRING_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) (h))
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HOBJECT_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
#define DUK_HOBJECT_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HOBJECT_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) (h))
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HBUFFER_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
#define DUK_HBUFFER_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HBUFFER_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) (h))
Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -&gt; duk_hcompfunc * duk_hnativefunction -&gt; duk_hnatfunc * duk_hbufferobject -&gt; duk_hbufobj Corresponding renames for all caps defines.
9 years ago
#define DUK_HCOMPFUNC_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
#define DUK_HCOMPFUNC_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HCOMPFUNC_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) &(h)->obj)
Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -&gt; duk_hcompfunc * duk_hnativefunction -&gt; duk_hnatfunc * duk_hbufferobject -&gt; duk_hbufobj Corresponding renames for all caps defines.
9 years ago
#define DUK_HNATFUNC_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
#define DUK_HNATFUNC_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HNATFUNC_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) &(h)->obj)
Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -&gt; duk_hcompfunc * duk_hnativefunction -&gt; duk_hnatfunc * duk_hbufferobject -&gt; duk_hbufobj Corresponding renames for all caps defines.
9 years ago
#define DUK_HBUFOBJ_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
#define DUK_HBUFOBJ_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HBUFOB_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) &(h)->obj)
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HTHREAD_INCREF(thr,h) DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
#define DUK_HTHREAD_DECREF(thr,h) DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HTHREAD_DECREF_NORZ(thr,h) DUK_HEAPHDR_DECREF_NORZ((thr),(duk_heaphdr *) &(h)->obj)
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
/* Convenience for some situations; the above macros don't allow NULLs
* for performance reasons.
*/
#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
if ((h) != NULL) { \
DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
} \
} while (0)
#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
if ((h) != NULL) { \
DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
} \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr,h) do { \
if ((h) != NULL) { \
DUK_HEAPHDR_DECREF_NORZ((thr), (duk_heaphdr *) (h)); \
} \
} while (0)
/* Free pending refzero entries; quick check to avoid call because often
* the queue is empty.
*/
#define DUK_REFZERO_CHECK(thr) do { \
if ((thr)->heap->refzero_list != NULL) { \
duk_refzero_free_pending((thr)); \
} \
} while (0)
add a set of heap object headers
12 years ago
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
/*
* Macros to set a duk_tval and update refcount of the target (decref the
* old value and incref the new value if necessary). This is both performance
* and footprint critical; any changes made should be measured for size/speed.
*/
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
DUK_TVAL_SET_UNDEFINED(tv__dst); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0(thr,tvptr_dst) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_UNDEFINED(tv__dst); \
DUK_TVAL_DECREF_NORZ((thr), &tv__tmp); \
} while (0)
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
DUK_TVAL_SET_UNUSED(tv__dst); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_NULL(tv__dst); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_NAN(tv__dst); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
#if defined(DUK_USE_FASTINT)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I48_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
DUK_TVAL_SET_I48(tv__dst, (newval)); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
DUK_TVAL_SET_I32(tv__dst, (newval)); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
DUK_TVAL_SET_U32(tv__dst, (newval)); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Add duk_tval fastint macros when fastints disabled For example, add DUK_TVAL_SET_FASTINT_U32() which, when fastints are disabled, simply coerces its argument to a double. This reduces the number of ifdefs required in calling code when the argument would need to be cast anyway.
9 years ago
#else
#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#endif /* DUK_USE_FASTINT */
#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_STRING(tv__dst, (newval)); \
DUK_HSTRING_INCREF((thr), (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
DUK_HOBJECT_INCREF((thr), (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
DUK_HBUFFER_INCREF((thr), (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
/* DUK_TVAL_SET_TVAL_UPDREF() is used a lot in executor, property lookups,
DUK_TVAL_SET_TVAL_UPDREF() macro optimization
9 years ago
* etc, so it's very important for performance. Measure when changing.
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
*
* NOTE: the source and destination duk_tval pointers may be the same, and
* the macros MUST deal with that correctly.
*/
DUK_TVAL_SET_TVAL_UPDREF() macro optimization
9 years ago
/* Original idiom used, minimal code size. */
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \
tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
DUK_TVAL_INCREF((thr), tv__src); \
DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
} while (0)
DUK_TVAL_SET_TVAL_UPDREF() macro optimization
9 years ago
/* Faster alternative: avoid making a temporary copy of tvptr_dst and use
* fast incref/decref macros.
*/
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr,tvptr_dst,tvptr_src) do { \
duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \
tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
DUK_TVAL_INCREF_FAST((thr), tv__src); \
Changes for ROM string/object support
9 years ago
if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv__dst)) { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \
DUK_ASSERT(h__obj != NULL); \
DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
DUK_HEAPHDR_DECREF_FAST((thr), h__obj); /* side effects */ \
} else { \
DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
} \
} while (0)
/* XXX: no optimized variants yet */
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNDEFINED_UPDREF DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNUSED_UPDREF DUK_TVAL_SET_UNUSED_UPDREF_ALT0
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_NULL_UPDREF DUK_TVAL_SET_NULL_UPDREF_ALT0
#define DUK_TVAL_SET_BOOLEAN_UPDREF DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
#define DUK_TVAL_SET_NUMBER_UPDREF DUK_TVAL_SET_NUMBER_UPDREF_ALT0
#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
#define DUK_TVAL_SET_DOUBLE_UPDREF DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
#define DUK_TVAL_SET_NAN_UPDREF DUK_TVAL_SET_NAN_UPDREF_ALT0
#if defined(DUK_USE_FASTINT)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_I48_UPDREF_ALT0
#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_I32_UPDREF_ALT0
#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_U32_UPDREF_ALT0
Add duk_tval fastint macros when fastints disabled For example, add DUK_TVAL_SET_FASTINT_U32() which, when fastints are disabled, simply coerces its argument to a double. This reduces the number of ifdefs required in calling code when the argument would need to be cast anyway.
9 years ago
#else
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast int-to-double */
#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#endif /* DUK_USE_FASTINT */
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_FASTINT_UPDREF DUK_TVAL_SET_I48_UPDREF /* convenience */
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
#define DUK_TVAL_SET_STRING_UPDREF DUK_TVAL_SET_STRING_UPDREF_ALT0
#define DUK_TVAL_SET_OBJECT_UPDREF DUK_TVAL_SET_OBJECT_UPDREF_ALT0
#define DUK_TVAL_SET_BUFFER_UPDREF DUK_TVAL_SET_BUFFER_UPDREF_ALT0
#define DUK_TVAL_SET_POINTER_UPDREF DUK_TVAL_SET_POINTER_UPDREF_ALT0
#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
/* Optimized for speed. */
DUK_TVAL_SET_TVAL_UPDREF() macro optimization
9 years ago
#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT1
#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT1
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0
#else
/* Optimized for size. */
#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT0
#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT0
#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0
#endif
add a set of heap object headers
12 years ago
#else /* DUK_USE_REFERENCE_COUNTING */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_TVAL_INCREF_FAST(thr,v) do {} while (0) /* nop */
#define DUK_TVAL_DECREF_FAST(thr,v) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ_FAST(thr,v) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_TVAL_INCREF_SLOW(thr,v) do {} while (0) /* nop */
#define DUK_TVAL_DECREF_SLOW(thr,v) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ_SLOW(thr,v) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_TVAL_INCREF(thr,v) do {} while (0) /* nop */
#define DUK_TVAL_DECREF(thr,v) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_TVAL_DECREF_NORZ(thr,v) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF_FAST(thr,h) do {} while (0) /* nop */
#define DUK_HEAPHDR_DECREF_FAST(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ_FAST(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do {} while (0) /* nop */
#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ_SLOW(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HEAPHDR_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HEAPHDR_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HEAPHDR_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HSTRING_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HSTRING_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HSTRING_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HOBJECT_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HOBJECT_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HOBJECT_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HBUFFER_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HBUFFER_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HBUFFER_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -&gt; duk_hcompfunc * duk_hnativefunction -&gt; duk_hnatfunc * duk_hbufferobject -&gt; duk_hbufobj Corresponding renames for all caps defines.
9 years ago
#define DUK_HCOMPFUNC_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HCOMPFUNC_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HCOMPFUNC_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -&gt; duk_hcompfunc * duk_hnativefunction -&gt; duk_hnatfunc * duk_hbufferobject -&gt; duk_hbufobj Corresponding renames for all caps defines.
9 years ago
#define DUK_HNATFUNC_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HNATFUNC_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HNATFUNC_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Rename internal struct/define names Improve readability by doing the following renames: * duk_hcompiledfunction -&gt; duk_hcompfunc * duk_hnativefunction -&gt; duk_hnatfunc * duk_hbufferobject -&gt; duk_hbufobj Corresponding renames for all caps defines.
9 years ago
#define DUK_HBUFOBJ_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HBUFOBJ_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HBUFOBJ_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HTHREAD_INCREF(thr,h) do {} while (0) /* nop */
#define DUK_HTHREAD_DECREF(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HTHREAD_DECREF_NORZ(thr,h) do {} while (0) /* nop */
Refcount update directly (inline) in refc macros Also remove the NULL check for refcounts: call sites where a NULL target value (duk_tval * or duk_heaphdr *) may occur must use a NULL-tolerant variant explicitly. This is for performance and to reduce call site size when the refcount operations are inlined. Using inline macros is basically the same as a forced inline when using a good compiler and the single source file model. Macros make this more portable, and will allow refcount updates to happen even directly from Duktape API macros later.
10 years ago
#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do {} while (0) /* nop */
#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do {} while (0) /* nop */
Add some NORZ (no-refzero free) refcount macros
9 years ago
#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr,h) do {} while (0) /* nop */
#define DUK_REFZERO_CHECK(thr) do {} while (0) /* nop */
add a set of heap object headers
12 years ago
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
DUK_TVAL_SET_UNDEFINED(tv__dst); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_UNREF((thr)); \
} while (0)
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
DUK_TVAL_SET_UNUSED(tv__dst); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_NULL(tv__dst); \
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_NAN(tv__dst); \
DUK_UNREF((thr)); \
} while (0)
#if defined(DUK_USE_FASTINT)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I48_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
DUK_TVAL_SET_I48(tv__dst, (newval)); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_UNREF((thr)); \
} while (0)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
DUK_TVAL_SET_I32(tv__dst, (newval)); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_UNREF((thr)); \
} while (0)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
DUK_TVAL_SET_U32(tv__dst, (newval)); \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
DUK_UNREF((thr)); \
} while (0)
Add duk_tval fastint macros when fastints disabled For example, add DUK_TVAL_SET_FASTINT_U32() which, when fastints are disabled, simply coerces its argument to a double. This reduces the number of ifdefs required in calling code when the argument would need to be cast anyway.
9 years ago
#else
#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#endif /* DUK_USE_FASTINT */
#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
DUK_UNREF((thr)); \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_STRING(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
Tval refcount macro name typo fixes
9 years ago
#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
duk_tval *tv__dst; tv__dst = (tvptr_dst); \
DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
DUK_UNREF((thr)); \
} while (0)
#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
duk_tval *tv__dst, *tv__src; \
tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
DUK_UNREF((thr)); \
} while (0)
Separate (marker) unused tag Reorder tags to accommodate a separate &#39;unused&#39; tag so that &#39;undefined&#39; can become a single tag write (instead of tag + value like booleans). This is good because &#39;undefined&#39; values are involved in e.g. value stack resizes and are performance relevant. Also reorder tags so that &#34;is heap allocated&#34; check can be a single bit test instead of a comparison when using non-packed duk_tval. This makes every DECREF potentially faster because an &#34;is heap allocated&#34; test appears in every DECREF. Because &#34;unused&#34; is not intended to appear anywhere in actual use (e.g. as a value stack value, as a property value, etc), &#34;unused&#34; values will fall into the default clause of DUK_TAG_xxx switch case statements. Add an assert to every such default clause that the value is not intended to be &#34;unused&#34;. Remove duk_push_unused() as it should no longer be used. It was only used by the debugger protocol; refuse an inbound &#34;unused&#34; value in the debugger. This is not breaking compatibility because there was no legitimate usage for the debug client sending requests with &#34;unused&#34; values.
9 years ago
#define DUK_TVAL_SET_UNDEFINED_UPDREF DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
#define DUK_TVAL_SET_UNUSED_UPDREF DUK_TVAL_SET_UNUSED_UPDREF_ALT0
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_NULL_UPDREF DUK_TVAL_SET_NULL_UPDREF_ALT0
#define DUK_TVAL_SET_BOOLEAN_UPDREF DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
#define DUK_TVAL_SET_NUMBER_UPDREF DUK_TVAL_SET_NUMBER_UPDREF_ALT0
#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
#define DUK_TVAL_SET_DOUBLE_UPDREF DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
#define DUK_TVAL_SET_NAN_UPDREF DUK_TVAL_SET_NAN_UPDREF_ALT0
#if defined(DUK_USE_FASTINT)
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_I48_UPDREF_ALT0
#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_I32_UPDREF_ALT0
#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_U32_UPDREF_ALT0
Add duk_tval fastint macros when fastints disabled For example, add DUK_TVAL_SET_FASTINT_U32() which, when fastints are disabled, simply coerces its argument to a double. This reduces the number of ifdefs required in calling code when the argument would need to be cast anyway.
9 years ago
#else
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast-int-to-double */
#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#endif /* DUK_USE_FASTINT */
Rework duk_tval fastint/int macros * Rename fastint macros so that e.g. DUK_SET_FASTINT_U32() becomes simply DUK_SET_U32(). This makes more sense because the macros are also enabled without fastint support. Right now the macros will just cast e.g. a uint32 to a double and set it to the duk_tval, but that operation can be optimized even when fastints are not present.
9 years ago
#define DUK_TVAL_SET_FASTINT_UPDREF DUK_TVAL_SET_I48_UPDREF /* convenience */
Add DUK_TVAL_SET_xxx_UPDREF macros These replace the much repeated idiom: duk_tval tv_tmp; DUK_TVAL_SET_TVAL(&amp;tv_tmp, tv_dst); DUK_TVAL_SET_TVAL(tv_dst, tv_src); DUK_TVAL_INCREF(thr, tv_src); DUK_TVAL_DECREF(thr, &amp;tv_tmp); /* side effects */ with (e.g.): DUK_TVAL_SET_TVAL_UPDREF(thr, tv_dst, tv_src); This reduces line count, and also allows the set-and-update-refcount sequence to be optimized in detail.
9 years ago
#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
#define DUK_TVAL_SET_STRING_UPDREF DUK_TVAL_SET_STRING_UPDREF_ALT0
#define DUK_TVAL_SET_OBJECT_UPDREF DUK_TVAL_SET_OBJECT_UPDREF_ALT0
#define DUK_TVAL_SET_BUFFER_UPDREF DUK_TVAL_SET_BUFFER_UPDREF_ALT0
#define DUK_TVAL_SET_POINTER_UPDREF DUK_TVAL_SET_POINTER_UPDREF_ALT0
#define DUK_TVAL_SET_TVAL_UPDREF DUK_TVAL_SET_TVAL_UPDREF_ALT0
#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT0
#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0
add a set of heap object headers
12 years ago
#endif /* DUK_USE_REFERENCE_COUNTING */
fix include guard names, don&#39;t use leading underscores as they are reserved
12 years ago
#endif /* DUK_HEAPHDR_H_INCLUDED */