From unknown Wed Jun 18 23:17:52 2025 Content-Disposition: inline Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 X-Mailer: MIME-tools 5.509 (Entity 5.509) Content-Type: text/plain; charset=utf-8 From: bug#4470 <4470@debbugs.gnu.org> To: bug#4470 <4470@debbugs.gnu.org> Subject: Status: 23.1; threaded interpreter Reply-To: bug#4470 <4470@debbugs.gnu.org> Date: Thu, 19 Jun 2025 06:17:52 +0000 retitle 4470 23.1; threaded interpreter reassign 4470 emacs submitter 4470 Tom Tromey severity 4470 wishlist tag 4470 patch thanks From tromey@redhat.com Thu Sep 17 13:57:15 2009 Received: (at submit) by emacsbugs.donarmstrong.com; 17 Sep 2009 20:57:15 +0000 X-Spam-Checker-Version: SpamAssassin 3.2.5-bugs.debian.org_2005_01_02 (2008-06-10) on rzlab.ucr.edu X-Spam-Level: * X-Spam-Bayes: score:0.5 Bayes not run. spammytokens:Tokens not available. hammytokens:Tokens not available. X-Spam-Status: No, score=1.4 required=4.0 tests=AWL,FOURLA,FVGT_m_MULTI_ODD, IMPRONONCABLE_1,IMPRONONCABLE_2,MURPHY_DRUGS_REL8,MURPHY_WRONG_WORD1, MURPHY_WRONG_WORD2,PHONENUMBER autolearn=no version=3.2.5-bugs.debian.org_2005_01_02 Received: from lists.gnu.org (lists.gnu.org [199.232.76.165]) by rzlab.ucr.edu (8.14.3/8.14.3/Debian-5) with ESMTP id n8HKvDbb030133 for ; Thu, 17 Sep 2009 13:57:14 -0700 Received: from mailman by lists.gnu.org with tmda-scanned (Exim 4.43) id 1MoO2T-0006A0-2Z for bug-gnu-emacs@gnu.org; Thu, 17 Sep 2009 16:57:13 -0400 Received: from exim by lists.gnu.org with spam-scanned (Exim 4.43) id 1MoO2N-00068l-2K for bug-gnu-emacs@gnu.org; Thu, 17 Sep 2009 16:57:11 -0400 Received: from [199.232.76.173] (port=36982 helo=monty-python.gnu.org) by lists.gnu.org with esmtp (Exim 4.43) id 1MoO2M-00068T-QX for bug-gnu-emacs@gnu.org; Thu, 17 Sep 2009 16:57:06 -0400 Received: from mx1.redhat.com ([209.132.183.28]:61477) by monty-python.gnu.org with esmtp (Exim 4.60) (envelope-from ) id 1MoO2K-00028p-6F for bug-gnu-emacs@gnu.org; Thu, 17 Sep 2009 16:57:05 -0400 Received: from int-mx01.intmail.prod.int.phx2.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id n8HKv1f5016093 for ; Thu, 17 Sep 2009 16:57:01 -0400 Received: from ns3.rdu.redhat.com (ns3.rdu.redhat.com [10.11.255.199]) by int-mx01.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id n8HKv0jM027398; Thu, 17 Sep 2009 16:57:00 -0400 Received: from opsy.redhat.com (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by ns3.rdu.redhat.com (8.13.8/8.13.8) with ESMTP id n8HKuxSa004943; Thu, 17 Sep 2009 16:56:59 -0400 Received: by opsy.redhat.com (Postfix, from userid 500) id A69CF378204; Thu, 17 Sep 2009 14:56:58 -0600 (MDT) From: Tom Tromey To: bug-gnu-emacs@gnu.org Subject: 23.1; threaded interpreter Reply-To: Tom Tromey X-Attribution: Tom Date: Thu, 17 Sep 2009 14:56:58 -0600 Message-ID: MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Scanned-By: MIMEDefang 2.67 on 10.5.11.11 X-detected-operating-system: by monty-python.gnu.org: Genre and OS details not recognized. Please write in English if possible, because the Emacs maintainers usually do not have translators to read other languages for them. Your bug report will be posted to the bug-gnu-emacs@gnu.org mailing list, and to the gnu.emacs.bug news group. Please describe exactly what actions triggered the bug and the precise symptoms of the bug: I've appended the threaded interpreter patch. If Emacs crashed, and you have the Emacs process in the gdb debugger, please include the output from the following gdb commands: `bt full' and `xbacktrace'. If you would like to further debug the crash, please read the file /usr/share/emacs/23.1/etc/DEBUG for instructions. In GNU Emacs 23.1.1 (i386-redhat-linux-gnu, GTK+ Version 2.16.5) of 2009-08-26 on x86-2.fedora.phx.redhat.com Windowing system distributor `The X.Org Foundation', version 11.0.10601901 configured using `configure '--build=i386-redhat-linux-gnu' '--host=i386-redhat-linux-gnu' '--target=i586-redhat-linux-gnu' '--program-prefix=' '--prefix=/usr' '--exec-prefix=/usr' '--bindir=/usr/bin' '--sbindir=/usr/sbin' '--sysconfdir=/etc' '--datadir=/usr/share' '--includedir=/usr/include' '--libdir=/usr/lib' '--libexecdir=/usr/libexec' '--localstatedir=/var' '--sharedstatedir=/var/lib' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--with-dbus' '--with-gif' '--with-jpeg' '--with-png' '--with-rsvg' '--with-tiff' '--with-xft' '--with-xpm' '--with-x-toolkit=gtk' 'build_alias=i386-redhat-linux-gnu' 'host_alias=i386-redhat-linux-gnu' 'target_alias=i586-redhat-linux-gnu' 'CFLAGS=-DMAIL_USE_LOCKF -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector --param=ssp-buffer-size=4 -m32 -march=i586 -mtune=generic -fasynchronous-unwind-tables'' Important settings: value of $LC_ALL: nil value of $LC_COLLATE: nil value of $LC_CTYPE: nil value of $LC_MESSAGES: nil value of $LC_MONETARY: nil value of $LC_NUMERIC: nil value of $LC_TIME: nil value of $LANG: en_US.UTF-8 value of $XMODIFIERS: nil locale-coding-system: utf-8-unix default-enable-multibyte-characters: t Major mode: Group Minor modes in effect: gnus-agent-mode: t shell-dirtrack-mode: t erc-list-mode: t erc-menu-mode: t erc-autojoin-mode: t erc-ring-mode: t erc-pcomplete-mode: t erc-track-mode: t erc-track-minor-mode: t erc-match-mode: t erc-button-mode: t erc-fill-mode: t erc-stamp-mode: t erc-netsplit-mode: t erc-spelling-mode: t erc-truncate-mode: t diff-auto-refine-mode: t gnus-undo-mode: t erc-status-mode: t erc-services-mode: t erc-networks-mode: t erc-irccontrols-mode: t erc-noncommands-mode: t erc-move-to-prompt-mode: t erc-readonly-mode: t tooltip-mode: t mouse-wheel-mode: t file-name-shadow-mode: t global-font-lock-mode: t font-lock-mode: t global-auto-composition-mode: t auto-composition-mode: t auto-encryption-mode: t auto-compression-mode: t line-number-mode: t transient-mark-mode: t Recent input: C-n C-w C-x C-o C-u C-p C-u C-p C-p C-p C-p C-e g e n e r a t e d SPC c o d e . C-f C-f C-z o C-z o C-o C-o I SPC a m SPC n o t SPC s u r e SPC v m g e n SPC i s SPC a SPC t h e SPC b e s t SPC t r a d e o f f . SPC SPC C-a C-k I S-SPC l i k e SPC v m g e n SPC b u t SPC C-a C-k C-x C-o C-u C-n C-n C-n C-n M-f M-f M-b M-c M-f w o u l d SPC b e M-f M-d M-d M-d SPC t o M-q C-n C-e SPC S-SPC S o , SPC M-q C-z o C-z o M-a M-k M-a M-k T h i s SPC i s SPC a SPC b i t SPC m o r e SPC s p e c s p e c i f i c SPC t h a n SPC y o u r SPC t y p i c a l SPC G C C S-SPC o p t i m i z a t i o n , SPC t h o u g h . I SPC d o n ' t SPC t h i n k SPC t h a t SPC c o n s i d e r a t i o n s SPC o C-a C-u C-u C-p C-x k y e s C-c b E q s M-x r e p o r t - e m b Recent messages: Mark activated Auto-saving...done Mark set Auto-saving...done Expiring articles...done (No changes need to be saved) Saving /home/tromey/.newsrc.eld... Saving file /home/tromey/.newsrc.eld... Wrote /home/tromey/.newsrc.eld Saving /home/tromey/.newsrc.eld...done Tom 2009-09-17 Tom Tromey * bytecode.c (BYTE_CODE_THREADED): New define. (Bvarref1, Bvarref2, Bvarref3, Bvarref4, Bvarref5, Bvarref6) (Bvarref7, Bvarset1, Bvarset2, Bvarset3, Bvarset4, Bvarset5) (Bvarset6, Bvarset7, Bvarbind1, Bvarbind2, Bvarbind3, Bvarbind4) (Bvarbind5, Bvarbind6, Bvarbind7, Bcall1, Bcall2, Bcall3) (Bcall4, Bcall5, Bcall6, Bcall7, Bunbind1, Bunbind2, Bunbind3) (Bunbind4, Bunbind5, Bunbind6, Bunbind7): New defines. (CASE, LABEL, NEXT, FIRST, CASE_DEFAULT, CASE_ABORT): New defines. (Fbyte_code): Use indirect threading. Rewrite switch and case labels. diff --git a/src/bytecode.c b/src/bytecode.c index 43d972e..bd69a89 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -54,6 +54,13 @@ by Hallvard: /* #define BYTE_CODE_SAFE */ /* #define BYTE_CODE_METER */ +/* If BYTE_CODE_THREADED is defined, then the interpreter will be + indirect threaded, using GCC's computed goto extension. This is + incompatible with BYTE_CODE_SAFE and BYTE_CODE_METER. */ +#if defined (__GNUC__) && !defined (BYTE_CODE_SAFE) && !defined (BYTE_CODE_METER) +#define BYTE_CODE_THREADED +#endif + #ifdef BYTE_CODE_METER @@ -90,10 +97,45 @@ Lisp_Object Qbytecode; /* Byte codes: */ #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 Bnth 070 #define Bsymbolp 071 @@ -463,27 +505,324 @@ If the third argument is incorrect, Emacs may crash. */) this_op = op = FETCH; METER_CODE (prev_op, op); #else +#ifndef BYTE_CODE_THREADED op = FETCH; #endif +#endif + +#ifdef BYTE_CODE_THREADED +#define CASE(OP) insn_ ## OP +#define LABEL(OP) &&insn_ ## OP +#define NEXT goto *(targets[op = FETCH]) +#define FIRST NEXT; +#define CASE_DEFAULT +#define CASE_ABORT CASE (default) +#else +#define CASE(OP) case OP +#define NEXT break +#define FIRST switch (op) +#define CASE_DEFAULT case 255: default: +#define CASE_ABORT case 0 +#endif + +#ifdef BYTE_CODE_THREADED + static const void *const targets[256] = + { + LABEL (default), /* 0 */ + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), /* 7 */ + LABEL (Bvarref), + LABEL (Bvarref1), + LABEL (Bvarref2), + LABEL (Bvarref3), + LABEL (Bvarref4), + LABEL (Bvarref5), + LABEL (Bvarref6), + LABEL (Bvarref7), + LABEL (Bvarset), + LABEL (Bvarset1), + LABEL (Bvarset2), + LABEL (Bvarset3), + LABEL (Bvarset4), + LABEL (Bvarset5), + LABEL (Bvarset6), + LABEL (Bvarset7), + LABEL (Bvarbind), + LABEL (Bvarbind1), + LABEL (Bvarbind2), + LABEL (Bvarbind3), + LABEL (Bvarbind4), + LABEL (Bvarbind5), + LABEL (Bvarbind6), + LABEL (Bvarbind7), + LABEL (Bcall), + LABEL (Bcall1), + LABEL (Bcall2), + LABEL (Bcall3), + LABEL (Bcall4), + LABEL (Bcall5), + LABEL (Bcall6), + LABEL (Bcall7), + LABEL (Bunbind), + LABEL (Bunbind1), + LABEL (Bunbind2), + LABEL (Bunbind3), + LABEL (Bunbind4), + LABEL (Bunbind5), + LABEL (Bunbind6), + LABEL (Bunbind7), + LABEL (default), /* 060 */ + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), /* 067 */ + LABEL (Bnth), + LABEL (Bsymbolp), + LABEL (Bconsp), + LABEL (Bstringp), + LABEL (Blistp), + LABEL (Beq), + LABEL (Bmemq), + LABEL (Bnot), + LABEL (Bcar), + LABEL (Bcdr), + LABEL (Bcons), + LABEL (Blist1), + LABEL (Blist2), + LABEL (Blist3), + LABEL (Blist4), + LABEL (Blength), + LABEL (Baref), + LABEL (Baset), + LABEL (Bsymbol_value), + LABEL (Bsymbol_function), + LABEL (Bset), + LABEL (Bfset), + LABEL (Bget), + LABEL (Bsubstring), + LABEL (Bconcat2), + LABEL (Bconcat3), + LABEL (Bconcat4), + LABEL (Bsub1), + LABEL (Badd1), + LABEL (Beqlsign), + LABEL (Bgtr), + LABEL (Blss), + LABEL (Bleq), + LABEL (Bgeq), + LABEL (Bdiff), + LABEL (Bnegate), + LABEL (Bplus), + LABEL (Bmax), + LABEL (Bmin), + LABEL (Bmult), + LABEL (Bpoint), + LABEL (Bsave_current_buffer), + LABEL (Bgoto_char), + LABEL (Binsert), + LABEL (Bpoint_max), + LABEL (Bpoint_min), + LABEL (Bchar_after), + LABEL (Bfollowing_char), + LABEL (Bpreceding_char), + LABEL (Bcurrent_column), + LABEL (Bindent_to), + LABEL (Bscan_buffer), + LABEL (Beolp), + LABEL (Beobp), + LABEL (Bbolp), + LABEL (Bbobp), + LABEL (Bcurrent_buffer), + LABEL (Bset_buffer), + LABEL (Bsave_current_buffer_1), + LABEL (Bset_mark), + LABEL (Binteractive_p), + LABEL (Bforward_char), + LABEL (Bforward_word), + LABEL (Bskip_chars_forward), + LABEL (Bskip_chars_backward), + LABEL (Bforward_line), + LABEL (Bchar_syntax), + LABEL (Bbuffer_substring), + LABEL (Bdelete_region), + LABEL (Bnarrow_to_region), + LABEL (Bwiden), + LABEL (Bend_of_line), + LABEL (default), /* 0200 */ + LABEL (Bconstant2), + LABEL (Bgoto), + LABEL (Bgotoifnil), + LABEL (Bgotoifnonnil), + LABEL (Bgotoifnilelsepop), + LABEL (Bgotoifnonnilelsepop), + LABEL (Breturn), + LABEL (Bdiscard), + LABEL (Bdup), + LABEL (Bsave_excursion), + LABEL (Bsave_window_excursion), + LABEL (Bsave_restriction), + LABEL (Bcatch), + LABEL (Bunwind_protect), + LABEL (Bcondition_case), + LABEL (Btemp_output_buffer_setup), + LABEL (Btemp_output_buffer_show), + LABEL (Bunbind_all), + LABEL (Bset_marker), + LABEL (Bmatch_beginning), + LABEL (Bmatch_end), + LABEL (Bupcase), + LABEL (Bdowncase), + LABEL (Bstringeqlsign), + LABEL (Bstringlss), + LABEL (Bequal), + LABEL (Bnthcdr), + LABEL (Belt), + LABEL (Bmember), + LABEL (Bassq), + LABEL (Bnreverse), + LABEL (Bsetcar), + LABEL (Bsetcdr), + LABEL (Bcar_safe), + LABEL (Bcdr_safe), + LABEL (Bnconc), + LABEL (Bquo), + LABEL (Brem), + LABEL (Bnumberp), + LABEL (Bintegerp), + LABEL (default), /* 0251 */ + LABEL (BRgoto), + LABEL (BRgotoifnil), + LABEL (BRgotoifnonnil), + LABEL (BRgotoifnilelsepop), + LABEL (BRgotoifnonnilelsepop), + LABEL (BlistN), + LABEL (BconcatN), + LABEL (BinsertN), + LABEL (default), /* 0262 */ + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), /* 0270 */ + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), + LABEL (default), /* 0277 */ + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant), + LABEL (Bconstant) + }; +#endif + +#if 0 + /* Sanity checks that are useful if you modify the table. */ + if (targets[Bsymbol_value] != LABEL (Bsymbol_value)) + abort (); + if (targets[Bconstant2] != LABEL (Bconstant2)) + abort (); + if (targets[Bnegate] != LABEL (Bnegate)) + abort (); + if (targets[BinsertN] != LABEL (BinsertN)) + abort (); + if (targets[0277] != LABEL (default)) + abort (); + if (targets[Bconstant-1] == LABEL (Bconstant)) + abort (); + if (targets[Bconstant] != LABEL (Bconstant)) + abort (); +#endif - switch (op) + FIRST { - case Bvarref + 7: + CASE (Bvarref7): op = FETCH2; goto varref; - case Bvarref: - case Bvarref + 1: - case Bvarref + 2: - case Bvarref + 3: - case Bvarref + 4: - case Bvarref + 5: + CASE (Bvarref): + CASE (Bvarref1): + CASE (Bvarref2): + CASE (Bvarref3): + CASE (Bvarref4): + CASE (Bvarref5): op = op - Bvarref; goto varref; /* This seems to be the most frequently executed byte-code among the Bvarref's, so avoid a goto here. */ - case Bvarref+6: + CASE (Bvarref6): op = FETCH; varref: { @@ -507,10 +846,10 @@ If the third argument is incorrect, Emacs may crash. */) AFTER_POTENTIAL_GC (); } PUSH (v2); - break; + NEXT; } - case Bgotoifnil: + CASE (Bgotoifnil): { Lisp_Object v1; MAYBE_GC (); @@ -522,57 +861,57 @@ If the third argument is incorrect, Emacs may crash. */) CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + NEXT; } - case Bcar: + CASE (Bcar): { Lisp_Object v1; v1 = TOP; TOP = CAR (v1); - break; + NEXT; } - case Beq: + CASE (Beq): { Lisp_Object v1; v1 = POP; TOP = EQ (v1, TOP) ? Qt : Qnil; - break; + NEXT; } - case Bmemq: + CASE (Bmemq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmemq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bcdr: + CASE (Bcdr): { Lisp_Object v1; v1 = TOP; TOP = CDR (v1); - break; + NEXT; } - case Bvarset: - case Bvarset+1: - case Bvarset+2: - case Bvarset+3: - case Bvarset+4: - case Bvarset+5: + CASE (Bvarset): + CASE (Bvarset1): + CASE (Bvarset2): + CASE (Bvarset3): + CASE (Bvarset4): + CASE (Bvarset5): op -= Bvarset; goto varset; - case Bvarset+7: + CASE (Bvarset7): op = FETCH2; goto varset; - case Bvarset+6: + CASE (Bvarset6): op = FETCH; varset: { @@ -596,54 +935,54 @@ If the third argument is incorrect, Emacs may crash. */) } } (void) POP; - break; + NEXT; - case Bdup: + CASE (Bdup): { Lisp_Object v1; v1 = TOP; PUSH (v1); - break; + NEXT; } /* ------------------ */ - case Bvarbind+6: + CASE (Bvarbind6): op = FETCH; goto varbind; - case Bvarbind+7: + CASE (Bvarbind7): op = FETCH2; goto varbind; - case Bvarbind: - case Bvarbind+1: - case Bvarbind+2: - case Bvarbind+3: - case Bvarbind+4: - case Bvarbind+5: + CASE (Bvarbind): + CASE (Bvarbind1): + CASE (Bvarbind2): + CASE (Bvarbind3): + CASE (Bvarbind4): + CASE (Bvarbind5): op -= Bvarbind; varbind: /* Specbind can signal and thus GC. */ BEFORE_POTENTIAL_GC (); specbind (vectorp[op], POP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bcall+6: + CASE (Bcall6): op = FETCH; goto docall; - case Bcall+7: + CASE (Bcall7): op = FETCH2; goto docall; - case Bcall: - case Bcall+1: - case Bcall+2: - case Bcall+3: - case Bcall+4: - case Bcall+5: + CASE (Bcall): + CASE (Bcall1): + CASE (Bcall2): + CASE (Bcall3): + CASE (Bcall4): + CASE (Bcall5): op -= Bcall; docall: { @@ -666,47 +1005,47 @@ If the third argument is incorrect, Emacs may crash. */) #endif TOP = Ffuncall (op + 1, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bunbind+6: + CASE (Bunbind6): op = FETCH; goto dounbind; - case Bunbind+7: + CASE (Bunbind7): op = FETCH2; goto dounbind; - case Bunbind: - case Bunbind+1: - case Bunbind+2: - case Bunbind+3: - case Bunbind+4: - case Bunbind+5: + CASE (Bunbind): + CASE (Bunbind1): + CASE (Bunbind2): + CASE (Bunbind3): + CASE (Bunbind4): + CASE (Bunbind5): op -= Bunbind; dounbind: BEFORE_POTENTIAL_GC (); unbind_to (SPECPDL_INDEX () - op, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bunbind_all: + CASE (Bunbind_all): /* To unbind back to the beginning of this frame. Not used yet, but will be needed for tail-recursion elimination. */ BEFORE_POTENTIAL_GC (); unbind_to (count, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bgoto: + CASE (Bgoto): MAYBE_GC (); BYTE_CODE_QUIT; op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */ CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; - break; + NEXT; - case Bgotoifnonnil: + CASE (Bgotoifnonnil): { Lisp_Object v1; MAYBE_GC (); @@ -718,10 +1057,10 @@ If the third argument is incorrect, Emacs may crash. */) CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + NEXT; } - case Bgotoifnilelsepop: + CASE (Bgotoifnilelsepop): MAYBE_GC (); op = FETCH2; if (NILP (TOP)) @@ -731,9 +1070,9 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + NEXT; - case Bgotoifnonnilelsepop: + CASE (Bgotoifnonnilelsepop): MAYBE_GC (); op = FETCH2; if (!NILP (TOP)) @@ -743,15 +1082,15 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + NEXT; - case BRgoto: + CASE (BRgoto): MAYBE_GC (); BYTE_CODE_QUIT; stack.pc += (int) *stack.pc - 127; - break; + NEXT; - case BRgotoifnil: + CASE (BRgotoifnil): { Lisp_Object v1; MAYBE_GC (); @@ -762,10 +1101,10 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + NEXT; } - case BRgotoifnonnil: + CASE (BRgotoifnonnil): { Lisp_Object v1; MAYBE_GC (); @@ -776,10 +1115,10 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + NEXT; } - case BRgotoifnilelsepop: + CASE (BRgotoifnilelsepop): MAYBE_GC (); op = *stack.pc++; if (NILP (TOP)) @@ -788,9 +1127,9 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += op - 128; } else DISCARD (1); - break; + NEXT; - case BRgotoifnonnilelsepop: + CASE (BRgotoifnonnilelsepop): MAYBE_GC (); op = *stack.pc++; if (!NILP (TOP)) @@ -799,56 +1138,56 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += op - 128; } else DISCARD (1); - break; + NEXT; - case Breturn: + CASE (Breturn): result = POP; goto exit; - case Bdiscard: + CASE (Bdiscard): DISCARD (1); - break; + NEXT; - case Bconstant2: + CASE (Bconstant2): PUSH (vectorp[FETCH2]); - break; + NEXT; - case Bsave_excursion: + CASE (Bsave_excursion): record_unwind_protect (save_excursion_restore, save_excursion_save ()); - break; + NEXT; - case Bsave_current_buffer: - case Bsave_current_buffer_1: + CASE (Bsave_current_buffer): + CASE (Bsave_current_buffer_1): record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ()); - break; + NEXT; - case Bsave_window_excursion: + CASE (Bsave_window_excursion): BEFORE_POTENTIAL_GC (); TOP = Fsave_window_excursion (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsave_restriction: + CASE (Bsave_restriction): record_unwind_protect (save_restriction_restore, save_restriction_save ()); - break; + NEXT; - case Bcatch: + CASE (Bcatch): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = internal_catch (TOP, Feval, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bunwind_protect: + CASE (Bunwind_protect): record_unwind_protect (Fprogn, POP); - break; + NEXT; - case Bcondition_case: + CASE (Bcondition_case): { Lisp_Object handlers, body; handlers = POP; @@ -856,18 +1195,18 @@ If the third argument is incorrect, Emacs may crash. */) BEFORE_POTENTIAL_GC (); TOP = internal_lisp_condition_case (TOP, body, handlers); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Btemp_output_buffer_setup: + CASE (Btemp_output_buffer_setup): BEFORE_POTENTIAL_GC (); CHECK_STRING (TOP); temp_output_buffer_setup (SDATA (TOP)); AFTER_POTENTIAL_GC (); TOP = Vstandard_output; - break; + NEXT; - case Btemp_output_buffer_show: + CASE (Btemp_output_buffer_show): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); @@ -877,10 +1216,10 @@ If the third argument is incorrect, Emacs may crash. */) /* pop binding of standard-output */ unbind_to (SPECPDL_INDEX () - 1, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnth: + CASE (Bnth): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -894,173 +1233,173 @@ If the third argument is incorrect, Emacs may crash. */) v1 = XCDR (v1); immediate_quit = 0; TOP = CAR (v1); - break; + NEXT; } - case Bsymbolp: + CASE (Bsymbolp): TOP = SYMBOLP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bconsp: + CASE (Bconsp): TOP = CONSP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bstringp: + CASE (Bstringp): TOP = STRINGP (TOP) ? Qt : Qnil; - break; + NEXT; - case Blistp: + CASE (Blistp): TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bnot: + CASE (Bnot): TOP = NILP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bcons: + CASE (Bcons): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, v1); - break; + NEXT; } - case Blist1: + CASE (Blist1): TOP = Fcons (TOP, Qnil); - break; + NEXT; - case Blist2: + CASE (Blist2): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, Fcons (v1, Qnil)); - break; + NEXT; } - case Blist3: + CASE (Blist3): DISCARD (2); TOP = Flist (3, &TOP); - break; + NEXT; - case Blist4: + CASE (Blist4): DISCARD (3); TOP = Flist (4, &TOP); - break; + NEXT; - case BlistN: + CASE (BlistN): op = FETCH; DISCARD (op - 1); TOP = Flist (op, &TOP); - break; + NEXT; - case Blength: + CASE (Blength): BEFORE_POTENTIAL_GC (); TOP = Flength (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Baref: + CASE (Baref): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Faref (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Baset: + CASE (Baset): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Faset (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsymbol_value: + CASE (Bsymbol_value): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_value (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsymbol_function: + CASE (Bsymbol_function): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_function (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bset: + CASE (Bset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bfset: + CASE (Bfset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Ffset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bget: + CASE (Bget): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fget (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsubstring: + CASE (Bsubstring): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Fsubstring (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bconcat2: + CASE (Bconcat2): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fconcat (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bconcat3: + CASE (Bconcat3): BEFORE_POTENTIAL_GC (); DISCARD (2); TOP = Fconcat (3, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bconcat4: + CASE (Bconcat4): BEFORE_POTENTIAL_GC (); DISCARD (3); TOP = Fconcat (4, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case BconcatN: + CASE (BconcatN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Fconcat (op, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsub1: + CASE (Bsub1): { Lisp_Object v1; v1 = TOP; @@ -1075,10 +1414,10 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fsub1 (v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Badd1: + CASE (Badd1): { Lisp_Object v1; v1 = TOP; @@ -1093,10 +1432,10 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fadd1 (v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Beqlsign: + CASE (Beqlsign): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1114,57 +1453,57 @@ If the third argument is incorrect, Emacs may crash. */) } else TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil); - break; + NEXT; } - case Bgtr: + CASE (Bgtr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgtr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Blss: + CASE (Blss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Flss (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bleq: + CASE (Bleq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fleq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bgeq: + CASE (Bgeq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgeq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bdiff: + CASE (Bdiff): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fminus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bnegate: + CASE (Bnegate): { Lisp_Object v1; v1 = TOP; @@ -1179,209 +1518,209 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fminus (1, &TOP); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Bplus: + CASE (Bplus): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fplus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmax: + CASE (Bmax): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmax (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmin: + CASE (Bmin): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmin (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmult: + CASE (Bmult): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Ftimes (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bquo: + CASE (Bquo): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fquo (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Brem: + CASE (Brem): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Frem (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bpoint: + CASE (Bpoint): { Lisp_Object v1; XSETFASTINT (v1, PT); PUSH (v1); - break; + NEXT; } - case Bgoto_char: + CASE (Bgoto_char): BEFORE_POTENTIAL_GC (); TOP = Fgoto_char (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Binsert: + CASE (Binsert): BEFORE_POTENTIAL_GC (); TOP = Finsert (1, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case BinsertN: + CASE (BinsertN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Finsert (op, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bpoint_max: + CASE (Bpoint_max): { Lisp_Object v1; XSETFASTINT (v1, ZV); PUSH (v1); - break; + NEXT; } - case Bpoint_min: + CASE (Bpoint_min): { Lisp_Object v1; XSETFASTINT (v1, BEGV); PUSH (v1); - break; + NEXT; } - case Bchar_after: + CASE (Bchar_after): BEFORE_POTENTIAL_GC (); TOP = Fchar_after (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bfollowing_char: + CASE (Bfollowing_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Ffollowing_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bpreceding_char: + CASE (Bpreceding_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Fprevious_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bcurrent_column: + CASE (Bcurrent_column): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); XSETFASTINT (v1, (int) current_column ()); /* iftc */ AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bindent_to: + CASE (Bindent_to): BEFORE_POTENTIAL_GC (); TOP = Findent_to (TOP, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Beolp: + CASE (Beolp): PUSH (Feolp ()); - break; + NEXT; - case Beobp: + CASE (Beobp): PUSH (Feobp ()); - break; + NEXT; - case Bbolp: + CASE (Bbolp): PUSH (Fbolp ()); - break; + NEXT; - case Bbobp: + CASE (Bbobp): PUSH (Fbobp ()); - break; + NEXT; - case Bcurrent_buffer: + CASE (Bcurrent_buffer): PUSH (Fcurrent_buffer ()); - break; + NEXT; - case Bset_buffer: + CASE (Bset_buffer): BEFORE_POTENTIAL_GC (); TOP = Fset_buffer (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Binteractive_p: + CASE (Binteractive_p): PUSH (Finteractive_p ()); - break; + NEXT; - case Bforward_char: + CASE (Bforward_char): BEFORE_POTENTIAL_GC (); TOP = Fforward_char (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bforward_word: + CASE (Bforward_word): BEFORE_POTENTIAL_GC (); TOP = Fforward_word (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bskip_chars_forward: + CASE (Bskip_chars_forward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_forward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bskip_chars_backward: + CASE (Bskip_chars_backward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_backward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bforward_line: + CASE (Bforward_line): BEFORE_POTENTIAL_GC (); TOP = Fforward_line (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bchar_syntax: + CASE (Bchar_syntax): { int c; @@ -1393,51 +1732,51 @@ If the third argument is incorrect, Emacs may crash. */) MAKE_CHAR_MULTIBYTE (c); XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]); } - break; + NEXT; - case Bbuffer_substring: + CASE (Bbuffer_substring): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fbuffer_substring (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bdelete_region: + CASE (Bdelete_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fdelete_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnarrow_to_region: + CASE (Bnarrow_to_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnarrow_to_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bwiden: + CASE (Bwiden): BEFORE_POTENTIAL_GC (); PUSH (Fwiden ()); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bend_of_line: + CASE (Bend_of_line): BEFORE_POTENTIAL_GC (); TOP = Fend_of_line (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bset_marker: + CASE (Bset_marker): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1445,72 +1784,72 @@ If the third argument is incorrect, Emacs may crash. */) v2 = POP; TOP = Fset_marker (TOP, v2, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bmatch_beginning: + CASE (Bmatch_beginning): BEFORE_POTENTIAL_GC (); TOP = Fmatch_beginning (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmatch_end: + CASE (Bmatch_end): BEFORE_POTENTIAL_GC (); TOP = Fmatch_end (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bupcase: + CASE (Bupcase): BEFORE_POTENTIAL_GC (); TOP = Fupcase (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bdowncase: + CASE (Bdowncase): BEFORE_POTENTIAL_GC (); TOP = Fdowncase (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bstringeqlsign: + CASE (Bstringeqlsign): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_equal (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bstringlss: + CASE (Bstringlss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_lessp (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bequal: + CASE (Bequal): { Lisp_Object v1; v1 = POP; TOP = Fequal (TOP, v1); - break; + NEXT; } - case Bnthcdr: + CASE (Bnthcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnthcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Belt: + CASE (Belt): { Lisp_Object v1, v2; if (CONSP (TOP)) @@ -1535,104 +1874,105 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Felt (TOP, v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Bmember: + CASE (Bmember): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmember (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bassq: + CASE (Bassq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fassq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnreverse: + CASE (Bnreverse): BEFORE_POTENTIAL_GC (); TOP = Fnreverse (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsetcar: + CASE (Bsetcar): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcar (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsetcdr: + CASE (Bsetcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bcar_safe: + CASE (Bcar_safe): { Lisp_Object v1; v1 = TOP; TOP = CAR_SAFE (v1); - break; + NEXT; } - case Bcdr_safe: + CASE (Bcdr_safe): { Lisp_Object v1; v1 = TOP; TOP = CDR_SAFE (v1); - break; + NEXT; } - case Bnconc: + CASE (Bnconc): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fnconc (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bnumberp: + CASE (Bnumberp): TOP = (NUMBERP (TOP) ? Qt : Qnil); - break; + NEXT; - case Bintegerp: + CASE (Bintegerp): TOP = INTEGERP (TOP) ? Qt : Qnil; - break; + NEXT; #ifdef BYTE_CODE_SAFE - case Bset_mark: + CASE (Bset_mark): BEFORE_POTENTIAL_GC (); error ("set-mark is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; - case Bscan_buffer: + NEXT; + CASE (Bscan_buffer): BEFORE_POTENTIAL_GC (); error ("scan-buffer is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; -#endif - - case 0: + NEXT; +#else + CASE (Bset_mark): + CASE (Bscan_buffer): abort (); +#endif - case 255: - default: + CASE_DEFAULT + CASE (Bconstant): #ifdef BYTE_CODE_SAFE if (op < Bconstant) { @@ -1646,6 +1986,10 @@ If the third argument is incorrect, Emacs may crash. */) #else PUSH (vectorp[op - Bconstant]); #endif + NEXT; + + CASE_ABORT: + abort (); } } From rgm@gnu.org Thu Sep 17 14:13:38 2009 Received: (at 4470-quiet) by emacsbugs.donarmstrong.com; 17 Sep 2009 21:13:38 +0000 X-Spam-Checker-Version: SpamAssassin 3.2.5-bugs.debian.org_2005_01_02 (2008-06-10) on rzlab.ucr.edu X-Spam-Level: X-Spam-Bayes: score:0.5 Bayes not run. spammytokens:Tokens not available. hammytokens:Tokens not available. X-Spam-Status: No, score=-7.6 required=4.0 tests=AWL,HAS_BUG_NUMBER, X_DEBBUGS_NO_ACK autolearn=ham version=3.2.5-bugs.debian.org_2005_01_02 Received: from fencepost.gnu.org (fencepost.gnu.org [140.186.70.10]) by rzlab.ucr.edu (8.14.3/8.14.3/Debian-5) with ESMTP id n8HLDbDH001149; Thu, 17 Sep 2009 14:13:38 -0700 Received: from rgm by fencepost.gnu.org with local (Exim 4.67) (envelope-from ) id 1MoOIK-0005C5-At; Thu, 17 Sep 2009 17:13:36 -0400 From: Glenn Morris To: 4470-quiet@debbugs.gnu.org Subject: Re: bug#4470: 23.1; threaded interpreter References: X-Spook: event security AIEWS SCUD missile Sears Tower Watergate X-Ran: Hyk"/0{W1,\l63imihA(=`~33sfZ`b\]:|1+=f$M9'#{N.1R2&Up{0R6|k|bGW\$Z3;$\7 X-Hue: magenta X-Debbugs-No-Ack: yes X-Attribution: GM Date: Thu, 17 Sep 2009 17:13:36 -0400 In-Reply-To: (Tom Tromey's message of "Thu, 17 Sep 2009 14:56:58 -0600") Message-ID: User-Agent: Gnus (www.gnus.org), GNU Emacs (www.gnu.org/software/emacs/) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii severity: wishlist stop See discussion at http://lists.gnu.org/archive/html/emacs-devel/2009-09/msg00486.html From rgm@gnu.org Thu Sep 17 14:24:11 2009 Received: (at control) by emacsbugs.donarmstrong.com; 17 Sep 2009 21:24:11 +0000 X-Spam-Checker-Version: SpamAssassin 3.2.5-bugs.debian.org_2005_01_02 (2008-06-10) on rzlab.ucr.edu X-Spam-Level: X-Spam-Bayes: score:0.5 Bayes not run. spammytokens:Tokens not available. hammytokens:Tokens not available. X-Spam-Status: No, score=-5.6 required=4.0 tests=AWL,ONEWORD,VALID_BTS_CONTROL, X_DEBBUGS_NO_ACK autolearn=ham version=3.2.5-bugs.debian.org_2005_01_02 Received: from fencepost.gnu.org (fencepost.gnu.org [140.186.70.10]) by rzlab.ucr.edu (8.14.3/8.14.3/Debian-5) with ESMTP id n8HLOA6h002923 for ; Thu, 17 Sep 2009 14:24:11 -0700 Received: from rgm by fencepost.gnu.org with local (Exim 4.67) (envelope-from ) id 1MoOSX-0005ZF-FK; Thu, 17 Sep 2009 17:24:09 -0400 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-ID: <19122.43257.416327.344257@fencepost.gnu.org> Date: Thu, 17 Sep 2009 17:24:09 -0400 From: Glenn Morris To: control Subject: control X-Attribution: GM X-Mailer: VM (www.wonderworks.com/vm), GNU Emacs (www.gnu.org/software/emacs) X-Hue: red X-Ran: :JbNwb5F>?t*ASpzUJ+AP+ON%82_ehu`*c$7*9rFTq!:c=g(*'p_^S`KX{n@:/[s"p8mJJ X-Debbugs-No-Ack: yes severity 4470 wishlist reassign 4465 spam reassign 4466 spam severity 4440 minor From tromey@redhat.com Fri Sep 18 10:36:54 2009 Received: (at 4470) by emacsbugs.donarmstrong.com; 18 Sep 2009 17:36:54 +0000 X-Spam-Checker-Version: SpamAssassin 3.2.5-bugs.debian.org_2005_01_02 (2008-06-10) on rzlab.ucr.edu X-Spam-Level: X-Spam-Bayes: score:0.5 Bayes not run. spammytokens:Tokens not available. hammytokens:Tokens not available. X-Spam-Status: No, score=-0.5 required=4.0 tests=AWL,FOURLA,FVGT_m_MULTI_ODD, HAS_BUG_NUMBER,IMPRONONCABLE_1,MURPHY_DRUGS_REL8,MURPHY_WRONG_WORD1, MURPHY_WRONG_WORD2,PHONENUMBER,SPF_HELO_PASS autolearn=ham version=3.2.5-bugs.debian.org_2005_01_02 Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by rzlab.ucr.edu (8.14.3/8.14.3/Debian-5) with ESMTP id n8IHar1V029413 for <4470@emacsbugs.donarmstrong.com>; Fri, 18 Sep 2009 10:36:54 -0700 Received: from int-mx04.intmail.prod.int.phx2.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.17]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id n8IHaqjC006579 for <4470@emacsbugs.donarmstrong.com>; Fri, 18 Sep 2009 13:36:53 -0400 Received: from ns3.rdu.redhat.com (ns3.rdu.redhat.com [10.11.255.199]) by int-mx04.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id n8IHamWU032236; Fri, 18 Sep 2009 13:36:49 -0400 Received: from opsy.redhat.com (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by ns3.rdu.redhat.com (8.13.8/8.13.8) with ESMTP id n8IHaoQP008015; Fri, 18 Sep 2009 13:36:50 -0400 Received: by opsy.redhat.com (Postfix, from userid 500) id E68D4378204; Fri, 18 Sep 2009 11:36:49 -0600 (MDT) From: Tom Tromey To: 4470@debbugs.gnu.org Subject: Re: bug#4470: Acknowledgement (23.1; threaded interpreter) References: Reply-To: Tom Tromey X-Attribution: Tom Date: Fri, 18 Sep 2009 11:36:49 -0600 In-Reply-To: (Emacs bug Tracking System's message of "Thu, 17 Sep 2009 21:05:05 +0000") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Scanned-By: MIMEDefang 2.67 on 10.5.11.17 Here is an updated version of the patch. This addresses some comments from Stefan and RMS. Tom diff --git a/src/bytecode.c b/src/bytecode.c index 43d972e..5004c5f 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -54,6 +54,13 @@ by Hallvard: /* #define BYTE_CODE_SAFE */ /* #define BYTE_CODE_METER */ +/* If BYTE_CODE_THREADED is defined, then the interpreter will be + indirect threaded, using GCC's computed goto extension. This is + incompatible with BYTE_CODE_SAFE and BYTE_CODE_METER. */ +#if defined (__GNUC__) && !defined (BYTE_CODE_SAFE) && !defined (BYTE_CODE_METER) +#define BYTE_CODE_THREADED +#endif + #ifdef BYTE_CODE_METER @@ -90,10 +97,45 @@ Lisp_Object Qbytecode; /* Byte codes: */ #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 Bnth 070 #define Bsymbolp 071 @@ -463,27 +505,254 @@ If the third argument is incorrect, Emacs may crash. */) this_op = op = FETCH; METER_CODE (prev_op, op); #else +#ifndef BYTE_CODE_THREADED op = FETCH; #endif +#endif + + /* The interpreter can be compiled one of two ways: as an + ordinary switch-based interpreter, or as a threaded + interpreter. The threaded interpreter relies on GCC's + computed goto extension, so it is not available everywhere. + Threading provides a performance boost. These macros are how + we allow the code to be compiled both ways. */ +#ifdef BYTE_CODE_THREADED + /* The CASE macro introduces an instruction's body. It is + either a label or a case label. */ +#define CASE(OP) insn_ ## OP + /* NEXT is invoked at the end of an instruction to go to the + next instruction. It is either a computed goto, or a + plain break. */ +#define NEXT goto *(targets[op = FETCH]) + /* FIRST is like NEXT, but is only used at the start of the + interpreter body. In the switch-based interpreter it is the + switch, so the threaded definition must include a semicolon. */ +#define FIRST NEXT; + /* Most cases are labeled with the CASE macro, above. + CASE_DEFAULT is one exception; it is used if the interpreter + being built requires a default case. The threaded + interpreter does not, because the dispatch table is + completely filled. */ +#define CASE_DEFAULT + /* This introduces an instruction that is known to call abort. */ +#define CASE_ABORT CASE (default) +#else + /* See above for the meaning of the various defines. */ +#define CASE(OP) case OP +#define NEXT break +#define FIRST switch (op) +#define CASE_DEFAULT case 255: default: +#define CASE_ABORT case 0 +#endif + +#ifdef BYTE_CODE_THREADED + + /* A convenience define that saves us a lot of typing and makes + the table clearer. */ +#define LABEL(OP) [OP] = &&insn_ ## OP + + /* This is the dispatch table for the threaded interpreter. */ + static const void *targets[256] = + { + LABEL (Bvarref), + LABEL (Bvarref1), + LABEL (Bvarref2), + LABEL (Bvarref3), + LABEL (Bvarref4), + LABEL (Bvarref5), + LABEL (Bvarref6), + LABEL (Bvarref7), + LABEL (Bvarset), + LABEL (Bvarset1), + LABEL (Bvarset2), + LABEL (Bvarset3), + LABEL (Bvarset4), + LABEL (Bvarset5), + LABEL (Bvarset6), + LABEL (Bvarset7), + LABEL (Bvarbind), + LABEL (Bvarbind1), + LABEL (Bvarbind2), + LABEL (Bvarbind3), + LABEL (Bvarbind4), + LABEL (Bvarbind5), + LABEL (Bvarbind6), + LABEL (Bvarbind7), + LABEL (Bcall), + LABEL (Bcall1), + LABEL (Bcall2), + LABEL (Bcall3), + LABEL (Bcall4), + LABEL (Bcall5), + LABEL (Bcall6), + LABEL (Bcall7), + LABEL (Bunbind), + LABEL (Bunbind1), + LABEL (Bunbind2), + LABEL (Bunbind3), + LABEL (Bunbind4), + LABEL (Bunbind5), + LABEL (Bunbind6), + LABEL (Bunbind7), + LABEL (Bnth), + LABEL (Bsymbolp), + LABEL (Bconsp), + LABEL (Bstringp), + LABEL (Blistp), + LABEL (Beq), + LABEL (Bmemq), + LABEL (Bnot), + LABEL (Bcar), + LABEL (Bcdr), + LABEL (Bcons), + LABEL (Blist1), + LABEL (Blist2), + LABEL (Blist3), + LABEL (Blist4), + LABEL (Blength), + LABEL (Baref), + LABEL (Baset), + LABEL (Bsymbol_value), + LABEL (Bsymbol_function), + LABEL (Bset), + LABEL (Bfset), + LABEL (Bget), + LABEL (Bsubstring), + LABEL (Bconcat2), + LABEL (Bconcat3), + LABEL (Bconcat4), + LABEL (Bsub1), + LABEL (Badd1), + LABEL (Beqlsign), + LABEL (Bgtr), + LABEL (Blss), + LABEL (Bleq), + LABEL (Bgeq), + LABEL (Bdiff), + LABEL (Bnegate), + LABEL (Bplus), + LABEL (Bmax), + LABEL (Bmin), + LABEL (Bmult), + LABEL (Bpoint), + LABEL (Bsave_current_buffer), + LABEL (Bgoto_char), + LABEL (Binsert), + LABEL (Bpoint_max), + LABEL (Bpoint_min), + LABEL (Bchar_after), + LABEL (Bfollowing_char), + LABEL (Bpreceding_char), + LABEL (Bcurrent_column), + LABEL (Bindent_to), + LABEL (Bscan_buffer), + LABEL (Beolp), + LABEL (Beobp), + LABEL (Bbolp), + LABEL (Bbobp), + LABEL (Bcurrent_buffer), + LABEL (Bset_buffer), + LABEL (Bsave_current_buffer_1), + LABEL (Bset_mark), + LABEL (Binteractive_p), + LABEL (Bforward_char), + LABEL (Bforward_word), + LABEL (Bskip_chars_forward), + LABEL (Bskip_chars_backward), + LABEL (Bforward_line), + LABEL (Bchar_syntax), + LABEL (Bbuffer_substring), + LABEL (Bdelete_region), + LABEL (Bnarrow_to_region), + LABEL (Bwiden), + LABEL (Bend_of_line), + LABEL (Bconstant2), + LABEL (Bgoto), + LABEL (Bgotoifnil), + LABEL (Bgotoifnonnil), + LABEL (Bgotoifnilelsepop), + LABEL (Bgotoifnonnilelsepop), + LABEL (Breturn), + LABEL (Bdiscard), + LABEL (Bdup), + LABEL (Bsave_excursion), + LABEL (Bsave_window_excursion), + LABEL (Bsave_restriction), + LABEL (Bcatch), + LABEL (Bunwind_protect), + LABEL (Bcondition_case), + LABEL (Btemp_output_buffer_setup), + LABEL (Btemp_output_buffer_show), + LABEL (Bunbind_all), + LABEL (Bset_marker), + LABEL (Bmatch_beginning), + LABEL (Bmatch_end), + LABEL (Bupcase), + LABEL (Bdowncase), + LABEL (Bstringeqlsign), + LABEL (Bstringlss), + LABEL (Bequal), + LABEL (Bnthcdr), + LABEL (Belt), + LABEL (Bmember), + LABEL (Bassq), + LABEL (Bnreverse), + LABEL (Bsetcar), + LABEL (Bsetcdr), + LABEL (Bcar_safe), + LABEL (Bcdr_safe), + LABEL (Bnconc), + LABEL (Bquo), + LABEL (Brem), + LABEL (Bnumberp), + LABEL (Bintegerp), + LABEL (BRgoto), + LABEL (BRgotoifnil), + LABEL (BRgotoifnonnil), + LABEL (BRgotoifnilelsepop), + LABEL (BRgotoifnonnilelsepop), + LABEL (BlistN), + LABEL (BconcatN), + LABEL (BinsertN), + LABEL (Bconstant) + }; + + static int initialized; + + if (!initialized) + { + int i; + initialized = 1; + /* We must initialize every slot in the table. An empty + slot before Bconstant should just abort. All the opcodes + after Bconstant should use the same code as Bconstant. */ + for (i = 0; i < 256; ++i) + { + if (!targets[i]) + targets[i] = i < Bconstant ? &&insn_default : &&insn_Bconstant; + } + } +#endif + - switch (op) + FIRST { - case Bvarref + 7: + CASE (Bvarref7): op = FETCH2; goto varref; - case Bvarref: - case Bvarref + 1: - case Bvarref + 2: - case Bvarref + 3: - case Bvarref + 4: - case Bvarref + 5: + CASE (Bvarref): + CASE (Bvarref1): + CASE (Bvarref2): + CASE (Bvarref3): + CASE (Bvarref4): + CASE (Bvarref5): op = op - Bvarref; goto varref; /* This seems to be the most frequently executed byte-code among the Bvarref's, so avoid a goto here. */ - case Bvarref+6: + CASE (Bvarref6): op = FETCH; varref: { @@ -507,10 +776,10 @@ If the third argument is incorrect, Emacs may crash. */) AFTER_POTENTIAL_GC (); } PUSH (v2); - break; + NEXT; } - case Bgotoifnil: + CASE (Bgotoifnil): { Lisp_Object v1; MAYBE_GC (); @@ -522,57 +791,57 @@ If the third argument is incorrect, Emacs may crash. */) CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + NEXT; } - case Bcar: + CASE (Bcar): { Lisp_Object v1; v1 = TOP; TOP = CAR (v1); - break; + NEXT; } - case Beq: + CASE (Beq): { Lisp_Object v1; v1 = POP; TOP = EQ (v1, TOP) ? Qt : Qnil; - break; + NEXT; } - case Bmemq: + CASE (Bmemq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmemq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bcdr: + CASE (Bcdr): { Lisp_Object v1; v1 = TOP; TOP = CDR (v1); - break; + NEXT; } - case Bvarset: - case Bvarset+1: - case Bvarset+2: - case Bvarset+3: - case Bvarset+4: - case Bvarset+5: + CASE (Bvarset): + CASE (Bvarset1): + CASE (Bvarset2): + CASE (Bvarset3): + CASE (Bvarset4): + CASE (Bvarset5): op -= Bvarset; goto varset; - case Bvarset+7: + CASE (Bvarset7): op = FETCH2; goto varset; - case Bvarset+6: + CASE (Bvarset6): op = FETCH; varset: { @@ -596,54 +865,54 @@ If the third argument is incorrect, Emacs may crash. */) } } (void) POP; - break; + NEXT; - case Bdup: + CASE (Bdup): { Lisp_Object v1; v1 = TOP; PUSH (v1); - break; + NEXT; } /* ------------------ */ - case Bvarbind+6: + CASE (Bvarbind6): op = FETCH; goto varbind; - case Bvarbind+7: + CASE (Bvarbind7): op = FETCH2; goto varbind; - case Bvarbind: - case Bvarbind+1: - case Bvarbind+2: - case Bvarbind+3: - case Bvarbind+4: - case Bvarbind+5: + CASE (Bvarbind): + CASE (Bvarbind1): + CASE (Bvarbind2): + CASE (Bvarbind3): + CASE (Bvarbind4): + CASE (Bvarbind5): op -= Bvarbind; varbind: /* Specbind can signal and thus GC. */ BEFORE_POTENTIAL_GC (); specbind (vectorp[op], POP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bcall+6: + CASE (Bcall6): op = FETCH; goto docall; - case Bcall+7: + CASE (Bcall7): op = FETCH2; goto docall; - case Bcall: - case Bcall+1: - case Bcall+2: - case Bcall+3: - case Bcall+4: - case Bcall+5: + CASE (Bcall): + CASE (Bcall1): + CASE (Bcall2): + CASE (Bcall3): + CASE (Bcall4): + CASE (Bcall5): op -= Bcall; docall: { @@ -666,47 +935,47 @@ If the third argument is incorrect, Emacs may crash. */) #endif TOP = Ffuncall (op + 1, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bunbind+6: + CASE (Bunbind6): op = FETCH; goto dounbind; - case Bunbind+7: + CASE (Bunbind7): op = FETCH2; goto dounbind; - case Bunbind: - case Bunbind+1: - case Bunbind+2: - case Bunbind+3: - case Bunbind+4: - case Bunbind+5: + CASE (Bunbind): + CASE (Bunbind1): + CASE (Bunbind2): + CASE (Bunbind3): + CASE (Bunbind4): + CASE (Bunbind5): op -= Bunbind; dounbind: BEFORE_POTENTIAL_GC (); unbind_to (SPECPDL_INDEX () - op, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bunbind_all: + CASE (Bunbind_all): /* To unbind back to the beginning of this frame. Not used yet, but will be needed for tail-recursion elimination. */ BEFORE_POTENTIAL_GC (); unbind_to (count, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bgoto: + CASE (Bgoto): MAYBE_GC (); BYTE_CODE_QUIT; op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */ CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; - break; + NEXT; - case Bgotoifnonnil: + CASE (Bgotoifnonnil): { Lisp_Object v1; MAYBE_GC (); @@ -718,10 +987,10 @@ If the third argument is incorrect, Emacs may crash. */) CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + NEXT; } - case Bgotoifnilelsepop: + CASE (Bgotoifnilelsepop): MAYBE_GC (); op = FETCH2; if (NILP (TOP)) @@ -731,9 +1000,9 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + NEXT; - case Bgotoifnonnilelsepop: + CASE (Bgotoifnonnilelsepop): MAYBE_GC (); op = FETCH2; if (!NILP (TOP)) @@ -743,15 +1012,15 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + NEXT; - case BRgoto: + CASE (BRgoto): MAYBE_GC (); BYTE_CODE_QUIT; stack.pc += (int) *stack.pc - 127; - break; + NEXT; - case BRgotoifnil: + CASE (BRgotoifnil): { Lisp_Object v1; MAYBE_GC (); @@ -762,10 +1031,10 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + NEXT; } - case BRgotoifnonnil: + CASE (BRgotoifnonnil): { Lisp_Object v1; MAYBE_GC (); @@ -776,10 +1045,10 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + NEXT; } - case BRgotoifnilelsepop: + CASE (BRgotoifnilelsepop): MAYBE_GC (); op = *stack.pc++; if (NILP (TOP)) @@ -788,9 +1057,9 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += op - 128; } else DISCARD (1); - break; + NEXT; - case BRgotoifnonnilelsepop: + CASE (BRgotoifnonnilelsepop): MAYBE_GC (); op = *stack.pc++; if (!NILP (TOP)) @@ -799,56 +1068,56 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += op - 128; } else DISCARD (1); - break; + NEXT; - case Breturn: + CASE (Breturn): result = POP; goto exit; - case Bdiscard: + CASE (Bdiscard): DISCARD (1); - break; + NEXT; - case Bconstant2: + CASE (Bconstant2): PUSH (vectorp[FETCH2]); - break; + NEXT; - case Bsave_excursion: + CASE (Bsave_excursion): record_unwind_protect (save_excursion_restore, save_excursion_save ()); - break; + NEXT; - case Bsave_current_buffer: - case Bsave_current_buffer_1: + CASE (Bsave_current_buffer): + CASE (Bsave_current_buffer_1): record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ()); - break; + NEXT; - case Bsave_window_excursion: + CASE (Bsave_window_excursion): BEFORE_POTENTIAL_GC (); TOP = Fsave_window_excursion (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsave_restriction: + CASE (Bsave_restriction): record_unwind_protect (save_restriction_restore, save_restriction_save ()); - break; + NEXT; - case Bcatch: + CASE (Bcatch): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = internal_catch (TOP, Feval, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bunwind_protect: + CASE (Bunwind_protect): record_unwind_protect (Fprogn, POP); - break; + NEXT; - case Bcondition_case: + CASE (Bcondition_case): { Lisp_Object handlers, body; handlers = POP; @@ -856,18 +1125,18 @@ If the third argument is incorrect, Emacs may crash. */) BEFORE_POTENTIAL_GC (); TOP = internal_lisp_condition_case (TOP, body, handlers); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Btemp_output_buffer_setup: + CASE (Btemp_output_buffer_setup): BEFORE_POTENTIAL_GC (); CHECK_STRING (TOP); temp_output_buffer_setup (SDATA (TOP)); AFTER_POTENTIAL_GC (); TOP = Vstandard_output; - break; + NEXT; - case Btemp_output_buffer_show: + CASE (Btemp_output_buffer_show): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); @@ -877,10 +1146,10 @@ If the third argument is incorrect, Emacs may crash. */) /* pop binding of standard-output */ unbind_to (SPECPDL_INDEX () - 1, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnth: + CASE (Bnth): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -894,173 +1163,173 @@ If the third argument is incorrect, Emacs may crash. */) v1 = XCDR (v1); immediate_quit = 0; TOP = CAR (v1); - break; + NEXT; } - case Bsymbolp: + CASE (Bsymbolp): TOP = SYMBOLP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bconsp: + CASE (Bconsp): TOP = CONSP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bstringp: + CASE (Bstringp): TOP = STRINGP (TOP) ? Qt : Qnil; - break; + NEXT; - case Blistp: + CASE (Blistp): TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bnot: + CASE (Bnot): TOP = NILP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bcons: + CASE (Bcons): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, v1); - break; + NEXT; } - case Blist1: + CASE (Blist1): TOP = Fcons (TOP, Qnil); - break; + NEXT; - case Blist2: + CASE (Blist2): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, Fcons (v1, Qnil)); - break; + NEXT; } - case Blist3: + CASE (Blist3): DISCARD (2); TOP = Flist (3, &TOP); - break; + NEXT; - case Blist4: + CASE (Blist4): DISCARD (3); TOP = Flist (4, &TOP); - break; + NEXT; - case BlistN: + CASE (BlistN): op = FETCH; DISCARD (op - 1); TOP = Flist (op, &TOP); - break; + NEXT; - case Blength: + CASE (Blength): BEFORE_POTENTIAL_GC (); TOP = Flength (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Baref: + CASE (Baref): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Faref (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Baset: + CASE (Baset): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Faset (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsymbol_value: + CASE (Bsymbol_value): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_value (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsymbol_function: + CASE (Bsymbol_function): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_function (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bset: + CASE (Bset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bfset: + CASE (Bfset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Ffset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bget: + CASE (Bget): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fget (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsubstring: + CASE (Bsubstring): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Fsubstring (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bconcat2: + CASE (Bconcat2): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fconcat (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bconcat3: + CASE (Bconcat3): BEFORE_POTENTIAL_GC (); DISCARD (2); TOP = Fconcat (3, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bconcat4: + CASE (Bconcat4): BEFORE_POTENTIAL_GC (); DISCARD (3); TOP = Fconcat (4, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case BconcatN: + CASE (BconcatN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Fconcat (op, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsub1: + CASE (Bsub1): { Lisp_Object v1; v1 = TOP; @@ -1075,10 +1344,10 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fsub1 (v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Badd1: + CASE (Badd1): { Lisp_Object v1; v1 = TOP; @@ -1093,10 +1362,10 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fadd1 (v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Beqlsign: + CASE (Beqlsign): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1114,57 +1383,57 @@ If the third argument is incorrect, Emacs may crash. */) } else TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil); - break; + NEXT; } - case Bgtr: + CASE (Bgtr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgtr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Blss: + CASE (Blss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Flss (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bleq: + CASE (Bleq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fleq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bgeq: + CASE (Bgeq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgeq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bdiff: + CASE (Bdiff): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fminus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bnegate: + CASE (Bnegate): { Lisp_Object v1; v1 = TOP; @@ -1179,209 +1448,209 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fminus (1, &TOP); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Bplus: + CASE (Bplus): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fplus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmax: + CASE (Bmax): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmax (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmin: + CASE (Bmin): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmin (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmult: + CASE (Bmult): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Ftimes (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bquo: + CASE (Bquo): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fquo (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Brem: + CASE (Brem): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Frem (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bpoint: + CASE (Bpoint): { Lisp_Object v1; XSETFASTINT (v1, PT); PUSH (v1); - break; + NEXT; } - case Bgoto_char: + CASE (Bgoto_char): BEFORE_POTENTIAL_GC (); TOP = Fgoto_char (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Binsert: + CASE (Binsert): BEFORE_POTENTIAL_GC (); TOP = Finsert (1, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case BinsertN: + CASE (BinsertN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Finsert (op, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bpoint_max: + CASE (Bpoint_max): { Lisp_Object v1; XSETFASTINT (v1, ZV); PUSH (v1); - break; + NEXT; } - case Bpoint_min: + CASE (Bpoint_min): { Lisp_Object v1; XSETFASTINT (v1, BEGV); PUSH (v1); - break; + NEXT; } - case Bchar_after: + CASE (Bchar_after): BEFORE_POTENTIAL_GC (); TOP = Fchar_after (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bfollowing_char: + CASE (Bfollowing_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Ffollowing_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bpreceding_char: + CASE (Bpreceding_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Fprevious_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bcurrent_column: + CASE (Bcurrent_column): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); XSETFASTINT (v1, (int) current_column ()); /* iftc */ AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bindent_to: + CASE (Bindent_to): BEFORE_POTENTIAL_GC (); TOP = Findent_to (TOP, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Beolp: + CASE (Beolp): PUSH (Feolp ()); - break; + NEXT; - case Beobp: + CASE (Beobp): PUSH (Feobp ()); - break; + NEXT; - case Bbolp: + CASE (Bbolp): PUSH (Fbolp ()); - break; + NEXT; - case Bbobp: + CASE (Bbobp): PUSH (Fbobp ()); - break; + NEXT; - case Bcurrent_buffer: + CASE (Bcurrent_buffer): PUSH (Fcurrent_buffer ()); - break; + NEXT; - case Bset_buffer: + CASE (Bset_buffer): BEFORE_POTENTIAL_GC (); TOP = Fset_buffer (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Binteractive_p: + CASE (Binteractive_p): PUSH (Finteractive_p ()); - break; + NEXT; - case Bforward_char: + CASE (Bforward_char): BEFORE_POTENTIAL_GC (); TOP = Fforward_char (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bforward_word: + CASE (Bforward_word): BEFORE_POTENTIAL_GC (); TOP = Fforward_word (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bskip_chars_forward: + CASE (Bskip_chars_forward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_forward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bskip_chars_backward: + CASE (Bskip_chars_backward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_backward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bforward_line: + CASE (Bforward_line): BEFORE_POTENTIAL_GC (); TOP = Fforward_line (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bchar_syntax: + CASE (Bchar_syntax): { int c; @@ -1393,51 +1662,51 @@ If the third argument is incorrect, Emacs may crash. */) MAKE_CHAR_MULTIBYTE (c); XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]); } - break; + NEXT; - case Bbuffer_substring: + CASE (Bbuffer_substring): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fbuffer_substring (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bdelete_region: + CASE (Bdelete_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fdelete_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnarrow_to_region: + CASE (Bnarrow_to_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnarrow_to_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bwiden: + CASE (Bwiden): BEFORE_POTENTIAL_GC (); PUSH (Fwiden ()); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bend_of_line: + CASE (Bend_of_line): BEFORE_POTENTIAL_GC (); TOP = Fend_of_line (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bset_marker: + CASE (Bset_marker): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1445,72 +1714,72 @@ If the third argument is incorrect, Emacs may crash. */) v2 = POP; TOP = Fset_marker (TOP, v2, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bmatch_beginning: + CASE (Bmatch_beginning): BEFORE_POTENTIAL_GC (); TOP = Fmatch_beginning (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmatch_end: + CASE (Bmatch_end): BEFORE_POTENTIAL_GC (); TOP = Fmatch_end (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bupcase: + CASE (Bupcase): BEFORE_POTENTIAL_GC (); TOP = Fupcase (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bdowncase: + CASE (Bdowncase): BEFORE_POTENTIAL_GC (); TOP = Fdowncase (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bstringeqlsign: + CASE (Bstringeqlsign): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_equal (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bstringlss: + CASE (Bstringlss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_lessp (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bequal: + CASE (Bequal): { Lisp_Object v1; v1 = POP; TOP = Fequal (TOP, v1); - break; + NEXT; } - case Bnthcdr: + CASE (Bnthcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnthcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Belt: + CASE (Belt): { Lisp_Object v1, v2; if (CONSP (TOP)) @@ -1535,104 +1804,105 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Felt (TOP, v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Bmember: + CASE (Bmember): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmember (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bassq: + CASE (Bassq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fassq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnreverse: + CASE (Bnreverse): BEFORE_POTENTIAL_GC (); TOP = Fnreverse (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsetcar: + CASE (Bsetcar): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcar (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsetcdr: + CASE (Bsetcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bcar_safe: + CASE (Bcar_safe): { Lisp_Object v1; v1 = TOP; TOP = CAR_SAFE (v1); - break; + NEXT; } - case Bcdr_safe: + CASE (Bcdr_safe): { Lisp_Object v1; v1 = TOP; TOP = CDR_SAFE (v1); - break; + NEXT; } - case Bnconc: + CASE (Bnconc): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fnconc (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bnumberp: + CASE (Bnumberp): TOP = (NUMBERP (TOP) ? Qt : Qnil); - break; + NEXT; - case Bintegerp: + CASE (Bintegerp): TOP = INTEGERP (TOP) ? Qt : Qnil; - break; + NEXT; #ifdef BYTE_CODE_SAFE - case Bset_mark: + CASE (Bset_mark): BEFORE_POTENTIAL_GC (); error ("set-mark is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; - case Bscan_buffer: + NEXT; + CASE (Bscan_buffer): BEFORE_POTENTIAL_GC (); error ("scan-buffer is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; -#endif - - case 0: + NEXT; +#else + CASE (Bset_mark): + CASE (Bscan_buffer): abort (); +#endif - case 255: - default: + CASE_DEFAULT + CASE (Bconstant): #ifdef BYTE_CODE_SAFE if (op < Bconstant) { @@ -1646,6 +1916,10 @@ If the third argument is incorrect, Emacs may crash. */) #else PUSH (vectorp[op - Bconstant]); #endif + NEXT; + + CASE_ABORT: + abort (); } } From whitebox@nefkom.net Fri Sep 18 11:25:53 2009 Received: (at 4470) by emacsbugs.donarmstrong.com; 18 Sep 2009 18:25:54 +0000 X-Spam-Checker-Version: SpamAssassin 3.2.5-bugs.debian.org_2005_01_02 (2008-06-10) on rzlab.ucr.edu X-Spam-Level: X-Spam-Bayes: score:0.5 Bayes not run. spammytokens:Tokens not available. hammytokens:Tokens not available. X-Spam-Status: No, score=-2.8 required=4.0 tests=AWL,HAS_BUG_NUMBER autolearn=ham version=3.2.5-bugs.debian.org_2005_01_02 Received: from mail-out.m-online.net (mail-out.m-online.net [212.18.0.10]) by rzlab.ucr.edu (8.14.3/8.14.3/Debian-5) with ESMTP id n8IIPpuL005332 for <4470@emacsbugs.donarmstrong.com>; Fri, 18 Sep 2009 11:25:53 -0700 Received: from mail01.m-online.net (mail.m-online.net [192.168.3.149]) by mail-out.m-online.net (Postfix) with ESMTP id 6A9531C0032A; Fri, 18 Sep 2009 20:25:50 +0200 (CEST) Received: from localhost (dynscan1.mnet-online.de [192.168.8.164]) by mail.m-online.net (Postfix) with ESMTP id 0F5D990171; Fri, 18 Sep 2009 20:25:50 +0200 (CEST) X-Virus-Scanned: amavisd-new at mnet-online.de Received: from mail.mnet-online.de ([192.168.3.149]) by localhost (dynscan1.mnet-online.de [192.168.8.164]) (amavisd-new, port 10024) with ESMTP id HfqIgAcQjAWn; Fri, 18 Sep 2009 20:26:37 +0200 (CEST) Received: from igel.home (DSL01.83.171.184.139.ip-pool.NEFkom.net [83.171.184.139]) by mail.mnet-online.de (Postfix) with ESMTP; Fri, 18 Sep 2009 20:25:49 +0200 (CEST) Received: by igel.home (Postfix, from userid 501) id 2C746140046; Fri, 18 Sep 2009 20:25:46 +0200 (CEST) From: Andreas Schwab To: Tom Tromey Cc: 4470@debbugs.gnu.org Subject: Re: bug#4470: Acknowledgement (23.1; threaded interpreter) References: X-Yow: ..I just walked into th' HOUSE OF REPRESENTATIVES with fourteen WET DOLPHINS and an out-of-date MARRIAGE MANUAL... Date: Fri, 18 Sep 2009 20:25:46 +0200 In-Reply-To: (Tom Tromey's message of "Fri, 18 Sep 2009 11:36:49 -0600") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Tom Tromey writes: > + static int initialized; > + > + if (!initialized) > + { > + int i; > + initialized = 1; > + /* We must initialize every slot in the table. An empty > + slot before Bconstant should just abort. All the opcodes > + after Bconstant should use the same code as Bconstant. */ > + for (i = 0; i < 256; ++i) > + { > + if (!targets[i]) > + targets[i] = i < Bconstant ? &&insn_default : &&insn_Bconstant; > + } > + } > +#endif You can use [0 ... 255] = &&insn_default, [Bconstant ... 255] = &&insn_Bconstant to statically initialize the array, avoiding the runtime initialisation. Andreas. -- Andreas Schwab, schwab@linux-m68k.org GPG Key fingerprint = 58CA 54C7 6D53 942B 1756 01D3 44D5 214B 8276 4ED5 "And now for something completely different." From tromey@redhat.com Fri Sep 18 12:00:46 2009 Received: (at 4470) by emacsbugs.donarmstrong.com; 18 Sep 2009 19:00:46 +0000 X-Spam-Checker-Version: SpamAssassin 3.2.5-bugs.debian.org_2005_01_02 (2008-06-10) on rzlab.ucr.edu X-Spam-Level: X-Spam-Bayes: score:0.5 Bayes not run. spammytokens:Tokens not available. hammytokens:Tokens not available. X-Spam-Status: No, score=-1.3 required=4.0 tests=AWL,FOURLA,FVGT_m_MULTI_ODD, HAS_BUG_NUMBER,IMPRONONCABLE_1,MURPHY_DRUGS_REL8,MURPHY_WRONG_WORD1, MURPHY_WRONG_WORD2,SPF_HELO_PASS autolearn=ham version=3.2.5-bugs.debian.org_2005_01_02 Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by rzlab.ucr.edu (8.14.3/8.14.3/Debian-5) with ESMTP id n8IJ0irQ010676 for <4470@emacsbugs.donarmstrong.com>; Fri, 18 Sep 2009 12:00:45 -0700 Received: from int-mx03.intmail.prod.int.phx2.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.16]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id n8IJ0f3a017616; Fri, 18 Sep 2009 15:00:41 -0400 Received: from ns3.rdu.redhat.com (ns3.rdu.redhat.com [10.11.255.199]) by int-mx03.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id n8IJ0Uib016637; Fri, 18 Sep 2009 15:00:37 -0400 Received: from opsy.redhat.com (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by ns3.rdu.redhat.com (8.13.8/8.13.8) with ESMTP id n8IJ0T3p014825; Fri, 18 Sep 2009 15:00:29 -0400 Received: by opsy.redhat.com (Postfix, from userid 500) id 9CCFF3782A5; Fri, 18 Sep 2009 13:00:28 -0600 (MDT) From: Tom Tromey To: Andreas Schwab Cc: 4470@debbugs.gnu.org Subject: Re: bug#4470: Acknowledgement (23.1; threaded interpreter) References: Reply-To: Tom Tromey X-Attribution: Tom Date: Fri, 18 Sep 2009 13:00:28 -0600 In-Reply-To: (Andreas Schwab's message of "Fri, 18 Sep 2009 20:25:46 +0200") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.1 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Scanned-By: MIMEDefang 2.67 on 10.5.11.16 Andreas> You can use [0 ... 255] = &&insn_default, [Bconstant ... 255] = Andreas> &&insn_Bconstant to statically initialize the array, avoiding the Andreas> runtime initialisation. Why, so you can. For some reason I thought that would be an error. New patch appended. Tom diff --git a/src/bytecode.c b/src/bytecode.c index 43d972e..5031472 100644 --- a/src/bytecode.c +++ b/src/bytecode.c @@ -54,6 +54,13 @@ by Hallvard: /* #define BYTE_CODE_SAFE */ /* #define BYTE_CODE_METER */ +/* If BYTE_CODE_THREADED is defined, then the interpreter will be + indirect threaded, using GCC's computed goto extension. This is + incompatible with BYTE_CODE_SAFE and BYTE_CODE_METER. */ +#if defined (__GNUC__) && !defined (BYTE_CODE_SAFE) && !defined (BYTE_CODE_METER) +#define BYTE_CODE_THREADED +#endif + #ifdef BYTE_CODE_METER @@ -90,10 +97,45 @@ Lisp_Object Qbytecode; /* Byte codes: */ #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 Bnth 070 #define Bsymbolp 071 @@ -463,27 +505,241 @@ If the third argument is incorrect, Emacs may crash. */) this_op = op = FETCH; METER_CODE (prev_op, op); #else +#ifndef BYTE_CODE_THREADED op = FETCH; #endif +#endif + + /* The interpreter can be compiled one of two ways: as an + ordinary switch-based interpreter, or as a threaded + interpreter. The threaded interpreter relies on GCC's + computed goto extension, so it is not available everywhere. + Threading provides a performance boost. These macros are how + we allow the code to be compiled both ways. */ +#ifdef BYTE_CODE_THREADED + /* The CASE macro introduces an instruction's body. It is + either a label or a case label. */ +#define CASE(OP) insn_ ## OP + /* NEXT is invoked at the end of an instruction to go to the + next instruction. It is either a computed goto, or a + plain break. */ +#define NEXT goto *(targets[op = FETCH]) + /* FIRST is like NEXT, but is only used at the start of the + interpreter body. In the switch-based interpreter it is the + switch, so the threaded definition must include a semicolon. */ +#define FIRST NEXT; + /* Most cases are labeled with the CASE macro, above. + CASE_DEFAULT is one exception; it is used if the interpreter + being built requires a default case. The threaded + interpreter does not, because the dispatch table is + completely filled. */ +#define CASE_DEFAULT + /* This introduces an instruction that is known to call abort. */ +#define CASE_ABORT CASE (default) +#else + /* See above for the meaning of the various defines. */ +#define CASE(OP) case OP +#define NEXT break +#define FIRST switch (op) +#define CASE_DEFAULT case 255: default: +#define CASE_ABORT case 0 +#endif + +#ifdef BYTE_CODE_THREADED + + /* A convenience define that saves us a lot of typing and makes + the table clearer. */ +#define LABEL(OP) [OP] = &&insn_ ## OP + + /* This is the dispatch table for the threaded interpreter. */ + static const void *const targets[256] = + { + [0 ... (Bconstant - 1)] = &&insn_default, + [Bconstant ... 255] = &&insn_Bconstant, + + LABEL (Bvarref), + LABEL (Bvarref1), + LABEL (Bvarref2), + LABEL (Bvarref3), + LABEL (Bvarref4), + LABEL (Bvarref5), + LABEL (Bvarref6), + LABEL (Bvarref7), + LABEL (Bvarset), + LABEL (Bvarset1), + LABEL (Bvarset2), + LABEL (Bvarset3), + LABEL (Bvarset4), + LABEL (Bvarset5), + LABEL (Bvarset6), + LABEL (Bvarset7), + LABEL (Bvarbind), + LABEL (Bvarbind1), + LABEL (Bvarbind2), + LABEL (Bvarbind3), + LABEL (Bvarbind4), + LABEL (Bvarbind5), + LABEL (Bvarbind6), + LABEL (Bvarbind7), + LABEL (Bcall), + LABEL (Bcall1), + LABEL (Bcall2), + LABEL (Bcall3), + LABEL (Bcall4), + LABEL (Bcall5), + LABEL (Bcall6), + LABEL (Bcall7), + LABEL (Bunbind), + LABEL (Bunbind1), + LABEL (Bunbind2), + LABEL (Bunbind3), + LABEL (Bunbind4), + LABEL (Bunbind5), + LABEL (Bunbind6), + LABEL (Bunbind7), + LABEL (Bnth), + LABEL (Bsymbolp), + LABEL (Bconsp), + LABEL (Bstringp), + LABEL (Blistp), + LABEL (Beq), + LABEL (Bmemq), + LABEL (Bnot), + LABEL (Bcar), + LABEL (Bcdr), + LABEL (Bcons), + LABEL (Blist1), + LABEL (Blist2), + LABEL (Blist3), + LABEL (Blist4), + LABEL (Blength), + LABEL (Baref), + LABEL (Baset), + LABEL (Bsymbol_value), + LABEL (Bsymbol_function), + LABEL (Bset), + LABEL (Bfset), + LABEL (Bget), + LABEL (Bsubstring), + LABEL (Bconcat2), + LABEL (Bconcat3), + LABEL (Bconcat4), + LABEL (Bsub1), + LABEL (Badd1), + LABEL (Beqlsign), + LABEL (Bgtr), + LABEL (Blss), + LABEL (Bleq), + LABEL (Bgeq), + LABEL (Bdiff), + LABEL (Bnegate), + LABEL (Bplus), + LABEL (Bmax), + LABEL (Bmin), + LABEL (Bmult), + LABEL (Bpoint), + LABEL (Bsave_current_buffer), + LABEL (Bgoto_char), + LABEL (Binsert), + LABEL (Bpoint_max), + LABEL (Bpoint_min), + LABEL (Bchar_after), + LABEL (Bfollowing_char), + LABEL (Bpreceding_char), + LABEL (Bcurrent_column), + LABEL (Bindent_to), + LABEL (Bscan_buffer), + LABEL (Beolp), + LABEL (Beobp), + LABEL (Bbolp), + LABEL (Bbobp), + LABEL (Bcurrent_buffer), + LABEL (Bset_buffer), + LABEL (Bsave_current_buffer_1), + LABEL (Bset_mark), + LABEL (Binteractive_p), + LABEL (Bforward_char), + LABEL (Bforward_word), + LABEL (Bskip_chars_forward), + LABEL (Bskip_chars_backward), + LABEL (Bforward_line), + LABEL (Bchar_syntax), + LABEL (Bbuffer_substring), + LABEL (Bdelete_region), + LABEL (Bnarrow_to_region), + LABEL (Bwiden), + LABEL (Bend_of_line), + LABEL (Bconstant2), + LABEL (Bgoto), + LABEL (Bgotoifnil), + LABEL (Bgotoifnonnil), + LABEL (Bgotoifnilelsepop), + LABEL (Bgotoifnonnilelsepop), + LABEL (Breturn), + LABEL (Bdiscard), + LABEL (Bdup), + LABEL (Bsave_excursion), + LABEL (Bsave_window_excursion), + LABEL (Bsave_restriction), + LABEL (Bcatch), + LABEL (Bunwind_protect), + LABEL (Bcondition_case), + LABEL (Btemp_output_buffer_setup), + LABEL (Btemp_output_buffer_show), + LABEL (Bunbind_all), + LABEL (Bset_marker), + LABEL (Bmatch_beginning), + LABEL (Bmatch_end), + LABEL (Bupcase), + LABEL (Bdowncase), + LABEL (Bstringeqlsign), + LABEL (Bstringlss), + LABEL (Bequal), + LABEL (Bnthcdr), + LABEL (Belt), + LABEL (Bmember), + LABEL (Bassq), + LABEL (Bnreverse), + LABEL (Bsetcar), + LABEL (Bsetcdr), + LABEL (Bcar_safe), + LABEL (Bcdr_safe), + LABEL (Bnconc), + LABEL (Bquo), + LABEL (Brem), + LABEL (Bnumberp), + LABEL (Bintegerp), + LABEL (BRgoto), + LABEL (BRgotoifnil), + LABEL (BRgotoifnonnil), + LABEL (BRgotoifnilelsepop), + LABEL (BRgotoifnonnilelsepop), + LABEL (BlistN), + LABEL (BconcatN), + LABEL (BinsertN), + LABEL (Bconstant) + }; +#endif + - switch (op) + FIRST { - case Bvarref + 7: + CASE (Bvarref7): op = FETCH2; goto varref; - case Bvarref: - case Bvarref + 1: - case Bvarref + 2: - case Bvarref + 3: - case Bvarref + 4: - case Bvarref + 5: + CASE (Bvarref): + CASE (Bvarref1): + CASE (Bvarref2): + CASE (Bvarref3): + CASE (Bvarref4): + CASE (Bvarref5): op = op - Bvarref; goto varref; /* This seems to be the most frequently executed byte-code among the Bvarref's, so avoid a goto here. */ - case Bvarref+6: + CASE (Bvarref6): op = FETCH; varref: { @@ -507,10 +763,10 @@ If the third argument is incorrect, Emacs may crash. */) AFTER_POTENTIAL_GC (); } PUSH (v2); - break; + NEXT; } - case Bgotoifnil: + CASE (Bgotoifnil): { Lisp_Object v1; MAYBE_GC (); @@ -522,57 +778,57 @@ If the third argument is incorrect, Emacs may crash. */) CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + NEXT; } - case Bcar: + CASE (Bcar): { Lisp_Object v1; v1 = TOP; TOP = CAR (v1); - break; + NEXT; } - case Beq: + CASE (Beq): { Lisp_Object v1; v1 = POP; TOP = EQ (v1, TOP) ? Qt : Qnil; - break; + NEXT; } - case Bmemq: + CASE (Bmemq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmemq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bcdr: + CASE (Bcdr): { Lisp_Object v1; v1 = TOP; TOP = CDR (v1); - break; + NEXT; } - case Bvarset: - case Bvarset+1: - case Bvarset+2: - case Bvarset+3: - case Bvarset+4: - case Bvarset+5: + CASE (Bvarset): + CASE (Bvarset1): + CASE (Bvarset2): + CASE (Bvarset3): + CASE (Bvarset4): + CASE (Bvarset5): op -= Bvarset; goto varset; - case Bvarset+7: + CASE (Bvarset7): op = FETCH2; goto varset; - case Bvarset+6: + CASE (Bvarset6): op = FETCH; varset: { @@ -596,54 +852,54 @@ If the third argument is incorrect, Emacs may crash. */) } } (void) POP; - break; + NEXT; - case Bdup: + CASE (Bdup): { Lisp_Object v1; v1 = TOP; PUSH (v1); - break; + NEXT; } /* ------------------ */ - case Bvarbind+6: + CASE (Bvarbind6): op = FETCH; goto varbind; - case Bvarbind+7: + CASE (Bvarbind7): op = FETCH2; goto varbind; - case Bvarbind: - case Bvarbind+1: - case Bvarbind+2: - case Bvarbind+3: - case Bvarbind+4: - case Bvarbind+5: + CASE (Bvarbind): + CASE (Bvarbind1): + CASE (Bvarbind2): + CASE (Bvarbind3): + CASE (Bvarbind4): + CASE (Bvarbind5): op -= Bvarbind; varbind: /* Specbind can signal and thus GC. */ BEFORE_POTENTIAL_GC (); specbind (vectorp[op], POP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bcall+6: + CASE (Bcall6): op = FETCH; goto docall; - case Bcall+7: + CASE (Bcall7): op = FETCH2; goto docall; - case Bcall: - case Bcall+1: - case Bcall+2: - case Bcall+3: - case Bcall+4: - case Bcall+5: + CASE (Bcall): + CASE (Bcall1): + CASE (Bcall2): + CASE (Bcall3): + CASE (Bcall4): + CASE (Bcall5): op -= Bcall; docall: { @@ -666,47 +922,47 @@ If the third argument is incorrect, Emacs may crash. */) #endif TOP = Ffuncall (op + 1, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bunbind+6: + CASE (Bunbind6): op = FETCH; goto dounbind; - case Bunbind+7: + CASE (Bunbind7): op = FETCH2; goto dounbind; - case Bunbind: - case Bunbind+1: - case Bunbind+2: - case Bunbind+3: - case Bunbind+4: - case Bunbind+5: + CASE (Bunbind): + CASE (Bunbind1): + CASE (Bunbind2): + CASE (Bunbind3): + CASE (Bunbind4): + CASE (Bunbind5): op -= Bunbind; dounbind: BEFORE_POTENTIAL_GC (); unbind_to (SPECPDL_INDEX () - op, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bunbind_all: + CASE (Bunbind_all): /* To unbind back to the beginning of this frame. Not used yet, but will be needed for tail-recursion elimination. */ BEFORE_POTENTIAL_GC (); unbind_to (count, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bgoto: + CASE (Bgoto): MAYBE_GC (); BYTE_CODE_QUIT; op = FETCH2; /* pc = FETCH2 loses since FETCH2 contains pc++ */ CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; - break; + NEXT; - case Bgotoifnonnil: + CASE (Bgotoifnonnil): { Lisp_Object v1; MAYBE_GC (); @@ -718,10 +974,10 @@ If the third argument is incorrect, Emacs may crash. */) CHECK_RANGE (op); stack.pc = stack.byte_string_start + op; } - break; + NEXT; } - case Bgotoifnilelsepop: + CASE (Bgotoifnilelsepop): MAYBE_GC (); op = FETCH2; if (NILP (TOP)) @@ -731,9 +987,9 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + NEXT; - case Bgotoifnonnilelsepop: + CASE (Bgotoifnonnilelsepop): MAYBE_GC (); op = FETCH2; if (!NILP (TOP)) @@ -743,15 +999,15 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc = stack.byte_string_start + op; } else DISCARD (1); - break; + NEXT; - case BRgoto: + CASE (BRgoto): MAYBE_GC (); BYTE_CODE_QUIT; stack.pc += (int) *stack.pc - 127; - break; + NEXT; - case BRgotoifnil: + CASE (BRgotoifnil): { Lisp_Object v1; MAYBE_GC (); @@ -762,10 +1018,10 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + NEXT; } - case BRgotoifnonnil: + CASE (BRgotoifnonnil): { Lisp_Object v1; MAYBE_GC (); @@ -776,10 +1032,10 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += (int) *stack.pc - 128; } stack.pc++; - break; + NEXT; } - case BRgotoifnilelsepop: + CASE (BRgotoifnilelsepop): MAYBE_GC (); op = *stack.pc++; if (NILP (TOP)) @@ -788,9 +1044,9 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += op - 128; } else DISCARD (1); - break; + NEXT; - case BRgotoifnonnilelsepop: + CASE (BRgotoifnonnilelsepop): MAYBE_GC (); op = *stack.pc++; if (!NILP (TOP)) @@ -799,56 +1055,56 @@ If the third argument is incorrect, Emacs may crash. */) stack.pc += op - 128; } else DISCARD (1); - break; + NEXT; - case Breturn: + CASE (Breturn): result = POP; goto exit; - case Bdiscard: + CASE (Bdiscard): DISCARD (1); - break; + NEXT; - case Bconstant2: + CASE (Bconstant2): PUSH (vectorp[FETCH2]); - break; + NEXT; - case Bsave_excursion: + CASE (Bsave_excursion): record_unwind_protect (save_excursion_restore, save_excursion_save ()); - break; + NEXT; - case Bsave_current_buffer: - case Bsave_current_buffer_1: + CASE (Bsave_current_buffer): + CASE (Bsave_current_buffer_1): record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ()); - break; + NEXT; - case Bsave_window_excursion: + CASE (Bsave_window_excursion): BEFORE_POTENTIAL_GC (); TOP = Fsave_window_excursion (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsave_restriction: + CASE (Bsave_restriction): record_unwind_protect (save_restriction_restore, save_restriction_save ()); - break; + NEXT; - case Bcatch: + CASE (Bcatch): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = internal_catch (TOP, Feval, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bunwind_protect: + CASE (Bunwind_protect): record_unwind_protect (Fprogn, POP); - break; + NEXT; - case Bcondition_case: + CASE (Bcondition_case): { Lisp_Object handlers, body; handlers = POP; @@ -856,18 +1112,18 @@ If the third argument is incorrect, Emacs may crash. */) BEFORE_POTENTIAL_GC (); TOP = internal_lisp_condition_case (TOP, body, handlers); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Btemp_output_buffer_setup: + CASE (Btemp_output_buffer_setup): BEFORE_POTENTIAL_GC (); CHECK_STRING (TOP); temp_output_buffer_setup (SDATA (TOP)); AFTER_POTENTIAL_GC (); TOP = Vstandard_output; - break; + NEXT; - case Btemp_output_buffer_show: + CASE (Btemp_output_buffer_show): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); @@ -877,10 +1133,10 @@ If the third argument is incorrect, Emacs may crash. */) /* pop binding of standard-output */ unbind_to (SPECPDL_INDEX () - 1, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnth: + CASE (Bnth): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -894,173 +1150,173 @@ If the third argument is incorrect, Emacs may crash. */) v1 = XCDR (v1); immediate_quit = 0; TOP = CAR (v1); - break; + NEXT; } - case Bsymbolp: + CASE (Bsymbolp): TOP = SYMBOLP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bconsp: + CASE (Bconsp): TOP = CONSP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bstringp: + CASE (Bstringp): TOP = STRINGP (TOP) ? Qt : Qnil; - break; + NEXT; - case Blistp: + CASE (Blistp): TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bnot: + CASE (Bnot): TOP = NILP (TOP) ? Qt : Qnil; - break; + NEXT; - case Bcons: + CASE (Bcons): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, v1); - break; + NEXT; } - case Blist1: + CASE (Blist1): TOP = Fcons (TOP, Qnil); - break; + NEXT; - case Blist2: + CASE (Blist2): { Lisp_Object v1; v1 = POP; TOP = Fcons (TOP, Fcons (v1, Qnil)); - break; + NEXT; } - case Blist3: + CASE (Blist3): DISCARD (2); TOP = Flist (3, &TOP); - break; + NEXT; - case Blist4: + CASE (Blist4): DISCARD (3); TOP = Flist (4, &TOP); - break; + NEXT; - case BlistN: + CASE (BlistN): op = FETCH; DISCARD (op - 1); TOP = Flist (op, &TOP); - break; + NEXT; - case Blength: + CASE (Blength): BEFORE_POTENTIAL_GC (); TOP = Flength (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Baref: + CASE (Baref): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Faref (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Baset: + CASE (Baset): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Faset (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsymbol_value: + CASE (Bsymbol_value): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_value (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsymbol_function: + CASE (Bsymbol_function): BEFORE_POTENTIAL_GC (); TOP = Fsymbol_function (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bset: + CASE (Bset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bfset: + CASE (Bfset): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Ffset (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bget: + CASE (Bget): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fget (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsubstring: + CASE (Bsubstring): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); v2 = POP; v1 = POP; TOP = Fsubstring (TOP, v1, v2); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bconcat2: + CASE (Bconcat2): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fconcat (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bconcat3: + CASE (Bconcat3): BEFORE_POTENTIAL_GC (); DISCARD (2); TOP = Fconcat (3, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bconcat4: + CASE (Bconcat4): BEFORE_POTENTIAL_GC (); DISCARD (3); TOP = Fconcat (4, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case BconcatN: + CASE (BconcatN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Fconcat (op, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsub1: + CASE (Bsub1): { Lisp_Object v1; v1 = TOP; @@ -1075,10 +1331,10 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fsub1 (v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Badd1: + CASE (Badd1): { Lisp_Object v1; v1 = TOP; @@ -1093,10 +1349,10 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fadd1 (v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Beqlsign: + CASE (Beqlsign): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1114,57 +1370,57 @@ If the third argument is incorrect, Emacs may crash. */) } else TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil); - break; + NEXT; } - case Bgtr: + CASE (Bgtr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgtr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Blss: + CASE (Blss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Flss (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bleq: + CASE (Bleq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fleq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bgeq: + CASE (Bgeq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fgeq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bdiff: + CASE (Bdiff): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fminus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bnegate: + CASE (Bnegate): { Lisp_Object v1; v1 = TOP; @@ -1179,209 +1435,209 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Fminus (1, &TOP); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Bplus: + CASE (Bplus): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fplus (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmax: + CASE (Bmax): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmax (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmin: + CASE (Bmin): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fmin (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmult: + CASE (Bmult): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Ftimes (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bquo: + CASE (Bquo): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fquo (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Brem: + CASE (Brem): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Frem (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bpoint: + CASE (Bpoint): { Lisp_Object v1; XSETFASTINT (v1, PT); PUSH (v1); - break; + NEXT; } - case Bgoto_char: + CASE (Bgoto_char): BEFORE_POTENTIAL_GC (); TOP = Fgoto_char (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Binsert: + CASE (Binsert): BEFORE_POTENTIAL_GC (); TOP = Finsert (1, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case BinsertN: + CASE (BinsertN): op = FETCH; BEFORE_POTENTIAL_GC (); DISCARD (op - 1); TOP = Finsert (op, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bpoint_max: + CASE (Bpoint_max): { Lisp_Object v1; XSETFASTINT (v1, ZV); PUSH (v1); - break; + NEXT; } - case Bpoint_min: + CASE (Bpoint_min): { Lisp_Object v1; XSETFASTINT (v1, BEGV); PUSH (v1); - break; + NEXT; } - case Bchar_after: + CASE (Bchar_after): BEFORE_POTENTIAL_GC (); TOP = Fchar_after (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bfollowing_char: + CASE (Bfollowing_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Ffollowing_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bpreceding_char: + CASE (Bpreceding_char): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = Fprevious_char (); AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bcurrent_column: + CASE (Bcurrent_column): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); XSETFASTINT (v1, (int) current_column ()); /* iftc */ AFTER_POTENTIAL_GC (); PUSH (v1); - break; + NEXT; } - case Bindent_to: + CASE (Bindent_to): BEFORE_POTENTIAL_GC (); TOP = Findent_to (TOP, Qnil); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Beolp: + CASE (Beolp): PUSH (Feolp ()); - break; + NEXT; - case Beobp: + CASE (Beobp): PUSH (Feobp ()); - break; + NEXT; - case Bbolp: + CASE (Bbolp): PUSH (Fbolp ()); - break; + NEXT; - case Bbobp: + CASE (Bbobp): PUSH (Fbobp ()); - break; + NEXT; - case Bcurrent_buffer: + CASE (Bcurrent_buffer): PUSH (Fcurrent_buffer ()); - break; + NEXT; - case Bset_buffer: + CASE (Bset_buffer): BEFORE_POTENTIAL_GC (); TOP = Fset_buffer (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Binteractive_p: + CASE (Binteractive_p): PUSH (Finteractive_p ()); - break; + NEXT; - case Bforward_char: + CASE (Bforward_char): BEFORE_POTENTIAL_GC (); TOP = Fforward_char (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bforward_word: + CASE (Bforward_word): BEFORE_POTENTIAL_GC (); TOP = Fforward_word (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bskip_chars_forward: + CASE (Bskip_chars_forward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_forward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bskip_chars_backward: + CASE (Bskip_chars_backward): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fskip_chars_backward (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bforward_line: + CASE (Bforward_line): BEFORE_POTENTIAL_GC (); TOP = Fforward_line (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bchar_syntax: + CASE (Bchar_syntax): { int c; @@ -1393,51 +1649,51 @@ If the third argument is incorrect, Emacs may crash. */) MAKE_CHAR_MULTIBYTE (c); XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]); } - break; + NEXT; - case Bbuffer_substring: + CASE (Bbuffer_substring): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fbuffer_substring (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bdelete_region: + CASE (Bdelete_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fdelete_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnarrow_to_region: + CASE (Bnarrow_to_region): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnarrow_to_region (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bwiden: + CASE (Bwiden): BEFORE_POTENTIAL_GC (); PUSH (Fwiden ()); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bend_of_line: + CASE (Bend_of_line): BEFORE_POTENTIAL_GC (); TOP = Fend_of_line (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bset_marker: + CASE (Bset_marker): { Lisp_Object v1, v2; BEFORE_POTENTIAL_GC (); @@ -1445,72 +1701,72 @@ If the third argument is incorrect, Emacs may crash. */) v2 = POP; TOP = Fset_marker (TOP, v2, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bmatch_beginning: + CASE (Bmatch_beginning): BEFORE_POTENTIAL_GC (); TOP = Fmatch_beginning (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bmatch_end: + CASE (Bmatch_end): BEFORE_POTENTIAL_GC (); TOP = Fmatch_end (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bupcase: + CASE (Bupcase): BEFORE_POTENTIAL_GC (); TOP = Fupcase (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bdowncase: + CASE (Bdowncase): BEFORE_POTENTIAL_GC (); TOP = Fdowncase (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bstringeqlsign: + CASE (Bstringeqlsign): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_equal (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bstringlss: + CASE (Bstringlss): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fstring_lessp (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bequal: + CASE (Bequal): { Lisp_Object v1; v1 = POP; TOP = Fequal (TOP, v1); - break; + NEXT; } - case Bnthcdr: + CASE (Bnthcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fnthcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Belt: + CASE (Belt): { Lisp_Object v1, v2; if (CONSP (TOP)) @@ -1535,104 +1791,105 @@ If the third argument is incorrect, Emacs may crash. */) TOP = Felt (TOP, v1); AFTER_POTENTIAL_GC (); } - break; + NEXT; } - case Bmember: + CASE (Bmember): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fmember (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bassq: + CASE (Bassq): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fassq (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bnreverse: + CASE (Bnreverse): BEFORE_POTENTIAL_GC (); TOP = Fnreverse (TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bsetcar: + CASE (Bsetcar): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcar (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bsetcdr: + CASE (Bsetcdr): { Lisp_Object v1; BEFORE_POTENTIAL_GC (); v1 = POP; TOP = Fsetcdr (TOP, v1); AFTER_POTENTIAL_GC (); - break; + NEXT; } - case Bcar_safe: + CASE (Bcar_safe): { Lisp_Object v1; v1 = TOP; TOP = CAR_SAFE (v1); - break; + NEXT; } - case Bcdr_safe: + CASE (Bcdr_safe): { Lisp_Object v1; v1 = TOP; TOP = CDR_SAFE (v1); - break; + NEXT; } - case Bnconc: + CASE (Bnconc): BEFORE_POTENTIAL_GC (); DISCARD (1); TOP = Fnconc (2, &TOP); AFTER_POTENTIAL_GC (); - break; + NEXT; - case Bnumberp: + CASE (Bnumberp): TOP = (NUMBERP (TOP) ? Qt : Qnil); - break; + NEXT; - case Bintegerp: + CASE (Bintegerp): TOP = INTEGERP (TOP) ? Qt : Qnil; - break; + NEXT; #ifdef BYTE_CODE_SAFE - case Bset_mark: + CASE (Bset_mark): BEFORE_POTENTIAL_GC (); error ("set-mark is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; - case Bscan_buffer: + NEXT; + CASE (Bscan_buffer): BEFORE_POTENTIAL_GC (); error ("scan-buffer is an obsolete bytecode"); AFTER_POTENTIAL_GC (); - break; -#endif - - case 0: + NEXT; +#else + CASE (Bset_mark): + CASE (Bscan_buffer): abort (); +#endif - case 255: - default: + CASE_DEFAULT + CASE (Bconstant): #ifdef BYTE_CODE_SAFE if (op < Bconstant) { @@ -1646,6 +1903,10 @@ If the third argument is incorrect, Emacs may crash. */) #else PUSH (vectorp[op - Bconstant]); #endif + NEXT; + + CASE_ABORT: + abort (); } } From debbugs-submit-bounces@debbugs.gnu.org Tue Jan 19 20:40:54 2010 Received: (at control) by debbugs.gnu.org; 20 Jan 2010 01:40:54 +0000 Received: from localhost ([127.0.0.1] helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1NXPYz-0007Wd-5s for submit@debbugs.gnu.org; Tue, 19 Jan 2010 20:40:53 -0500 Received: from fencepost.gnu.org ([140.186.70.10]) by debbugs.gnu.org with esmtp (Exim 4.69) (envelope-from ) id 1NXPYl-0007WW-Uj for control@debbugs.gnu.org; Tue, 19 Jan 2010 20:40:52 -0500 Received: from rgm by fencepost.gnu.org with local (Exim 4.69) (envelope-from ) id 1NXPYi-0007Sl-Bs; Tue, 19 Jan 2010 20:40:36 -0500 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-ID: <19286.24340.350706.582414@gargle.gargle.HOWL> Date: Tue, 19 Jan 2010 20:40:36 -0500 From: Glenn Morris To: control Subject: control X-Attribution: GM X-Mailer: VM (www.wonderworks.com/vm), GNU Emacs (www.gnu.org/software/emacs) X-Hue: cyan X-Ran: 8WU:4P)DBN*0i&7=5k?sw9O_ List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -5.0 (-----) close 2951 tags 4206 moreinfo tags 3098 patch tags 2499 patch tags 5297 patch tags 5290 patch tags 1975 patch tags 4470 patch tags 5055 patch tags 3541 patch tags 2527 patch tags 5119 patch tags 2404 patch From debbugs-submit-bounces@debbugs.gnu.org Thu Aug 09 16:16:16 2012 Received: (at 4470-done) by debbugs.gnu.org; 9 Aug 2012 20:16:16 +0000 Received: from localhost ([127.0.0.1]:45264 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SzZ9T-00033l-OZ for submit@debbugs.gnu.org; Thu, 09 Aug 2012 16:16:16 -0400 Received: from fencepost.gnu.org ([208.118.235.10]:47883) by debbugs.gnu.org with esmtp (Exim 4.72) (envelope-from ) id 1SzZ9R-00033e-4G for 4470-done@debbugs.gnu.org; Thu, 09 Aug 2012 16:16:13 -0400 Received: from rgm by fencepost.gnu.org with local (Exim 4.71) (envelope-from ) id 1SzZ1U-00031R-0Q; Thu, 09 Aug 2012 16:08:00 -0400 From: Glenn Morris To: 4470-done@debbugs.gnu.org Subject: Re: bug#4470: 23.1; threaded interpreter References: X-Spook: Jyllandsposten Firewalls Dateline SWAT Putin Montenegro X-Ran: Ba?5*_UH&4T7SP06HeC&b (Tom Tromey's message of "Fri, 18 Sep 2009 13:00:28 -0600") Message-ID: User-Agent: Gnus (www.gnus.org), GNU Emacs (www.gnu.org/software/emacs/) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-Spam-Score: -6.9 (------) X-Debbugs-Envelope-To: 4470-done X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: debbugs-submit-bounces@debbugs.gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org X-Spam-Score: -6.9 (------) Not much point keeping this open as a bug report AFAICS. Newer version here: http://lists.gnu.org/archive/html/emacs-devel/2012-08/msg00313.html From unknown Wed Jun 18 23:17:52 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Fri, 07 Sep 2012 11:24:03 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator