From 639dfad3ae2a478652a399986b03e5eec219eab1 Mon Sep 17 00:00:00 2001 From: Nickolas Lloyd Date: Fri, 30 Dec 2016 23:19:14 -0500 Subject: [PATCH] ; Make JIT compilation loop more readable. ; * src/bytecode-jit.c (jit_byte_code__): Condense cases using JIT_CALL_STACK_N and JIT_CALL_STACK_MANY. ; * src/bytecode.h: Define function called and number of stack items for each bytecode instruction. --- src/bytecode-jit.c | 825 +++++++++------------------------------------ src/bytecode.c | 1 - src/bytecode.h | 353 +++++++++---------- 3 files changed, 342 insertions(+), 837 deletions(-) diff --git a/src/bytecode-jit.c b/src/bytecode-jit.c index 91924d63cbf..60984478f33 100644 --- a/src/bytecode-jit.c +++ b/src/bytecode-jit.c @@ -777,6 +777,23 @@ void jit_call_with_stack_many (struct emacs_jit_context *ctxt, void *f, #undef JIT_CONSTANT +struct { + void * const ptr; + const char * const name; + int n; +} functions[256] = { +#undef DEFINE_FIXED +#define DEFINE_FIXED(bname, value, fname, num) \ + [value] = { .ptr = (void *)(&fname), .name = #fname, .n = num }, +#define DEFINE(bname, value) + + BYTE_CODES + +#undef DEFINE_FIXED +#undef DEFINE +#define DEFINE_FIXED(bname, value, fname, num) DEFINE (bname, value) +}; + void jit_byte_code__ (Lisp_Object byte_code) { @@ -979,6 +996,129 @@ jit_byte_code__ (Lisp_Object byte_code) FIRST { + CASE (Bcall): + CASE (Bcall1): + CASE (Bcall2): + CASE (Bcall3): + CASE (Bcall4): + CASE (Bcall5): + CASE (Bcall6): + CASE (Bcall7): + CASE (Blist3): + CASE (Blist4): + CASE (BlistN): + CASE (Bconcat2): + CASE (Bconcat3): + CASE (Bconcat4): + CASE (BconcatN): + CASE (Bdiff): + CASE (Bplus): + CASE (Bmax): + CASE (Bmin): + CASE (Bmult): + CASE (Bquo): + CASE (Binsert): + CASE (BinsertN): + CASE (Bnconc): + { + int args = functions[op].n; + if (args < 0) + { + if (args == -1) + args = FETCH; + else if (args == -2) + args = FETCH2; + if (op == Bcall6 || op == Bcall7) + args += 1; + } + JIT_NEED_STACK; + jit_call_with_stack_many (&ctxt, functions[op].ptr, + functions[op].name, args); + JIT_NEXT; + NEXT; + } + CASE (Blist1): + CASE (Blist2): + CASE (Bcar): + CASE (Beq): + CASE (Bmemq): + CASE (Bcdr): + CASE (Bsave_window_excursion): /* Obsolete since 24.1. */ + CASE (Bcatch): /* Obsolete since 24.4. */ + CASE (Bcondition_case): /* Obsolete since 24.4. */ + CASE (Btemp_output_buffer_setup): /* Obsolete since 24.1. */ + CASE (Bnth): + CASE (Bsymbolp): + CASE (Bconsp): + CASE (Bstringp): + CASE (Blistp): + CASE (Bnot): + CASE (Bcons): + CASE (Blength): + CASE (Baref): + CASE (Baset): + CASE (Bsymbol_value): + CASE (Bsymbol_function): + CASE (Bset): + CASE (Bfset): + CASE (Bget): + CASE (Bsubstring): + CASE (Beqlsign): + CASE (Bnegate): + CASE (Brem): + CASE (Bpoint): + CASE (Bgoto_char): + CASE (Bpoint_max): + CASE (Bpoint_min): + CASE (Bchar_after): + CASE (Bfollowing_char): + CASE (Bpreceding_char): + CASE (Bcurrent_column): + CASE (Beolp): + CASE (Beobp): + CASE (Bbolp): + CASE (Bbobp): + CASE (Bcurrent_buffer): + CASE (Bset_buffer): + CASE (Binteractive_p): /* Obsolete since 24.1. */ + CASE (Bforward_char): + CASE (Bforward_word): + CASE (Bskip_chars_forward): + CASE (Bskip_chars_backward): + CASE (Bforward_line): + CASE (Bchar_syntax): + CASE (Bbuffer_substring): + CASE (Bdelete_region): + CASE (Bnarrow_to_region): + CASE (Bwiden): + CASE (Bend_of_line): + CASE (Bset_marker): + CASE (Bmatch_beginning): + CASE (Bmatch_end): + CASE (Bupcase): + CASE (Bdowncase): + CASE (Bstringeqlsign): + CASE (Bstringlss): + CASE (Bequal): + CASE (Bnthcdr): + CASE (Belt): + CASE (Bmember): + CASE (Bassq): + CASE (Bnreverse): + CASE (Bsetcar): + CASE (Bsetcdr): + CASE (Bcar_safe): + CASE (Bcdr_safe): + CASE (Bnumberp): + CASE (Bintegerp): + { + JIT_NEED_STACK; + jit_call_with_stack_n (&ctxt, functions[op].ptr, + functions[op].name, functions[op].n); + JIT_NEXT; + NEXT; + } + CASE (Bvarref7): op = FETCH2; goto varref; @@ -1005,34 +1145,6 @@ jit_byte_code__ (Lisp_Object byte_code) NEXT; } - CASE (Bcar): - { - JIT_CALL_WITH_STACK_N (native_car, 1); - JIT_NEXT; - NEXT; - } - - CASE (Beq): - { - JIT_CALL_WITH_STACK_N (native_eq, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bmemq): - { - JIT_CALL_WITH_STACK_N (native_memq, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bcdr): - { - JIT_CALL_WITH_STACK_N (native_cdr, 1); - JIT_NEXT; - NEXT; - } - CASE (Bvarset): CASE (Bvarset1): CASE (Bvarset2): @@ -1095,28 +1207,6 @@ jit_byte_code__ (Lisp_Object byte_code) NEXT; } - CASE (Bcall6): - op = FETCH; - goto docall; - - CASE (Bcall7): - op = FETCH2; - goto docall; - - CASE (Bcall): - CASE (Bcall1): - CASE (Bcall2): - CASE (Bcall3): - CASE (Bcall4): - CASE (Bcall5): - op -= Bcall; - docall: - { - JIT_NEED_STACK; - JIT_CALL_WITH_STACK_MANY (Ffuncall, op + 1); - JIT_NEXT; - NEXT; - } CASE (Bunbind6): op = FETCH; @@ -1263,25 +1353,11 @@ jit_byte_code__ (Lisp_Object byte_code) NEXT; } - CASE (Bsave_window_excursion): /* Obsolete since 24.1. */ - { - JIT_CALL_WITH_STACK_N (native_save_window_excursion, 1); - JIT_NEXT; - NEXT; - } - CASE (Bsave_restriction): JIT_CALL (native_save_restriction, NULL, 0); JIT_NEXT; NEXT; - CASE (Bcatch): /* Obsolete since 24.4. */ - { - JIT_CALL_WITH_STACK_N (native_catch, 2); - JIT_NEXT; - NEXT; - } - CASE (Bpushcatch): /* New in 24.4. */ type = CATCHER; goto pushhandler; @@ -1337,21 +1413,6 @@ jit_byte_code__ (Lisp_Object byte_code) NEXT; } - CASE (Bcondition_case): /* Obsolete since 24.4. */ - { - JIT_CALL_WITH_STACK_N (internal_lisp_condition_case, 3); - JIT_NEXT; - NEXT; - } - - CASE (Btemp_output_buffer_setup): /* Obsolete since 24.1. */ - { - JIT_NEED_STACK; - JIT_CALL_WITH_STACK_N (native_temp_output_buffer_setup, 1); - JIT_NEXT; - NEXT; - } - CASE (Btemp_output_buffer_show): /* Obsolete since 24.1. */ { jit_type_t temp_output_buffer_show_sig; @@ -1371,339 +1432,47 @@ jit_byte_code__ (Lisp_Object byte_code) NEXT; } - CASE (Bnth): - { - JIT_CALL_WITH_STACK_N (native_nth, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bsymbolp): - CASE (Bconsp): - CASE (Bstringp): - CASE (Blistp): - CASE (Bnot): + CASE (Bsub1): { JIT_NEED_STACK; - switch (op) - { - case Bsymbolp: - JIT_CALL_WITH_STACK_N (native_symbolp, 1); - break; - case Bconsp: - JIT_CALL_WITH_STACK_N (native_consp, 1); - break; - case Bstringp: - JIT_CALL_WITH_STACK_N (native_stringp, 1); - break; - case Blistp: - JIT_CALL_WITH_STACK_N (native_listp, 1); - break; - case Bnot: - default: - JIT_CALL_WITH_STACK_N (native_not, 1); - break; - } - JIT_NEXT; - NEXT; - } - - CASE (Bcons): - { - JIT_CALL_WITH_STACK_N (Fcons, 2); - JIT_NEXT; - NEXT; - } - - CASE (Blist1): - { - JIT_CALL_WITH_STACK_N (list1, 1); + JIT_PUSH (JIT_CALL_ARGS (native_add1, JIT_POP (), + JIT_CONSTANT (jit_type_sys_bool, 0))); JIT_NEXT; NEXT; } - CASE (Blist2): + CASE (Badd1): { - JIT_CALL_WITH_STACK_N (list2, 2); + JIT_NEED_STACK; + JIT_PUSH (JIT_CALL_ARGS (native_add1, JIT_POP (), + JIT_CONSTANT (jit_type_sys_bool, 1))); JIT_NEXT; NEXT; } - CASE (Blist3): - CASE (Blist4): - CASE (BlistN): + CASE (Bgtr): + CASE (Blss): + CASE (Bleq): + CASE (Bgeq): { - size_t temp; - if (op == BlistN) - { - temp = FETCH; - } - else + jit_value_t v1, v2, c; + enum Arith_Comparison v[] = { - if (op == Blist3) - temp = 3; - else - temp = 4; - } - JIT_CALL_WITH_STACK_MANY (Flist, temp); - JIT_NEXT; - NEXT; - } - - CASE (Blength): - { - JIT_CALL_WITH_STACK_N (Flength, 1); - JIT_NEXT; - NEXT; - } - - CASE (Baref): - { - JIT_CALL_WITH_STACK_N (Faref, 2); - JIT_NEXT; - NEXT; - } - - CASE (Baset): - { - JIT_CALL_WITH_STACK_N (Faset, 3); + ARITH_GRTR, + ARITH_LESS, + ARITH_LESS_OR_EQUAL, + ARITH_GRTR_OR_EQUAL + }; + JIT_NEED_STACK; + c = JIT_CONSTANT (jit_type_nuint, v[op-Bgtr]); + v2 = JIT_POP (); + v1 = JIT_POP (); + JIT_PUSH (JIT_CALL_ARGS (arithcompare, v1, v2, c)); JIT_NEXT; NEXT; } - CASE (Bsymbol_value): - { - JIT_CALL_WITH_STACK_N (Fsymbol_value, 1); - JIT_NEXT; - NEXT; - } - CASE (Bsymbol_function): - { - JIT_CALL_WITH_STACK_N (Fsymbol_function, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bset): - { - JIT_CALL_WITH_STACK_N (Fset, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bfset): - { - JIT_CALL_WITH_STACK_N (Ffset, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bget): - { - JIT_CALL_WITH_STACK_N (Fget, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bsubstring): - { - JIT_CALL_WITH_STACK_N (Fsubstring, 3); - JIT_NEXT; - NEXT; - } - - CASE (Bconcat2): - CASE (Bconcat3): - CASE (Bconcat4): - CASE (BconcatN): - { - size_t n; - if (op == BconcatN) - n = FETCH; - else - n = op - Bconcat2 + 2; - JIT_CALL_WITH_STACK_MANY (Fconcat, n); - JIT_NEXT; - NEXT; - } - - CASE (Bsub1): - { - JIT_NEED_STACK; - JIT_PUSH (JIT_CALL_ARGS (native_add1, JIT_POP (), - JIT_CONSTANT (jit_type_sys_bool, 0))); - JIT_NEXT; - NEXT; - } - - CASE (Badd1): - { - JIT_NEED_STACK; - JIT_PUSH (JIT_CALL_ARGS (native_add1, JIT_POP (), - JIT_CONSTANT (jit_type_sys_bool, 1))); - JIT_NEXT; - NEXT; - } - - CASE (Beqlsign): - { - JIT_CALL_WITH_STACK_N (native_eqlsign, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bgtr): - CASE (Blss): - CASE (Bleq): - CASE (Bgeq): - { - jit_value_t v1, v2, c; - enum Arith_Comparison v[] = - { - ARITH_GRTR, - ARITH_LESS, - ARITH_LESS_OR_EQUAL, - ARITH_GRTR_OR_EQUAL - }; - JIT_NEED_STACK; - c = JIT_CONSTANT (jit_type_nuint, v[op-Bgtr]); - v2 = JIT_POP (); - v1 = JIT_POP (); - JIT_PUSH (JIT_CALL_ARGS (arithcompare, v1, v2, c)); - JIT_NEXT; - NEXT; - } - - CASE (Bdiff): - { - JIT_CALL_WITH_STACK_MANY (Fminus, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bnegate): - { - JIT_CALL_WITH_STACK_N (native_negate, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bplus): - { - JIT_CALL_WITH_STACK_MANY (Fplus, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bmax): - { - JIT_CALL_WITH_STACK_MANY (Fmax, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bmin): - { - JIT_CALL_WITH_STACK_MANY (Fmin, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bmult): - { - JIT_CALL_WITH_STACK_MANY (Ftimes, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bquo): - { - JIT_CALL_WITH_STACK_MANY (Fquo, 2); - JIT_NEXT; - NEXT; - } - - CASE (Brem): - { - JIT_CALL_WITH_STACK_N (Frem, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bpoint): - { - JIT_CALL_WITH_STACK_N (native_point, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bgoto_char): - { - JIT_CALL_WITH_STACK_N (Fgoto_char, 1); - JIT_NEXT; - NEXT; - } - - CASE (Binsert): - { - JIT_CALL_WITH_STACK_MANY (Finsert, 1); - JIT_NEXT; - NEXT; - } - - CASE (BinsertN): - { - /* FETCH must not appear in the macro reference below, otherwise - the macro expansion will contain multiple instances OF FETCH */ - Lisp_Object n = FETCH; - JIT_CALL_WITH_STACK_MANY (Finsert, n); - JIT_NEXT; - NEXT; - } - - CASE (Bpoint_max): - { - JIT_CALL_WITH_STACK_N (native_point_max, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bpoint_min): - { - JIT_CALL_WITH_STACK_N (native_point_min, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bchar_after): - { - JIT_CALL_WITH_STACK_N (Fchar_after, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bfollowing_char): - { - JIT_CALL_WITH_STACK_N (Ffollowing_char, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bpreceding_char): - { - JIT_CALL_WITH_STACK_N (Fprevious_char, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bcurrent_column): - { - JIT_CALL_WITH_STACK_N (native_current_column, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bindent_to): + CASE (Bindent_to): { JIT_PUSH (JIT_CONSTANT (jit_type_Lisp_Object, Qnil)); JIT_CALL_WITH_STACK_N (Findent_to, 2); @@ -1711,272 +1480,6 @@ jit_byte_code__ (Lisp_Object byte_code) NEXT; } - CASE (Beolp): - { - JIT_CALL_WITH_STACK_N (Feolp, 0); - JIT_NEXT; - NEXT; - } - - CASE (Beobp): - { - JIT_CALL_WITH_STACK_N (Feobp, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bbolp): - { - JIT_CALL_WITH_STACK_N (Fbolp, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bbobp): - { - JIT_CALL_WITH_STACK_N (Fbobp, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bcurrent_buffer): - { - JIT_CALL_WITH_STACK_N (Fcurrent_buffer, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bset_buffer): - { - JIT_CALL_WITH_STACK_N (Fset_buffer, 1); - JIT_NEXT; - NEXT; - } - - CASE (Binteractive_p): /* Obsolete since 24.1. */ - { - JIT_CALL_WITH_STACK_N (native_interactive_p, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bforward_char): - { - JIT_CALL_WITH_STACK_N (Fforward_char, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bforward_word): - { - JIT_CALL_WITH_STACK_N (Fforward_word, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bskip_chars_forward): - { - JIT_CALL_WITH_STACK_N (Fskip_chars_forward, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bskip_chars_backward): - { - JIT_CALL_WITH_STACK_N (Fskip_chars_backward, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bforward_line): - { - JIT_CALL_WITH_STACK_N (Fforward_line, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bchar_syntax): - { - JIT_CALL_WITH_STACK_N (native_char_syntax, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bbuffer_substring): - { - JIT_CALL_WITH_STACK_N (Fbuffer_substring, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bdelete_region): - { - JIT_CALL_WITH_STACK_N (Fdelete_region, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bnarrow_to_region): - { - JIT_CALL_WITH_STACK_N (Fnarrow_to_region, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bwiden): - { - JIT_CALL_WITH_STACK_N (Fwiden, 0); - JIT_NEXT; - NEXT; - } - - CASE (Bend_of_line): - { - JIT_CALL_WITH_STACK_N (Fend_of_line, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bset_marker): - { - JIT_CALL_WITH_STACK_N (Fset_marker, 3); - JIT_NEXT; - NEXT; - } - - CASE (Bmatch_beginning): - { - JIT_CALL_WITH_STACK_N (Fmatch_beginning, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bmatch_end): - { - JIT_CALL_WITH_STACK_N (Fmatch_end, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bupcase): - { - JIT_CALL_WITH_STACK_N (Fupcase, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bdowncase): - { - JIT_CALL_WITH_STACK_N (Fdowncase, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bstringeqlsign): - { - JIT_CALL_WITH_STACK_N (Fstring_equal, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bstringlss): - { - JIT_CALL_WITH_STACK_N (Fstring_lessp, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bequal): - { - JIT_CALL_WITH_STACK_N (Fequal, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bnthcdr): - { - JIT_CALL_WITH_STACK_N (Fnthcdr, 2); - JIT_NEXT; - NEXT; - } - - CASE (Belt): - { - JIT_CALL_WITH_STACK_N (native_elt, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bmember): - { - JIT_CALL_WITH_STACK_N (Fmember, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bassq): - { - JIT_CALL_WITH_STACK_N (Fassq, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bnreverse): - { - JIT_CALL_WITH_STACK_N (Fnreverse, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bsetcar): - { - JIT_CALL_WITH_STACK_N (Fsetcar, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bsetcdr): - { - JIT_CALL_WITH_STACK_N (Fsetcdr, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bcar_safe): - { - JIT_CALL_WITH_STACK_N (native_car_safe, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bcdr_safe): - { - JIT_CALL_WITH_STACK_N (native_cdr_safe, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bnconc): - { - JIT_CALL_WITH_STACK_MANY (Fnconc, 2); - JIT_NEXT; - NEXT; - } - - CASE (Bnumberp): - { - JIT_CALL_WITH_STACK_N (native_number_p, 1); - JIT_NEXT; - NEXT; - } - - CASE (Bintegerp): - { - JIT_CALL_WITH_STACK_N (native_integer_p, 1); - JIT_NEXT; - NEXT; - } - #if BYTE_CODE_SAFE /* These are intentionally written using 'case' syntax, because they are incompatible with the threaded diff --git a/src/bytecode.c b/src/bytecode.c index 26860daec10..0e95c3ea559 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -289,7 +289,6 @@ exec_byte_code__ (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth, { [0 ... (Bconstant - 1)] = &&insn_default, [Bconstant ... 255] = &&insn_Bconstant, - #define DEFINE(name, value) LABEL (name) , BYTE_CODES #undef DEFINE diff --git a/src/bytecode.h b/src/bytecode.h index 4882ca50db6..18c9c267069 100644 --- a/src/bytecode.h +++ b/src/bytecode.h @@ -42,198 +42,201 @@ along with GNU Emacs. If not, see . */ /* Byte codes: */ #define BYTE_CODES \ -DEFINE (Bstack_ref, 0) /* Actually, Bstack_ref+0 is not implemented: use dup. */ \ -DEFINE (Bstack_ref1, 1) \ -DEFINE (Bstack_ref2, 2) \ -DEFINE (Bstack_ref3, 3) \ -DEFINE (Bstack_ref4, 4) \ -DEFINE (Bstack_ref5, 5) \ -DEFINE (Bstack_ref6, 6) \ -DEFINE (Bstack_ref7, 7) \ -DEFINE (Bvarref, 010) \ -DEFINE (Bvarref1, 011) \ -DEFINE (Bvarref2, 012) \ -DEFINE (Bvarref3, 013) \ -DEFINE (Bvarref4, 014) \ -DEFINE (Bvarref5, 015) \ -DEFINE (Bvarref6, 016) \ -DEFINE (Bvarref7, 017) \ -DEFINE (Bvarset, 020) \ -DEFINE (Bvarset1, 021) \ -DEFINE (Bvarset2, 022) \ -DEFINE (Bvarset3, 023) \ -DEFINE (Bvarset4, 024) \ -DEFINE (Bvarset5, 025) \ -DEFINE (Bvarset6, 026) \ -DEFINE (Bvarset7, 027) \ -DEFINE (Bvarbind, 030) \ -DEFINE (Bvarbind1, 031) \ -DEFINE (Bvarbind2, 032) \ -DEFINE (Bvarbind3, 033) \ -DEFINE (Bvarbind4, 034) \ -DEFINE (Bvarbind5, 035) \ -DEFINE (Bvarbind6, 036) \ -DEFINE (Bvarbind7, 037) \ -DEFINE (Bcall, 040) \ -DEFINE (Bcall1, 041) \ -DEFINE (Bcall2, 042) \ -DEFINE (Bcall3, 043) \ -DEFINE (Bcall4, 044) \ -DEFINE (Bcall5, 045) \ -DEFINE (Bcall6, 046) \ -DEFINE (Bcall7, 047) \ -DEFINE (Bunbind, 050) \ -DEFINE (Bunbind1, 051) \ -DEFINE (Bunbind2, 052) \ -DEFINE (Bunbind3, 053) \ -DEFINE (Bunbind4, 054) \ -DEFINE (Bunbind5, 055) \ -DEFINE (Bunbind6, 056) \ -DEFINE (Bunbind7, 057) \ + DEFINE (Bstack_ref, 0) /* Actually, Bstack_ref+0 is not implemented: use dup. */ \ + DEFINE (Bstack_ref1, 1) \ + DEFINE (Bstack_ref2, 2) \ + DEFINE (Bstack_ref3, 3) \ + DEFINE (Bstack_ref4, 4) \ + DEFINE (Bstack_ref5, 5) \ + DEFINE (Bstack_ref6, 6) \ + DEFINE (Bstack_ref7, 7) \ + DEFINE (Bvarref, 010) \ + DEFINE (Bvarref1, 011) \ + DEFINE (Bvarref2, 012) \ + DEFINE (Bvarref3, 013) \ + DEFINE (Bvarref4, 014) \ + DEFINE (Bvarref5, 015) \ + DEFINE (Bvarref6, 016) \ + DEFINE (Bvarref7, 017) \ + DEFINE (Bvarset, 020) \ + DEFINE (Bvarset1, 021) \ + DEFINE (Bvarset2, 022) \ + DEFINE (Bvarset3, 023) \ + DEFINE (Bvarset4, 024) \ + DEFINE (Bvarset5, 025) \ + DEFINE (Bvarset6, 026) \ + DEFINE (Bvarset7, 027) \ + DEFINE (Bvarbind, 030) \ + DEFINE (Bvarbind1, 031) \ + DEFINE (Bvarbind2, 032) \ + DEFINE (Bvarbind3, 033) \ + DEFINE (Bvarbind4, 034) \ + DEFINE (Bvarbind5, 035) \ + DEFINE (Bvarbind6, 036) \ + DEFINE (Bvarbind7, 037) \ + DEFINE_MANY (Bcall, 040, Ffuncall, 1) \ + DEFINE_MANY (Bcall1, 041, Ffuncall, 2) \ + DEFINE_MANY (Bcall2, 042, Ffuncall, 3) \ + DEFINE_MANY (Bcall3, 043, Ffuncall, 4) \ + DEFINE_MANY (Bcall4, 044, Ffuncall, 5) \ + DEFINE_MANY (Bcall5, 045, Ffuncall, 6) \ + DEFINE_MANY (Bcall6, 046, Ffuncall, -1) \ + DEFINE_MANY (Bcall7, 047, Ffuncall, -2) \ + DEFINE (Bunbind, 050) \ + DEFINE (Bunbind1, 051) \ + DEFINE (Bunbind2, 052) \ + DEFINE (Bunbind3, 053) \ + DEFINE (Bunbind4, 054) \ + DEFINE (Bunbind5, 055) \ + DEFINE (Bunbind6, 056) \ + DEFINE (Bunbind7, 057) \ \ -DEFINE (Bpophandler, 060) \ -DEFINE (Bpushconditioncase, 061) \ -DEFINE (Bpushcatch, 062) \ + DEFINE (Bpophandler, 060) \ + DEFINE (Bpushconditioncase, 061) \ + DEFINE (Bpushcatch, 062) \ \ -DEFINE (Bnth, 070) \ -DEFINE (Bsymbolp, 071) \ -DEFINE (Bconsp, 072) \ -DEFINE (Bstringp, 073) \ -DEFINE (Blistp, 074) \ -DEFINE (Beq, 075) \ -DEFINE (Bmemq, 076) \ -DEFINE (Bnot, 077) \ -DEFINE (Bcar, 0100) \ -DEFINE (Bcdr, 0101) \ -DEFINE (Bcons, 0102) \ -DEFINE (Blist1, 0103) \ -DEFINE (Blist2, 0104) \ -DEFINE (Blist3, 0105) \ -DEFINE (Blist4, 0106) \ -DEFINE (Blength, 0107) \ -DEFINE (Baref, 0110) \ -DEFINE (Baset, 0111) \ -DEFINE (Bsymbol_value, 0112) \ -DEFINE (Bsymbol_function, 0113) \ -DEFINE (Bset, 0114) \ -DEFINE (Bfset, 0115) \ -DEFINE (Bget, 0116) \ -DEFINE (Bsubstring, 0117) \ -DEFINE (Bconcat2, 0120) \ -DEFINE (Bconcat3, 0121) \ -DEFINE (Bconcat4, 0122) \ -DEFINE (Bsub1, 0123) \ -DEFINE (Badd1, 0124) \ -DEFINE (Beqlsign, 0125) \ -DEFINE (Bgtr, 0126) \ -DEFINE (Blss, 0127) \ -DEFINE (Bleq, 0130) \ -DEFINE (Bgeq, 0131) \ -DEFINE (Bdiff, 0132) \ -DEFINE (Bnegate, 0133) \ -DEFINE (Bplus, 0134) \ -DEFINE (Bmax, 0135) \ -DEFINE (Bmin, 0136) \ -DEFINE (Bmult, 0137) \ + DEFINE_FIXED (Bnth, 070, native_nth, 2) \ + DEFINE_FIXED (Bsymbolp, 071, native_symbolp, 1) \ + DEFINE_FIXED (Bconsp, 072, native_consp, 1) \ + DEFINE_FIXED (Bstringp, 073, native_stringp, 1) \ + DEFINE_FIXED (Blistp, 074, native_listp, 1) \ + DEFINE_FIXED (Beq, 075, native_eq, 2) \ + DEFINE_FIXED (Bmemq, 076, native_memq, 2) \ + DEFINE_FIXED (Bnot, 077, native_not, 1) \ + DEFINE_FIXED (Bcar, 0100, native_car, 1) \ + DEFINE_FIXED (Bcdr, 0101, native_cdr, 1) \ + DEFINE_FIXED (Bcons, 0102, Fcons, 2) \ + DEFINE_FIXED (Blist1, 0103, list1, 1) \ + DEFINE_FIXED (Blist2, 0104, list2, 2) \ + DEFINE_MANY (Blist3, 0105, Flist, 3) \ + DEFINE_MANY (Blist4, 0106, Flist, 4) \ + DEFINE_FIXED (Blength, 0107, Flength, 1) \ + DEFINE_FIXED (Baref, 0110, Faref, 2) \ + DEFINE_FIXED (Baset, 0111, Faset, 3) \ + DEFINE_FIXED (Bsymbol_value, 0112, Fsymbol_value, 1) \ + DEFINE_FIXED (Bsymbol_function, 0113, Fsymbol_function, 1) \ + DEFINE_FIXED (Bset, 0114, Fset, 2) \ + DEFINE_FIXED (Bfset, 0115, Ffset, 2) \ + DEFINE_FIXED (Bget, 0116, Fget, 2) \ + DEFINE_FIXED (Bsubstring, 0117, Fsubstring, 3) \ + DEFINE_MANY (Bconcat2, 0120, Fconcat, 2) \ + DEFINE_MANY (Bconcat3, 0121, Fconcat, 3) \ + DEFINE_MANY (Bconcat4, 0122, Fconcat, 4) \ + DEFINE (Bsub1, 0123) \ + DEFINE (Badd1, 0124) \ + DEFINE_FIXED (Beqlsign, 0125, native_eqlsign, 2) \ + DEFINE (Bgtr, 0126) \ + DEFINE (Blss, 0127) \ + DEFINE (Bleq, 0130) \ + DEFINE (Bgeq, 0131) \ + DEFINE_MANY (Bdiff, 0132, Fminus, 2) \ + DEFINE_FIXED (Bnegate, 0133, native_negate, 1) \ + DEFINE_MANY (Bplus, 0134, Fplus, 2) \ + DEFINE_MANY (Bmax, 0135, Fmax, 2) \ + DEFINE_MANY (Bmin, 0136, Fmin, 2) \ + DEFINE_MANY (Bmult, 0137, Ftimes, 2) \ \ -DEFINE (Bpoint, 0140) \ -/* Was Bmark in v17. */ \ -DEFINE (Bsave_current_buffer, 0141) /* Obsolete. */ \ -DEFINE (Bgoto_char, 0142) \ -DEFINE (Binsert, 0143) \ -DEFINE (Bpoint_max, 0144) \ -DEFINE (Bpoint_min, 0145) \ -DEFINE (Bchar_after, 0146) \ -DEFINE (Bfollowing_char, 0147) \ -DEFINE (Bpreceding_char, 0150) \ -DEFINE (Bcurrent_column, 0151) \ -DEFINE (Bindent_to, 0152) \ -DEFINE (Beolp, 0154) \ -DEFINE (Beobp, 0155) \ -DEFINE (Bbolp, 0156) \ -DEFINE (Bbobp, 0157) \ -DEFINE (Bcurrent_buffer, 0160) \ -DEFINE (Bset_buffer, 0161) \ -DEFINE (Bsave_current_buffer_1, 0162) /* Replacing Bsave_current_buffer. */ \ -DEFINE (Binteractive_p, 0164) /* Obsolete since Emacs-24.1. */ \ + DEFINE_FIXED (Bpoint, 0140, native_point, 0) \ + /* Was Bmark in v17. */ \ + DEFINE (Bsave_current_buffer, 0141) /* Obsolete. */ \ + DEFINE_FIXED (Bgoto_char, 0142, Fgoto_char, 1) \ + DEFINE_MANY (Binsert, 0143, Finsert, 1) \ + DEFINE_FIXED (Bpoint_max, 0144, native_point_max, 0) \ + DEFINE_FIXED (Bpoint_min, 0145, native_point_min, 0) \ + DEFINE_FIXED (Bchar_after, 0146, Fchar_after, 1) \ + DEFINE_FIXED (Bfollowing_char, 0147, Ffollowing_char, 0) \ + DEFINE_FIXED (Bpreceding_char, 0150, Fprevious_char, 0) \ + DEFINE_FIXED (Bcurrent_column, 0151, native_current_column, 0) \ + DEFINE (Bindent_to, 0152) \ + DEFINE_FIXED (Beolp, 0154, Feolp, 0) \ + DEFINE_FIXED (Beobp, 0155, Feobp, 0) \ + DEFINE_FIXED (Bbolp, 0156, Fbolp, 0) \ + DEFINE_FIXED (Bbobp, 0157, Fbobp, 0) \ + DEFINE_FIXED (Bcurrent_buffer, 0160, Fcurrent_buffer, 0) \ + DEFINE_FIXED (Bset_buffer, 0161, Fset_buffer, 1) \ + DEFINE (Bsave_current_buffer_1, 0162) /* Replacing Bsave_current_buffer. */ \ + DEFINE_FIXED (Binteractive_p, 0164, native_interactive_p, 0) /* Obsolete since Emacs-24.1. */ \ \ -DEFINE (Bforward_char, 0165) \ -DEFINE (Bforward_word, 0166) \ -DEFINE (Bskip_chars_forward, 0167) \ -DEFINE (Bskip_chars_backward, 0170) \ -DEFINE (Bforward_line, 0171) \ -DEFINE (Bchar_syntax, 0172) \ -DEFINE (Bbuffer_substring, 0173) \ -DEFINE (Bdelete_region, 0174) \ -DEFINE (Bnarrow_to_region, 0175) \ -DEFINE (Bwiden, 0176) \ -DEFINE (Bend_of_line, 0177) \ + DEFINE_FIXED (Bforward_char, 0165, Fforward_char, 1) \ + DEFINE_FIXED (Bforward_word, 0166, Fforward_word, 1) \ + DEFINE_FIXED (Bskip_chars_forward, 0167, Fskip_chars_forward, 2) \ + DEFINE_FIXED (Bskip_chars_backward, 0170, Fskip_chars_backward, 2) \ + DEFINE_FIXED (Bforward_line, 0171, Fforward_line, 1) \ + DEFINE_FIXED (Bchar_syntax, 0172, native_char_syntax, 1) \ + DEFINE_FIXED (Bbuffer_substring, 0173, Fbuffer_substring, 2) \ + DEFINE_FIXED (Bdelete_region, 0174, Fdelete_region, 2) \ + DEFINE_FIXED (Bnarrow_to_region, 0175, Fnarrow_to_region, 2) \ + DEFINE_FIXED (Bwiden, 0176, Fwiden, 0) \ + DEFINE_FIXED (Bend_of_line, 0177, Fend_of_line, 1) \ \ -DEFINE (Bconstant2, 0201) \ -DEFINE (Bgoto, 0202) \ -DEFINE (Bgotoifnil, 0203) \ -DEFINE (Bgotoifnonnil, 0204) \ -DEFINE (Bgotoifnilelsepop, 0205) \ -DEFINE (Bgotoifnonnilelsepop, 0206) \ -DEFINE (Breturn, 0207) \ -DEFINE (Bdiscard, 0210) \ -DEFINE (Bdup, 0211) \ + DEFINE (Bconstant2, 0201) \ + DEFINE (Bgoto, 0202) \ + DEFINE (Bgotoifnil, 0203) \ + DEFINE (Bgotoifnonnil, 0204) \ + DEFINE (Bgotoifnilelsepop, 0205) \ + DEFINE (Bgotoifnonnilelsepop, 0206) \ + DEFINE (Breturn, 0207) \ + DEFINE (Bdiscard, 0210) \ + DEFINE (Bdup, 0211) \ \ -DEFINE (Bsave_excursion, 0212) \ -DEFINE (Bsave_window_excursion, 0213) /* Obsolete since Emacs-24.1. */ \ -DEFINE (Bsave_restriction, 0214) \ -DEFINE (Bcatch, 0215) \ + DEFINE (Bsave_excursion, 0212) \ + DEFINE_FIXED (Bsave_window_excursion, 0213, native_save_window_excursion, 1) /* Obsolete since Emacs-24.1. */ \ + DEFINE (Bsave_restriction, 0214) \ + DEFINE_FIXED (Bcatch, 0215, native_catch, 2) \ \ -DEFINE (Bunwind_protect, 0216) \ -DEFINE (Bcondition_case, 0217) \ -DEFINE (Btemp_output_buffer_setup, 0220) /* Obsolete since Emacs-24.1. */ \ -DEFINE (Btemp_output_buffer_show, 0221) /* Obsolete since Emacs-24.1. */ \ + DEFINE (Bunwind_protect, 0216) \ + DEFINE_FIXED (Bcondition_case, 0217, internal_lisp_condition_case, 3) \ + DEFINE_FIXED (Btemp_output_buffer_setup, 0220, native_temp_output_buffer_setup, 1) /* Obsolete since Emacs-24.1. */ \ + DEFINE (Btemp_output_buffer_show, 0221) /* Obsolete since Emacs-24.1. */ \ \ -DEFINE (Bunbind_all, 0222) /* Obsolete. Never used. */ \ + DEFINE (Bunbind_all, 0222) /* Obsolete. Never used. */ \ \ -DEFINE (Bset_marker, 0223) \ -DEFINE (Bmatch_beginning, 0224) \ -DEFINE (Bmatch_end, 0225) \ -DEFINE (Bupcase, 0226) \ -DEFINE (Bdowncase, 0227) \ + DEFINE_FIXED (Bset_marker, 0223, Fset_marker, 3) \ + DEFINE_FIXED (Bmatch_beginning, 0224, Fmatch_beginning, 1) \ + DEFINE_FIXED (Bmatch_end, 0225, Fmatch_end, 1) \ + DEFINE_FIXED (Bupcase, 0226, Fupcase, 1) \ + DEFINE_FIXED (Bdowncase, 0227, Fdowncase, 1) \ \ -DEFINE (Bstringeqlsign, 0230) \ -DEFINE (Bstringlss, 0231) \ -DEFINE (Bequal, 0232) \ -DEFINE (Bnthcdr, 0233) \ -DEFINE (Belt, 0234) \ -DEFINE (Bmember, 0235) \ -DEFINE (Bassq, 0236) \ -DEFINE (Bnreverse, 0237) \ -DEFINE (Bsetcar, 0240) \ -DEFINE (Bsetcdr, 0241) \ -DEFINE (Bcar_safe, 0242) \ -DEFINE (Bcdr_safe, 0243) \ -DEFINE (Bnconc, 0244) \ -DEFINE (Bquo, 0245) \ -DEFINE (Brem, 0246) \ -DEFINE (Bnumberp, 0247) \ -DEFINE (Bintegerp, 0250) \ + DEFINE_FIXED (Bstringeqlsign, 0230, Fstring_equal, 2) \ + DEFINE_FIXED (Bstringlss, 0231, Fstring_lessp, 2) \ + DEFINE_FIXED (Bequal, 0232, Fequal, 2) \ + DEFINE_FIXED (Bnthcdr, 0233, Fnthcdr, 2) \ + DEFINE_FIXED (Belt, 0234, native_elt, 2) \ + DEFINE_FIXED (Bmember, 0235, Fmember, 2) \ + DEFINE_FIXED (Bassq, 0236, Fassq, 2) \ + DEFINE_FIXED (Bnreverse, 0237, Fnreverse, 1) \ + DEFINE_FIXED (Bsetcar, 0240, Fsetcar, 2) \ + DEFINE_FIXED (Bsetcdr, 0241, Fsetcdr, 2) \ + DEFINE_FIXED (Bcar_safe, 0242, native_car_safe, 1) \ + DEFINE_FIXED (Bcdr_safe, 0243, native_cdr_safe, 1) \ + DEFINE_MANY (Bnconc, 0244, Fnconc, 2) \ + DEFINE_MANY (Bquo, 0245, Fquo, 2) \ + DEFINE_FIXED (Brem, 0246, Frem, 2) \ + DEFINE_FIXED (Bnumberp, 0247, native_number_p, 1) \ + DEFINE_FIXED (Bintegerp, 0250, native_integer_p, 1) \ \ -DEFINE (BRgoto, 0252) \ -DEFINE (BRgotoifnil, 0253) \ -DEFINE (BRgotoifnonnil, 0254) \ -DEFINE (BRgotoifnilelsepop, 0255) \ -DEFINE (BRgotoifnonnilelsepop, 0256) \ + DEFINE (BRgoto, 0252) \ + DEFINE (BRgotoifnil, 0253) \ + DEFINE (BRgotoifnonnil, 0254) \ + DEFINE (BRgotoifnilelsepop, 0255) \ + DEFINE (BRgotoifnonnilelsepop, 0256) \ \ -DEFINE (BlistN, 0257) \ -DEFINE (BconcatN, 0260) \ -DEFINE (BinsertN, 0261) \ + DEFINE_MANY (BlistN, 0257, Flist, -1) \ + DEFINE_MANY (BconcatN, 0260, Fconcat, -1) \ + DEFINE_MANY (BinsertN, 0261, Finsert, -1) \ \ -/* Bstack_ref is code 0. */ \ -DEFINE (Bstack_set, 0262) \ -DEFINE (Bstack_set2, 0263) \ -DEFINE (BdiscardN, 0266) \ + /* Bstack_ref is code 0. */ \ + DEFINE (Bstack_set, 0262) \ + DEFINE (Bstack_set2, 0263) \ + DEFINE (BdiscardN, 0266) \ \ -DEFINE (Bconstant, 0300) + DEFINE (Bconstant, 0300) enum byte_code_op { +#define DEFINE_FIXED(bname, value, fname, num) DEFINE (bname, value) +#define DEFINE_MANY(bname, value, fname, num) \ + DEFINE_FIXED (bname, value, fname, num) #define DEFINE(name, value) name = value, BYTE_CODES #undef DEFINE -- 2.39.5