duktape

Commit Graph

Author	SHA1	Message	Date
Sami Vaarala	96d301b3cb	Rename src/ to src-input/ to match dist With this change the directory naming in the main repo and dist is the same.	8 years ago
Sami Vaarala	2e825bc2ee	Remove unused opcode flag define	8 years ago
Sami Vaarala	75c57ad6f4	Rework executor to use a single level dispatch Change dispatch to use an 8-bit main opcode instead of a 6-bit one. This removes the need for "EXTRA" opcodes and a secondary switch clause in the executor dispatch loop. The new opcode layout uses four 8-bit fields: opcode, A, B, C. The previous reg/const concept which used 9-bit B and C fields, with the top bit reserved to denote reg vs const, is now implemented by using four consecutive opcode slots and moving the B and C reg/const flags into the opcode. For example: ADD_RR reg(A) <- reg(B) + reg(C) ADD_CR reg(A) <- const(B) + reg(C) ADD_RC reg(A) <- reg(B) + const(C) ADD_CC reg(A) <- const(B) + const(C) From a footprint standpoint this allows the executor to remain roughly the same size: four dispatched opcodes (each a function pointer in a compiled jump table) point to the same case clause handler, which does the reg/const decision based on an instruction bit test as before. However, when performance is more important than footprint, each reg/const case can be handled separately in the executor so that there's no longer a reg/const check when the opcode executes. Note that not all opcodes require a reg/const qualifier, so that opcode space is effectively increased even if reg/const opcodes consume multiple entries from the opcode table. Other minor changes: * Optimize behavior of several opcodes to e.g. avoid unnecessary support for shuffling/indirection when wider register arguments are now available.	8 years ago
Sami Vaarala	173f3c75e5	Simplify call handling opcodes a bit * Remove CSPROP(I) opcode. CSPROP usually leads to three opcodes, e.g. LDREG + LDCONST + CSPROP. Direct loads for 'base[key]' and 'base' has the same effect with one opcode shorter bytecode and no need for a separate CSPROP opcode. * Remove CSREGI (indirect) opcode, simplify CSREG opcode a bit. Extend CSREG base register argument to be wider (BC) so that shuffling is not needed in practice. * Remove CSVARI (indirect) opcode and handle its equivalent by using explicit shuffling in the compiler. This removes one opcode, and indirect target check from CSVAR. * Remove NEWI and extend base register argument of NEW to be wider (BC) so that shuffling is not needed in practice. * Remove CALLI, and split CALL into CALL, TAILCALL, and EVALCALL. This eliminates the flags field (A) and allows the base register to be wider (BC), eliminating the need for shuffling in practice. * Maximum argument count to constructor and ordinary calls drops from 511 to 255 with this change.	9 years ago
Sami Vaarala	5910806f28	Use single shift+mask in executor reg/const access Instead of decoding a field (say A) and then computing DUK__REGP which involves further shifting of the value, add macros such as DUK__REGP_A(ins) which operate directly on the 32-bit 'ins' and use a single shift+mask to get the byte offset (rather than element offset) for the target reg/const. Technically the compiler should be able to do this, but in practice at least gcc -O2 won't.	9 years ago
Sami Vaarala	d31ec37fc5	Handle RETURN opcode without longjmp	9 years ago
Sami Vaarala	3aa7edbb41	Use direct bytecode pointer to improve performance	10 years ago
Sami Vaarala	c281a7e8a0	Rework pre/post inc/dec in compiler and executor Pre/post inc/dec are an important fast path for fastints. Reimplement these operations as atomic opcodes so that fast pathing is easier. Opcodes emitted for typical loop constructs are also reduced by the change. Several opcodes were moved to extraops to make space for the 12 pre/post inc/dec reg/var/prop variants, and the compiler was changed to support two-argument (dest, dest, src) extraop arithmetic for its ispec/ivalue. Example of bytecode change, in Duktape 1.1.0: function foo() { var x = 10; print(x++, x++, x--, x--, x--); print(x); } BC 0000: LDINT 0, 10, 256 ; 0x80028003 op=3 (LDINT) a=0 b=10 c=256 BC 0001: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0002: LDREG 3, 0, 0 ; 0x000000c0 op=0 (LDREG) a=3 b=0 c=0 BC 0003: TONUM 3, 3 ; 0x0180c2fe op=62 (EXTRA) a=11 b=3 c=3 BC 0004: INC 0, 3 ; 0x0180067e op=62 (EXTRA) a=25 b=0 c=3 BC 0005: LDREG 4, 0, 0 ; 0x00000100 op=0 (LDREG) a=4 b=0 c=0 BC 0006: TONUM 4, 4 ; 0x020102fe op=62 (EXTRA) a=11 b=4 c=4 BC 0007: INC 0, 4 ; 0x0200067e op=62 (EXTRA) a=25 b=0 c=4 BC 0008: LDREG 5, 0, 0 ; 0x00000140 op=0 (LDREG) a=5 b=0 c=0 BC 0009: TONUM 5, 5 ; 0x028142fe op=62 (EXTRA) a=11 b=5 c=5 BC 0010: DEC 0, 5 ; 0x028006be op=62 (EXTRA) a=26 b=0 c=5 BC 0011: LDREG 6, 0, 0 ; 0x00000180 op=0 (LDREG) a=6 b=0 c=0 BC 0012: TONUM 6, 6 ; 0x030182fe op=62 (EXTRA) a=11 b=6 c=6 BC 0013: DEC 0, 6 ; 0x030006be op=62 (EXTRA) a=26 b=0 c=6 BC 0014: LDREG 7, 0, 0 ; 0x000001c0 op=0 (LDREG) a=7 b=0 c=0 BC 0015: TONUM 7, 7 ; 0x0381c2fe op=62 (EXTRA) a=11 b=7 c=7 BC 0016: DEC 0, 7 ; 0x038006be op=62 (EXTRA) a=26 b=0 c=7 BC 0017: CALL 0, 1, 5 ; 0x02804034 op=52 (CALL) a=0 b=1 c=5 BC 0018: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0019: LDREG 3, 0, 0 ; 0x000000c0 op=0 (LDREG) a=3 b=0 c=0 BC 0020: CALL 0, 1, 1 ; 0x00804034 op=52 (CALL) a=0 b=1 c=1 BC 0021: RETURN 1, 0, 0 ; 0x00000073 op=51 (RETURN) a=1 b=0 c=0 After this commit: function foo() { var x = 10; print(x++, x++, x--, x--, x--); print(x); } BC 0000: LDINT 0, 10, 256 ; 0x80028003 op=3 (LDINT) a=0 b=10 c=256 BC 0001: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0002: POSTINC 3, 0, 0 ; 0x000000f9 op=57 (POSTINC) a=3 b=0 c=0 BC 0003: POSTINC 4, 0, 0 ; 0x00000139 op=57 (POSTINC) a=4 b=0 c=0 BC 0004: POSTDEC 5, 0, 0 ; 0x0000017c op=60 (POSTDEC) a=5 b=0 c=0 BC 0005: POSTDEC 6, 0, 0 ; 0x000001bc op=60 (POSTDEC) a=6 b=0 c=0 BC 0006: POSTDEC 7, 0, 0 ; 0x000001fc op=60 (POSTDEC) a=7 b=0 c=0 BC 0007: CALL 0, 1, 5 ; 0x02804030 op=48 (CALL) a=0 b=1 c=5 BC 0008: CSVAR 1, 256, 0 ; 0x00400052 op=18 (CSVAR) a=1 b=256 c=0 BC 0009: LDREG 3, 0, 0 ; 0x000000c0 op=0 (LDREG) a=3 b=0 c=0 BC 0010: CALL 0, 1, 1 ; 0x00804030 op=48 (CALL) a=0 b=1 c=1 BC 0011: RETURN 1, 0, 0 ; 0x0000006f op=47 (RETURN) a=1 b=0 c=0 For an empty for-loop, in Duktape 1.1.0: function foo() { for (var i = 0; i < 1000; i++) {} } BC 0000: LABEL 0, 0, 0 ; 0x00000036 op=54 (LABEL) a=0 b=0 c=0 BC 0001: JUMP 11 (to pc+12) ; 0x800002f2 op=50 (JUMP) a=11 b=0 c=256 BC 0002: JUMP 5 (to pc+6) ; 0x80000172 op=50 (JUMP) a=5 b=0 c=256 BC 0003: LDINT 0, 0, 256 ; 0x80000003 op=3 (LDINT) a=0 b=0 c=256 BC 0004: LT 1, 0, 256 ; 0x8000006d op=45 (LT) a=1 b=0 c=256 BC 0005: IF 0, 1, 0 ; 0x0000402f op=47 (IF) a=0 b=1 c=0 BC 0006: JUMP 1 (to pc+2) ; 0x80000072 op=50 (JUMP) a=1 b=0 c=256 BC 0007: JUMP 5 (to pc+6) ; 0x80000172 op=50 (JUMP) a=5 b=0 c=256 BC 0008: LDREG 1, 0, 0 ; 0x00000040 op=0 (LDREG) a=1 b=0 c=0 BC 0009: TONUM 1, 1 ; 0x008042fe op=62 (EXTRA) a=11 b=1 c=1 BC 0010: INC 0, 1 ; 0x0080067e op=62 (EXTRA) a=25 b=0 c=1 BC 0011: JUMP -8 (to pc-7) ; 0x7ffffe32 op=50 (JUMP) a=248 b=511 c=255 BC 0012: JUMP -5 (to pc-4) ; 0x7ffffef2 op=50 (JUMP) a=251 b=511 c=255 BC 0013: ENDLABEL 0, 0, 0 ; 0x00000037 op=55 (ENDLABEL) a=0 b=0 c=0 BC 0014: RETURN 1, 0, 0 ; 0x00000073 op=51 (RETURN) a=1 b=0 c=0 After this commit: function foo() { for (var i = 0; i < 1000; i++) {} } BC 0000: LABEL 0, 0 ; 0x0000083f op=63 (EXTRA) a=32 b=0 c=0 BC 0001: JUMP 9 (to pc+10) ; 0x8000026e op=46 (JUMP) a=9 b=0 c=256 BC 0002: JUMP 5 (to pc+6) ; 0x8000016e op=46 (JUMP) a=5 b=0 c=256 BC 0003: LDINT 0, 0, 256 ; 0x80000003 op=3 (LDINT) a=0 b=0 c=256 BC 0004: LT 1, 0, 256 ; 0x8000006b op=43 (LT) a=1 b=0 c=256 BC 0005: IF 0, 1, 0 ; 0x0000402d op=45 (IF) a=0 b=1 c=0 BC 0006: JUMP 1 (to pc+2) ; 0x8000006e op=46 (JUMP) a=1 b=0 c=256 BC 0007: JUMP 3 (to pc+4) ; 0x800000ee op=46 (JUMP) a=3 b=0 c=256 BC 0008: POSTINC 1, 0, 0 ; 0x00000079 op=57 (POSTINC) a=1 b=0 c=0 BC 0009: JUMP -6 (to pc-5) ; 0x7ffffeae op=46 (JUMP) a=250 b=511 c=255 BC 0010: JUMP -3 (to pc-2) ; 0x7fffff6e op=46 (JUMP) a=253 b=511 c=255 BC 0011: ENDLABEL 0, 0 ; 0x0000087f op=63 (EXTRA) a=33 b=0 c=0 BC 0012: RETURN 1, 0, 0 ; 0x0000006f op=47 (RETURN) a=1 b=0 c=0	10 years ago
Sami Vaarala	5c22523ebf	Add debugger support to core engine	10 years ago
Sami Vaarala	36494812ed	ENC16/DEC16/EXTSTR udata changes Also remove mostly unused old debug code. Debug code doesn't have access to 'heap' 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
Sami Vaarala	f5ee49d713	Fix trailing newline offenders in src	10 years ago
Sami Vaarala	3ab572de8a	Code policy issue fix trivia	10 years ago
Sami Vaarala	ddd0619f78	Intermediate commit of compiler typing cleanup	10 years ago
Sami Vaarala	baf7ef34a0	remove DUK_OP_DEBUG and move debug opcodes under DUK_OP_EXTRA	11 years ago
Sami Vaarala	59b5591e5a	large expression fixes for INITSET/INITGET (which now have indirect variants) and PUTVAR	11 years ago
Sami Vaarala	1b36288b1f	move INC, DEC, UNM, UNP to extraops to make room for MPUTARRI, MPUTOBJI (indirect variants); add shuffling special handling for MPUTARRI and MPUTOBJI to allow literals in large expressions	11 years ago
Sami Vaarala	70aae61dd9	add indirect variants of call related opcodes: CALL, NEW, CSVAR; CSREG, CSPROP	11 years ago
Sami Vaarala	7049399008	change emit_loadint to support full 32-bit signed range, add support for emitting LDINT+LDINTX for larger constants	11 years ago
Sami Vaarala	9fa1ec592d	clean up #define, #undef, #ifdef etc to have a single space after the directive	11 years ago
Sami Vaarala	761ef90976	first step to reducing temp/const limits through automatic shuffling; compiler fixes: change INTERNAL errors to RANGE errors when limits reached, normalize constant folding NaNs, recursion value stack check for expressions, do-while continue label target fix, larger limit for compiler recursion with deep stack mode	11 years ago
Sami Vaarala	cbe678f1d8	bytecode constant trivia	11 years ago
Sami Vaarala	884045b1d1	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
Sami Vaarala	c3330cc908	clean up duk_features.h / duk_internal.h split; merge very small duk_rdtsc.h and duk_bittypes.h to duk_features.h to make duk_features.h the only place where platform specific stuff is handled	11 years ago
Sami Vaarala	d8130dd23c	split extraop LDBOOL into LDTRUE/LDFALSE and increase its constant range (use BC instead of just B for const index)	11 years ago
Sami Vaarala	4862b7aa49	fix include guard names, don't use leading underscores as they are reserved	12 years ago
Sami Vaarala	68689d09a7	fix handling of re-declaration of a global function when the offending existing property is in an ancestor; this needs to be reworked later as it is now quite awkward	12 years ago
Sami Vaarala	dd83ee1a0e	executor bytecode header	12 years ago

1 Commits (84131700dfd32d9d1063f99b5b0a900f5935a613)