src/bytecode.c

   1 /* Execution of byte code produced by bytecomp.el.
   2    Copyright (C) 1985-1988, 1993, 2000-2014 Free Software Foundation,
   3    Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /*
  21 hacked on by jwz@lucid.com 17-jun-91
  22   o  added a compile-time switch to turn on simple sanity checking;
  23   o  put back the obsolete byte-codes for error-detection;
  24   o  added a new instruction, unbind_all, which I will use for
  25      tail-recursion elimination;
  26   o  made temp_output_buffer_show be called with the right number
  27      of args;
  28   o  made the new bytecodes be called with args in the right order;
  29   o  added metering support.
  30
  31 by Hallvard:
  32   o  added relative jump instructions;
  33   o  all conditionals now only do QUIT if they jump.
  34  */
  35
  36 #include <config.h>
  37
  38 #include "lisp.h"
  39 #include "character.h"
  40 #include "buffer.h"
  41 #include "syntax.h"
  42 #include "window.h"
  43
  44 #ifdef CHECK_FRAME_FONT
  45 #include "frame.h"
  46 #include "xterm.h"
  47 #endif
  48
  49 /*
  50  * define BYTE_CODE_SAFE to enable some minor sanity checking (useful for
  51  * debugging the byte compiler...)
  52  *
  53  * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
  54  */
  55 /* #define BYTE_CODE_SAFE */
  56 /* #define BYTE_CODE_METER */
  57
  58 /* If BYTE_CODE_THREADED is defined, then the interpreter will be
  59    indirect threaded, using GCC's computed goto extension.  This code,
  60    as currently implemented, is incompatible with BYTE_CODE_SAFE and
  61    BYTE_CODE_METER.  */
  62 #if (defined __GNUC__ && !defined __STRICT_ANSI__ \
  63      && !defined BYTE_CODE_SAFE && !defined BYTE_CODE_METER)
  64 #define BYTE_CODE_THREADED
  65 #endif
  66
  67 \f
  68 #ifdef BYTE_CODE_METER
  69
  70 Lisp_Object Qbyte_code_meter;
  71 #define METER_2(code1, code2) AREF (AREF (Vbyte_code_meter, code1), code2)
  72 #define METER_1(code) METER_2 (0, code)
  73
  74 #define METER_CODE(last_code, this_code)                                \
  75 {                                                                       \
  76   if (byte_metering_on)                                                 \
  77     {                                                                   \
  78       if (XFASTINT (METER_1 (this_code)) < MOST_POSITIVE_FIXNUM)        \
  79         XSETFASTINT (METER_1 (this_code),                               \
  80                      XFASTINT (METER_1 (this_code)) + 1);               \
  81       if (last_code                                                     \
  82           && (XFASTINT (METER_2 (last_code, this_code))                 \
  83               < MOST_POSITIVE_FIXNUM))                                  \
  84         XSETFASTINT (METER_2 (last_code, this_code),                    \
  85                      XFASTINT (METER_2 (last_code, this_code)) + 1);    \
  86     }                                                                   \
  87 }
  88
  89 #endif /* BYTE_CODE_METER */
  90 \f
  91
  92 /*  Byte codes: */
  93
  94 #define BYTE_CODES                                                      \
  95 DEFINE (Bstack_ref, 0) /* Actually, Bstack_ref+0 is not implemented: use dup.  */ \
  96 DEFINE (Bstack_ref1, 1)                                                 \
  97 DEFINE (Bstack_ref2, 2)                                                 \
  98 DEFINE (Bstack_ref3, 3)                                                 \
  99 DEFINE (Bstack_ref4, 4)                                                 \
 100 DEFINE (Bstack_ref5, 5)                                                 \
 101 DEFINE (Bstack_ref6, 6)                                                 \
 102 DEFINE (Bstack_ref7, 7)                                                 \
 103 DEFINE (Bvarref, 010)                                                   \
 104 DEFINE (Bvarref1, 011)                                                  \
 105 DEFINE (Bvarref2, 012)                                                  \
 106 DEFINE (Bvarref3, 013)                                                  \
 107 DEFINE (Bvarref4, 014)                                                  \
 108 DEFINE (Bvarref5, 015)                                                  \
 109 DEFINE (Bvarref6, 016)                                                  \
 110 DEFINE (Bvarref7, 017)                                                  \
 111 DEFINE (Bvarset, 020)                                                   \
 112 DEFINE (Bvarset1, 021)                                                  \
 113 DEFINE (Bvarset2, 022)                                                  \
 114 DEFINE (Bvarset3, 023)                                                  \
 115 DEFINE (Bvarset4, 024)                                                  \
 116 DEFINE (Bvarset5, 025)                                                  \
 117 DEFINE (Bvarset6, 026)                                                  \
 118 DEFINE (Bvarset7, 027)                                                  \
 119 DEFINE (Bvarbind, 030)                                                  \
 120 DEFINE (Bvarbind1, 031)                                                 \
 121 DEFINE (Bvarbind2, 032)                                                 \
 122 DEFINE (Bvarbind3, 033)                                                 \
 123 DEFINE (Bvarbind4, 034)                                                 \
 124 DEFINE (Bvarbind5, 035)                                                 \
 125 DEFINE (Bvarbind6, 036)                                                 \
 126 DEFINE (Bvarbind7, 037)                                                 \
 127 DEFINE (Bcall, 040)                                                     \
 128 DEFINE (Bcall1, 041)                                                    \
 129 DEFINE (Bcall2, 042)                                                    \
 130 DEFINE (Bcall3, 043)                                                    \
 131 DEFINE (Bcall4, 044)                                                    \
 132 DEFINE (Bcall5, 045)                                                    \
 133 DEFINE (Bcall6, 046)                                                    \
 134 DEFINE (Bcall7, 047)                                                    \
 135 DEFINE (Bunbind, 050)                                                   \
 136 DEFINE (Bunbind1, 051)                                                  \
 137 DEFINE (Bunbind2, 052)                                                  \
 138 DEFINE (Bunbind3, 053)                                                  \
 139 DEFINE (Bunbind4, 054)                                                  \
 140 DEFINE (Bunbind5, 055)                                                  \
 141 DEFINE (Bunbind6, 056)                                                  \
 142 DEFINE (Bunbind7, 057)                                                  \
 143                                                                         \
 144 DEFINE (Bpophandler, 060)                                               \
 145 DEFINE (Bpushconditioncase, 061)                                        \
 146 DEFINE (Bpushcatch, 062)                                                \
 147                                                                         \
 148 DEFINE (Bnth, 070)                                                      \
 149 DEFINE (Bsymbolp, 071)                                                  \
 150 DEFINE (Bconsp, 072)                                                    \
 151 DEFINE (Bstringp, 073)                                                  \
 152 DEFINE (Blistp, 074)                                                    \
 153 DEFINE (Beq, 075)                                                       \
 154 DEFINE (Bmemq, 076)                                                     \
 155 DEFINE (Bnot, 077)                                                      \
 156 DEFINE (Bcar, 0100)                                                     \
 157 DEFINE (Bcdr, 0101)                                                     \
 158 DEFINE (Bcons, 0102)                                                    \
 159 DEFINE (Blist1, 0103)                                                   \
 160 DEFINE (Blist2, 0104)                                                   \
 161 DEFINE (Blist3, 0105)                                                   \
 162 DEFINE (Blist4, 0106)                                                   \
 163 DEFINE (Blength, 0107)                                                  \
 164 DEFINE (Baref, 0110)                                                    \
 165 DEFINE (Baset, 0111)                                                    \
 166 DEFINE (Bsymbol_value, 0112)                                            \
 167 DEFINE (Bsymbol_function, 0113)                                         \
 168 DEFINE (Bset, 0114)                                                     \
 169 DEFINE (Bfset, 0115)                                                    \
 170 DEFINE (Bget, 0116)                                                     \
 171 DEFINE (Bsubstring, 0117)                                               \
 172 DEFINE (Bconcat2, 0120)                                                 \
 173 DEFINE (Bconcat3, 0121)                                                 \
 174 DEFINE (Bconcat4, 0122)                                                 \
 175 DEFINE (Bsub1, 0123)                                                    \
 176 DEFINE (Badd1, 0124)                                                    \
 177 DEFINE (Beqlsign, 0125)                                                 \
 178 DEFINE (Bgtr, 0126)                                                     \
 179 DEFINE (Blss, 0127)                                                     \
 180 DEFINE (Bleq, 0130)                                                     \
 181 DEFINE (Bgeq, 0131)                                                     \
 182 DEFINE (Bdiff, 0132)                                                    \
 183 DEFINE (Bnegate, 0133)                                                  \
 184 DEFINE (Bplus, 0134)                                                    \
 185 DEFINE (Bmax, 0135)                                                     \
 186 DEFINE (Bmin, 0136)                                                     \
 187 DEFINE (Bmult, 0137)                                                    \
 188                                                                         \
 189 DEFINE (Bpoint, 0140)                                                   \
 190 /* Was Bmark in v17.  */                                                \
 191 DEFINE (Bsave_current_buffer, 0141) /* Obsolete.  */                    \
 192 DEFINE (Bgoto_char, 0142)                                               \
 193 DEFINE (Binsert, 0143)                                                  \
 194 DEFINE (Bpoint_max, 0144)                                               \
 195 DEFINE (Bpoint_min, 0145)                                               \
 196 DEFINE (Bchar_after, 0146)                                              \
 197 DEFINE (Bfollowing_char, 0147)                                          \
 198 DEFINE (Bpreceding_char, 0150)                                          \
 199 DEFINE (Bcurrent_column, 0151)                                          \
 200 DEFINE (Bindent_to, 0152)                                               \
 201 DEFINE (Beolp, 0154)                                                    \
 202 DEFINE (Beobp, 0155)                                                    \
 203 DEFINE (Bbolp, 0156)                                                    \
 204 DEFINE (Bbobp, 0157)                                                    \
 205 DEFINE (Bcurrent_buffer, 0160)                                          \
 206 DEFINE (Bset_buffer, 0161)                                              \
 207 DEFINE (Bsave_current_buffer_1, 0162) /* Replacing Bsave_current_buffer.  */ \
 208 DEFINE (Binteractive_p, 0164) /* Obsolete since Emacs-24.1.  */         \
 209                                                                         \
 210 DEFINE (Bforward_char, 0165)                                            \
 211 DEFINE (Bforward_word, 0166)                                            \
 212 DEFINE (Bskip_chars_forward, 0167)                                      \
 213 DEFINE (Bskip_chars_backward, 0170)                                     \
 214 DEFINE (Bforward_line, 0171)                                            \
 215 DEFINE (Bchar_syntax, 0172)                                             \
 216 DEFINE (Bbuffer_substring, 0173)                                        \
 217 DEFINE (Bdelete_region, 0174)                                           \
 218 DEFINE (Bnarrow_to_region, 0175)                                        \
 219 DEFINE (Bwiden, 0176)                                                   \
 220 DEFINE (Bend_of_line, 0177)                                             \
 221                                                                         \
 222 DEFINE (Bconstant2, 0201)                                               \
 223 DEFINE (Bgoto, 0202)                                                    \
 224 DEFINE (Bgotoifnil, 0203)                                               \
 225 DEFINE (Bgotoifnonnil, 0204)                                            \
 226 DEFINE (Bgotoifnilelsepop, 0205)                                        \
 227 DEFINE (Bgotoifnonnilelsepop, 0206)                                     \
 228 DEFINE (Breturn, 0207)                                                  \
 229 DEFINE (Bdiscard, 0210)                                                 \
 230 DEFINE (Bdup, 0211)                                                     \
 231                                                                         \
 232 DEFINE (Bsave_excursion, 0212)                                          \
 233 DEFINE (Bsave_window_excursion, 0213) /* Obsolete since Emacs-24.1.  */ \
 234 DEFINE (Bsave_restriction, 0214)                                        \
 235 DEFINE (Bcatch, 0215)                                                   \
 236                                                                         \
 237 DEFINE (Bunwind_protect, 0216)                                          \
 238 DEFINE (Bcondition_case, 0217)                                          \
 239 DEFINE (Btemp_output_buffer_setup, 0220) /* Obsolete since Emacs-24.1.  */ \
 240 DEFINE (Btemp_output_buffer_show, 0221)  /* Obsolete since Emacs-24.1.  */ \
 241                                                                         \
 242 DEFINE (Bunbind_all, 0222)      /* Obsolete.  Never used.  */           \
 243                                                                         \
 244 DEFINE (Bset_marker, 0223)                                              \
 245 DEFINE (Bmatch_beginning, 0224)                                         \
 246 DEFINE (Bmatch_end, 0225)                                               \
 247 DEFINE (Bupcase, 0226)                                                  \
 248 DEFINE (Bdowncase, 0227)                                                \
 249                                                                         \
 250 DEFINE (Bstringeqlsign, 0230)                                           \
 251 DEFINE (Bstringlss, 0231)                                               \
 252 DEFINE (Bequal, 0232)                                                   \
 253 DEFINE (Bnthcdr, 0233)                                                  \
 254 DEFINE (Belt, 0234)                                                     \
 255 DEFINE (Bmember, 0235)                                                  \
 256 DEFINE (Bassq, 0236)                                                    \
 257 DEFINE (Bnreverse, 0237)                                                \
 258 DEFINE (Bsetcar, 0240)                                                  \
 259 DEFINE (Bsetcdr, 0241)                                                  \
 260 DEFINE (Bcar_safe, 0242)                                                \
 261 DEFINE (Bcdr_safe, 0243)                                                \
 262 DEFINE (Bnconc, 0244)                                                   \
 263 DEFINE (Bquo, 0245)                                                     \
 264 DEFINE (Brem, 0246)                                                     \
 265 DEFINE (Bnumberp, 0247)                                                 \
 266 DEFINE (Bintegerp, 0250)                                                \
 267                                                                         \
 268 DEFINE (BRgoto, 0252)                                                   \
 269 DEFINE (BRgotoifnil, 0253)                                              \
 270 DEFINE (BRgotoifnonnil, 0254)                                           \
 271 DEFINE (BRgotoifnilelsepop, 0255)                                       \
 272 DEFINE (BRgotoifnonnilelsepop, 0256)                                    \
 273                                                                         \
 274 DEFINE (BlistN, 0257)                                                   \
 275 DEFINE (BconcatN, 0260)                                                 \
 276 DEFINE (BinsertN, 0261)                                                 \
 277                                                                         \
 278 /* Bstack_ref is code 0.  */                                            \
 279 DEFINE (Bstack_set,  0262)                                              \
 280 DEFINE (Bstack_set2, 0263)                                              \
 281 DEFINE (BdiscardN,   0266)                                              \
 282                                                                         \
 283 DEFINE (Bconstant, 0300)
 284
 285 enum byte_code_op
 286 {
 287 #define DEFINE(name, value) name = value,
 288     BYTE_CODES
 289 #undef DEFINE
 290
 291 #ifdef BYTE_CODE_SAFE
 292     Bscan_buffer = 0153, /* No longer generated as of v18.  */
 293     Bset_mark = 0163, /* this loser is no longer generated as of v18 */
 294 #endif
 295
 296     B__dummy__ = 0  /* Pacify C89.  */
 297 };
 298
 299 /* Whether to maintain a `top' and `bottom' field in the stack frame.  */
 300 #define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK)
 301 \f
 302 /* Structure describing a value stack used during byte-code execution
 303    in Fbyte_code.  */
 304
 305 struct byte_stack
 306 {
 307   /* Program counter.  This points into the byte_string below
 308      and is relocated when that string is relocated.  */
 309   const unsigned char *pc;
 310
 311   /* Top and bottom of stack.  The bottom points to an area of memory
 312      allocated with alloca in Fbyte_code.  */
 313 #if BYTE_MAINTAIN_TOP
 314   Lisp_Object *top, *bottom;
 315 #endif
 316
 317   /* The string containing the byte-code, and its current address.
 318      Storing this here protects it from GC because mark_byte_stack
 319      marks it.  */
 320   Lisp_Object byte_string;
 321   const unsigned char *byte_string_start;
 322
 323 #if BYTE_MARK_STACK
 324   /* The vector of constants used during byte-code execution.  Storing
 325      this here protects it from GC because mark_byte_stack marks it.  */
 326   Lisp_Object constants;
 327 #endif
 328
 329   /* Next entry in byte_stack_list.  */
 330   struct byte_stack *next;
 331 };
 332
 333 /* A list of currently active byte-code execution value stacks.
 334    Fbyte_code adds an entry to the head of this list before it starts
 335    processing byte-code, and it removes the entry again when it is
 336    done.  Signaling an error truncates the list analogous to
 337    gcprolist.  */
 338
 339 struct byte_stack *byte_stack_list;
 340
 341 \f
 342 /* Mark objects on byte_stack_list.  Called during GC.  */
 343
 344 #if BYTE_MARK_STACK
 345 void
 346 mark_byte_stack (void)
 347 {
 348   struct byte_stack *stack;
 349   Lisp_Object *obj;
 350
 351   for (stack = byte_stack_list; stack; stack = stack->next)
 352     {
 353       /* If STACK->top is null here, this means there's an opcode in
 354          Fbyte_code that wasn't expected to GC, but did.  To find out
 355          which opcode this is, record the value of `stack', and walk
 356          up the stack in a debugger, stopping in frames of Fbyte_code.
 357          The culprit is found in the frame of Fbyte_code where the
 358          address of its local variable `stack' is equal to the
 359          recorded value of `stack' here.  */
 360       eassert (stack->top);
 361
 362       for (obj = stack->bottom; obj <= stack->top; ++obj)
 363         mark_object (*obj);
 364
 365       mark_object (stack->byte_string);
 366       mark_object (stack->constants);
 367     }
 368 }
 369 #endif
 370
 371 /* Unmark objects in the stacks on byte_stack_list.  Relocate program
 372    counters.  Called when GC has completed.  */
 373
 374 void
 375 unmark_byte_stack (void)
 376 {
 377   struct byte_stack *stack;
 378
 379   for (stack = byte_stack_list; stack; stack = stack->next)
 380     {
 381       if (stack->byte_string_start != SDATA (stack->byte_string))
 382         {
 383           ptrdiff_t offset = stack->pc - stack->byte_string_start;
 384           stack->byte_string_start = SDATA (stack->byte_string);
 385           stack->pc = stack->byte_string_start + offset;
 386         }
 387     }
 388 }
 389
 390 \f
 391 /* Fetch the next byte from the bytecode stream.  */
 392
 393 #define FETCH *stack.pc++
 394
 395 /* Fetch two bytes from the bytecode stream and make a 16-bit number
 396    out of them.  */
 397
 398 #define FETCH2 (op = FETCH, op + (FETCH << 8))
 399
 400 /* Push x onto the execution stack.  This used to be #define PUSH(x)
 401    (*++stackp = (x)) This oddity is necessary because Alliant can't be
 402    bothered to compile the preincrement operator properly, as of 4/91.
 403    -JimB */
 404
 405 #define PUSH(x) (top++, *top = (x))
 406
 407 /* Pop a value off the execution stack.  */
 408
 409 #define POP (*top--)
 410
 411 /* Discard n values from the execution stack.  */
 412
 413 #define DISCARD(n) (top -= (n))
 414
 415 /* Get the value which is at the top of the execution stack, but don't
 416    pop it.  */
 417
 418 #define TOP (*top)
 419
 420 /* Actions that must be performed before and after calling a function
 421    that might GC.  */
 422
 423 #if !BYTE_MAINTAIN_TOP
 424 #define BEFORE_POTENTIAL_GC()   ((void)0)
 425 #define AFTER_POTENTIAL_GC()    ((void)0)
 426 #else
 427 #define BEFORE_POTENTIAL_GC()   stack.top = top
 428 #define AFTER_POTENTIAL_GC()    stack.top = NULL
 429 #endif
 430
 431 /* Garbage collect if we have consed enough since the last time.
 432    We do this at every branch, to avoid loops that never GC.  */
 433
 434 #define MAYBE_GC()              \
 435   do {                          \
 436    BEFORE_POTENTIAL_GC ();      \
 437    maybe_gc ();                 \
 438    AFTER_POTENTIAL_GC ();       \
 439  } while (0)
 440
 441 /* Check for jumping out of range.  */
 442
 443 #ifdef BYTE_CODE_SAFE
 444
 445 #define CHECK_RANGE(ARG) \
 446   if (ARG >= bytestr_length) emacs_abort ()
 447
 448 #else /* not BYTE_CODE_SAFE */
 449
 450 #define CHECK_RANGE(ARG)
 451
 452 #endif /* not BYTE_CODE_SAFE */
 453
 454 /* A version of the QUIT macro which makes sure that the stack top is
 455    set before signaling `quit'.  */
 456
 457 #define BYTE_CODE_QUIT                                  \
 458   do {                                                  \
 459     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
 460       {                                                 \
 461         Lisp_Object flag = Vquit_flag;                  \
 462         Vquit_flag = Qnil;                              \
 463         BEFORE_POTENTIAL_GC ();                         \
 464         if (EQ (Vthrow_on_input, flag))                 \
 465           Fthrow (Vthrow_on_input, Qt);                 \
 466         Fsignal (Qquit, Qnil);                          \
 467         AFTER_POTENTIAL_GC ();                          \
 468       }                                                 \
 469     else if (pending_signals)                           \
 470       process_pending_signals ();                       \
 471   } while (0)
 472
 473
 474 DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
 475        doc: /* Function used internally in byte-compiled code.
 476 The first argument, BYTESTR, is a string of byte code;
 477 the second, VECTOR, a vector of constants;
 478 the third, MAXDEPTH, the maximum stack depth used in this function.
 479 If the third argument is incorrect, Emacs may crash.  */)
 480   (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth)
 481 {
 482   return exec_byte_code (bytestr, vector, maxdepth, Qnil, 0, NULL);
 483 }
 484
 485 static void
 486 bcall0 (Lisp_Object f)
 487 {
 488   Ffuncall (1, &f);
 489 }
 490
 491 /* Execute the byte-code in BYTESTR.  VECTOR is the constant vector, and
 492    MAXDEPTH is the maximum stack depth used (if MAXDEPTH is incorrect,
 493    emacs may crash!).  If ARGS_TEMPLATE is non-nil, it should be a lisp
 494    argument list (including &rest, &optional, etc.), and ARGS, of size
 495    NARGS, should be a vector of the actual arguments.  The arguments in
 496    ARGS are pushed on the stack according to ARGS_TEMPLATE before
 497    executing BYTESTR.  */
 498
 499 Lisp_Object
 500 exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 501                 Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args)
 502 {
 503   ptrdiff_t count = SPECPDL_INDEX ();
 504 #ifdef BYTE_CODE_METER
 505   int volatile this_op = 0;
 506   int prev_op;
 507 #endif
 508   int op;
 509   /* Lisp_Object v1, v2; */
 510   Lisp_Object *vectorp;
 511 #ifdef BYTE_CODE_SAFE
 512   ptrdiff_t const_length;
 513   Lisp_Object *stacke;
 514   ptrdiff_t bytestr_length;
 515 #endif
 516   struct byte_stack stack;
 517   Lisp_Object *top;
 518   Lisp_Object result;
 519   enum handlertype type;
 520
 521 #if 0 /* CHECK_FRAME_FONT */
 522  {
 523    struct frame *f = SELECTED_FRAME ();
 524    if (FRAME_X_P (f)
 525        && FRAME_FONT (f)->direction != 0
 526        && FRAME_FONT (f)->direction != 1)
 527      emacs_abort ();
 528  }
 529 #endif
 530
 531   CHECK_STRING (bytestr);
 532   CHECK_VECTOR (vector);
 533   CHECK_NATNUM (maxdepth);
 534
 535 #ifdef BYTE_CODE_SAFE
 536   const_length = ASIZE (vector);
 537 #endif
 538
 539   if (STRING_MULTIBYTE (bytestr))
 540     /* BYTESTR must have been produced by Emacs 20.2 or the earlier
 541        because they produced a raw 8-bit string for byte-code and now
 542        such a byte-code string is loaded as multibyte while raw 8-bit
 543        characters converted to multibyte form.  Thus, now we must
 544        convert them back to the originally intended unibyte form.  */
 545     bytestr = Fstring_as_unibyte (bytestr);
 546
 547 #ifdef BYTE_CODE_SAFE
 548   bytestr_length = SBYTES (bytestr);
 549 #endif
 550   vectorp = XVECTOR (vector)->contents;
 551
 552   stack.byte_string = bytestr;
 553   stack.pc = stack.byte_string_start = SDATA (bytestr);
 554 #if BYTE_MARK_STACK
 555   stack.constants = vector;
 556 #endif
 557   if (MAX_ALLOCA / word_size <= XFASTINT (maxdepth))
 558     memory_full (SIZE_MAX);
 559   top = alloca ((XFASTINT (maxdepth) + 1) * sizeof *top);
 560 #if BYTE_MAINTAIN_TOP
 561   stack.bottom = top + 1;
 562   stack.top = NULL;
 563 #endif
 564   stack.next = byte_stack_list;
 565   byte_stack_list = &stack;
 566
 567 #ifdef BYTE_CODE_SAFE
 568   stacke = stack.bottom - 1 + XFASTINT (maxdepth);
 569 #endif
 570
 571   if (INTEGERP (args_template))
 572     {
 573       ptrdiff_t at = XINT (args_template);
 574       bool rest = (at & 128) != 0;
 575       int mandatory = at & 127;
 576       ptrdiff_t nonrest = at >> 8;
 577       eassert (mandatory <= nonrest);
 578       if (nargs <= nonrest)
 579         {
 580           ptrdiff_t i;
 581           for (i = 0 ; i < nargs; i++, args++)
 582             PUSH (*args);
 583           if (nargs < mandatory)
 584             /* Too few arguments.  */
 585             Fsignal (Qwrong_number_of_arguments,
 586                      list2 (Fcons (make_number (mandatory),
 587                                    rest ? Qand_rest : make_number (nonrest)),
 588                             make_number (nargs)));
 589           else
 590             {
 591               for (; i < nonrest; i++)
 592                 PUSH (Qnil);
 593               if (rest)
 594                 PUSH (Qnil);
 595             }
 596         }
 597       else if (rest)
 598         {
 599           ptrdiff_t i;
 600           for (i = 0 ; i < nonrest; i++, args++)
 601             PUSH (*args);
 602           PUSH (Flist (nargs - nonrest, args));
 603         }
 604       else
 605         /* Too many arguments.  */
 606         Fsignal (Qwrong_number_of_arguments,
 607                  list2 (Fcons (make_number (mandatory), make_number (nonrest)),
 608                         make_number (nargs)));
 609     }
 610   else if (! NILP (args_template))
 611     /* We should push some arguments on the stack.  */
 612     {
 613       error ("Unknown args template!");
 614     }
 615
 616   while (1)
 617     {
 618 #ifdef BYTE_CODE_SAFE
 619       if (top > stacke)
 620         emacs_abort ();
 621       else if (top < stack.bottom - 1)
 622         emacs_abort ();
 623 #endif
 624
 625 #ifdef BYTE_CODE_METER
 626       prev_op = this_op;
 627       this_op = op = FETCH;
 628       METER_CODE (prev_op, op);
 629 #else
 630 #ifndef BYTE_CODE_THREADED
 631       op = FETCH;
 632 #endif
 633 #endif
 634
 635       /* The interpreter can be compiled one of two ways: as an
 636          ordinary switch-based interpreter, or as a threaded
 637          interpreter.  The threaded interpreter relies on GCC's
 638          computed goto extension, so it is not available everywhere.
 639          Threading provides a performance boost.  These macros are how
 640          we allow the code to be compiled both ways.  */
 641 #ifdef BYTE_CODE_THREADED
 642       /* The CASE macro introduces an instruction's body.  It is
 643          either a label or a case label.  */
 644 #define CASE(OP) insn_ ## OP
 645       /* NEXT is invoked at the end of an instruction to go to the
 646          next instruction.  It is either a computed goto, or a
 647          plain break.  */
 648 #define NEXT goto *(targets[op = FETCH])
 649       /* FIRST is like NEXT, but is only used at the start of the
 650          interpreter body.  In the switch-based interpreter it is the
 651          switch, so the threaded definition must include a semicolon.  */
 652 #define FIRST NEXT;
 653       /* Most cases are labeled with the CASE macro, above.
 654          CASE_DEFAULT is one exception; it is used if the interpreter
 655          being built requires a default case.  The threaded
 656          interpreter does not, because the dispatch table is
 657          completely filled.  */
 658 #define CASE_DEFAULT
 659       /* This introduces an instruction that is known to call abort.  */
 660 #define CASE_ABORT CASE (Bstack_ref): CASE (default)
 661 #else
 662       /* See above for the meaning of the various defines.  */
 663 #define CASE(OP) case OP
 664 #define NEXT break
 665 #define FIRST switch (op)
 666 #define CASE_DEFAULT case 255: default:
 667 #define CASE_ABORT case 0
 668 #endif
 669
 670 #ifdef BYTE_CODE_THREADED
 671
 672       /* A convenience define that saves us a lot of typing and makes
 673          the table clearer.  */
 674 #define LABEL(OP) [OP] = &&insn_ ## OP
 675
 676 #if 4 < __GNUC__ + (6 <= __GNUC_MINOR__)
 677 # pragma GCC diagnostic push
 678 # pragma GCC diagnostic ignored "-Woverride-init"
 679 #elif defined __clang__
 680 # pragma GCC diagnostic push
 681 # pragma GCC diagnostic ignored "-Winitializer-overrides"
 682 #endif
 683
 684       /* This is the dispatch table for the threaded interpreter.  */
 685       static const void *const targets[256] =
 686         {
 687           [0 ... (Bconstant - 1)] = &&insn_default,
 688           [Bconstant ... 255] = &&insn_Bconstant,
 689
 690 #define DEFINE(name, value) LABEL (name) ,
 691           BYTE_CODES
 692 #undef DEFINE
 693         };
 694
 695 #if 4 < __GNUC__ + (6 <= __GNUC_MINOR__) || defined __clang__
 696 # pragma GCC diagnostic pop
 697 #endif
 698
 699 #endif
 700
 701
 702       FIRST
 703         {
 704         CASE (Bvarref7):
 705           op = FETCH2;
 706           goto varref;
 707
 708         CASE (Bvarref):
 709         CASE (Bvarref1):
 710         CASE (Bvarref2):
 711         CASE (Bvarref3):
 712         CASE (Bvarref4):
 713         CASE (Bvarref5):
 714           op = op - Bvarref;
 715           goto varref;
 716
 717         /* This seems to be the most frequently executed byte-code
 718            among the Bvarref's, so avoid a goto here.  */
 719         CASE (Bvarref6):
 720           op = FETCH;
 721         varref:
 722           {
 723             Lisp_Object v1, v2;
 724
 725             v1 = vectorp[op];
 726             if (SYMBOLP (v1))
 727               {
 728                 if (XSYMBOL (v1)->redirect != SYMBOL_PLAINVAL
 729                     || (v2 = SYMBOL_VAL (XSYMBOL (v1)),
 730                         EQ (v2, Qunbound)))
 731                   {
 732                     BEFORE_POTENTIAL_GC ();
 733                     v2 = Fsymbol_value (v1);
 734                     AFTER_POTENTIAL_GC ();
 735                   }
 736               }
 737             else
 738               {
 739                 BEFORE_POTENTIAL_GC ();
 740                 v2 = Fsymbol_value (v1);
 741                 AFTER_POTENTIAL_GC ();
 742               }
 743             PUSH (v2);
 744             NEXT;
 745           }
 746
 747         CASE (Bgotoifnil):
 748           {
 749             Lisp_Object v1;
 750             MAYBE_GC ();
 751             op = FETCH2;
 752             v1 = POP;
 753             if (NILP (v1))
 754               {
 755                 BYTE_CODE_QUIT;
 756                 CHECK_RANGE (op);
 757                 stack.pc = stack.byte_string_start + op;
 758               }
 759             NEXT;
 760           }
 761
 762         CASE (Bcar):
 763           {
 764             Lisp_Object v1;
 765             v1 = TOP;
 766             if (CONSP (v1))
 767               TOP = XCAR (v1);
 768             else if (NILP (v1))
 769               TOP = Qnil;
 770             else
 771               {
 772                 BEFORE_POTENTIAL_GC ();
 773                 wrong_type_argument (Qlistp, v1);
 774               }
 775             NEXT;
 776           }
 777
 778         CASE (Beq):
 779           {
 780             Lisp_Object v1;
 781             v1 = POP;
 782             TOP = EQ (v1, TOP) ? Qt : Qnil;
 783             NEXT;
 784           }
 785
 786         CASE (Bmemq):
 787           {
 788             Lisp_Object v1;
 789             BEFORE_POTENTIAL_GC ();
 790             v1 = POP;
 791             TOP = Fmemq (TOP, v1);
 792             AFTER_POTENTIAL_GC ();
 793             NEXT;
 794           }
 795
 796         CASE (Bcdr):
 797           {
 798             Lisp_Object v1;
 799             v1 = TOP;
 800             if (CONSP (v1))
 801               TOP = XCDR (v1);
 802             else if (NILP (v1))
 803               TOP = Qnil;
 804             else
 805               {
 806                 BEFORE_POTENTIAL_GC ();
 807                 wrong_type_argument (Qlistp, v1);
 808               }
 809             NEXT;
 810           }
 811
 812         CASE (Bvarset):
 813         CASE (Bvarset1):
 814         CASE (Bvarset2):
 815         CASE (Bvarset3):
 816         CASE (Bvarset4):
 817         CASE (Bvarset5):
 818           op -= Bvarset;
 819           goto varset;
 820
 821         CASE (Bvarset7):
 822           op = FETCH2;
 823           goto varset;
 824
 825         CASE (Bvarset6):
 826           op = FETCH;
 827         varset:
 828           {
 829             Lisp_Object sym, val;
 830
 831             sym = vectorp[op];
 832             val = TOP;
 833
 834             /* Inline the most common case.  */
 835             if (SYMBOLP (sym)
 836                 && !EQ (val, Qunbound)
 837                 && !XSYMBOL (sym)->redirect
 838                 && !SYMBOL_CONSTANT_P (sym))
 839               SET_SYMBOL_VAL (XSYMBOL (sym), val);
 840             else
 841               {
 842                 BEFORE_POTENTIAL_GC ();
 843                 set_internal (sym, val, Qnil, 0);
 844                 AFTER_POTENTIAL_GC ();
 845               }
 846           }
 847           (void) POP;
 848           NEXT;
 849
 850         CASE (Bdup):
 851           {
 852             Lisp_Object v1;
 853             v1 = TOP;
 854             PUSH (v1);
 855             NEXT;
 856           }
 857
 858         /* ------------------ */
 859
 860         CASE (Bvarbind6):
 861           op = FETCH;
 862           goto varbind;
 863
 864         CASE (Bvarbind7):
 865           op = FETCH2;
 866           goto varbind;
 867
 868         CASE (Bvarbind):
 869         CASE (Bvarbind1):
 870         CASE (Bvarbind2):
 871         CASE (Bvarbind3):
 872         CASE (Bvarbind4):
 873         CASE (Bvarbind5):
 874           op -= Bvarbind;
 875         varbind:
 876           /* Specbind can signal and thus GC.  */
 877           BEFORE_POTENTIAL_GC ();
 878           specbind (vectorp[op], POP);
 879           AFTER_POTENTIAL_GC ();
 880           NEXT;
 881
 882         CASE (Bcall6):
 883           op = FETCH;
 884           goto docall;
 885
 886         CASE (Bcall7):
 887           op = FETCH2;
 888           goto docall;
 889
 890         CASE (Bcall):
 891         CASE (Bcall1):
 892         CASE (Bcall2):
 893         CASE (Bcall3):
 894         CASE (Bcall4):
 895         CASE (Bcall5):
 896           op -= Bcall;
 897         docall:
 898           {
 899             BEFORE_POTENTIAL_GC ();
 900             DISCARD (op);
 901 #ifdef BYTE_CODE_METER
 902             if (byte_metering_on && SYMBOLP (TOP))
 903               {
 904                 Lisp_Object v1, v2;
 905
 906                 v1 = TOP;
 907                 v2 = Fget (v1, Qbyte_code_meter);
 908                 if (INTEGERP (v2)
 909                     && XINT (v2) < MOST_POSITIVE_FIXNUM)
 910                   {
 911                     XSETINT (v2, XINT (v2) + 1);
 912                     Fput (v1, Qbyte_code_meter, v2);
 913                   }
 914               }
 915 #endif
 916             TOP = Ffuncall (op + 1, &TOP);
 917             AFTER_POTENTIAL_GC ();
 918             NEXT;
 919           }
 920
 921         CASE (Bunbind6):
 922           op = FETCH;
 923           goto dounbind;
 924
 925         CASE (Bunbind7):
 926           op = FETCH2;
 927           goto dounbind;
 928
 929         CASE (Bunbind):
 930         CASE (Bunbind1):
 931         CASE (Bunbind2):
 932         CASE (Bunbind3):
 933         CASE (Bunbind4):
 934         CASE (Bunbind5):
 935           op -= Bunbind;
 936         dounbind:
 937           BEFORE_POTENTIAL_GC ();
 938           unbind_to (SPECPDL_INDEX () - op, Qnil);
 939           AFTER_POTENTIAL_GC ();
 940           NEXT;
 941
 942         CASE (Bunbind_all):     /* Obsolete.  Never used.  */
 943           /* To unbind back to the beginning of this frame.  Not used yet,
 944              but will be needed for tail-recursion elimination.  */
 945           BEFORE_POTENTIAL_GC ();
 946           unbind_to (count, Qnil);
 947           AFTER_POTENTIAL_GC ();
 948           NEXT;
 949
 950         CASE (Bgoto):
 951           MAYBE_GC ();
 952           BYTE_CODE_QUIT;
 953           op = FETCH2;    /* pc = FETCH2 loses since FETCH2 contains pc++ */
 954           CHECK_RANGE (op);
 955           stack.pc = stack.byte_string_start + op;
 956           NEXT;
 957
 958         CASE (Bgotoifnonnil):
 959           {
 960             Lisp_Object v1;
 961             MAYBE_GC ();
 962             op = FETCH2;
 963             v1 = POP;
 964             if (!NILP (v1))
 965               {
 966                 BYTE_CODE_QUIT;
 967                 CHECK_RANGE (op);
 968                 stack.pc = stack.byte_string_start + op;
 969               }
 970             NEXT;
 971           }
 972
 973         CASE (Bgotoifnilelsepop):
 974           MAYBE_GC ();
 975           op = FETCH2;
 976           if (NILP (TOP))
 977             {
 978               BYTE_CODE_QUIT;
 979               CHECK_RANGE (op);
 980               stack.pc = stack.byte_string_start + op;
 981             }
 982           else DISCARD (1);
 983           NEXT;
 984
 985         CASE (Bgotoifnonnilelsepop):
 986           MAYBE_GC ();
 987           op = FETCH2;
 988           if (!NILP (TOP))
 989             {
 990               BYTE_CODE_QUIT;
 991               CHECK_RANGE (op);
 992               stack.pc = stack.byte_string_start + op;
 993             }
 994           else DISCARD (1);
 995           NEXT;
 996
 997         CASE (BRgoto):
 998           MAYBE_GC ();
 999           BYTE_CODE_QUIT;
1000           stack.pc += (int) *stack.pc - 127;
1001           NEXT;
1002
1003         CASE (BRgotoifnil):
1004           {
1005             Lisp_Object v1;
1006             MAYBE_GC ();
1007             v1 = POP;
1008             if (NILP (v1))
1009               {
1010                 BYTE_CODE_QUIT;
1011                 stack.pc += (int) *stack.pc - 128;
1012               }
1013             stack.pc++;
1014             NEXT;
1015           }
1016
1017         CASE (BRgotoifnonnil):
1018           {
1019             Lisp_Object v1;
1020             MAYBE_GC ();
1021             v1 = POP;
1022             if (!NILP (v1))
1023               {
1024                 BYTE_CODE_QUIT;
1025                 stack.pc += (int) *stack.pc - 128;
1026               }
1027             stack.pc++;
1028             NEXT;
1029           }
1030
1031         CASE (BRgotoifnilelsepop):
1032           MAYBE_GC ();
1033           op = *stack.pc++;
1034           if (NILP (TOP))
1035             {
1036               BYTE_CODE_QUIT;
1037               stack.pc += op - 128;
1038             }
1039           else DISCARD (1);
1040           NEXT;
1041
1042         CASE (BRgotoifnonnilelsepop):
1043           MAYBE_GC ();
1044           op = *stack.pc++;
1045           if (!NILP (TOP))
1046             {
1047               BYTE_CODE_QUIT;
1048               stack.pc += op - 128;
1049             }
1050           else DISCARD (1);
1051           NEXT;
1052
1053         CASE (Breturn):
1054           result = POP;
1055           goto exit;
1056
1057         CASE (Bdiscard):
1058           DISCARD (1);
1059           NEXT;
1060
1061         CASE (Bconstant2):
1062           PUSH (vectorp[FETCH2]);
1063           NEXT;
1064
1065         CASE (Bsave_excursion):
1066           record_unwind_protect (save_excursion_restore,
1067                                  save_excursion_save ());
1068           NEXT;
1069
1070         CASE (Bsave_current_buffer): /* Obsolete since ??.  */
1071         CASE (Bsave_current_buffer_1):
1072           record_unwind_current_buffer ();
1073           NEXT;
1074
1075         CASE (Bsave_window_excursion): /* Obsolete since 24.1.  */
1076           {
1077             ptrdiff_t count1 = SPECPDL_INDEX ();
1078             record_unwind_protect (restore_window_configuration,
1079                                    Fcurrent_window_configuration (Qnil));
1080             BEFORE_POTENTIAL_GC ();
1081             TOP = Fprogn (TOP);
1082             unbind_to (count1, TOP);
1083             AFTER_POTENTIAL_GC ();
1084             NEXT;
1085           }
1086
1087         CASE (Bsave_restriction):
1088           record_unwind_protect (save_restriction_restore,
1089                                  save_restriction_save ());
1090           NEXT;
1091
1092         CASE (Bcatch):          /* Obsolete since 24.4.  */
1093           {
1094             Lisp_Object v1;
1095             BEFORE_POTENTIAL_GC ();
1096             v1 = POP;
1097             TOP = internal_catch (TOP, eval_sub, v1);
1098             AFTER_POTENTIAL_GC ();
1099             NEXT;
1100           }
1101
1102         CASE (Bpushcatch):      /* New in 24.4.  */
1103           type = CATCHER;
1104           goto pushhandler;
1105         CASE (Bpushconditioncase): /* New in 24.4.  */
1106           {
1107             extern EMACS_INT lisp_eval_depth;
1108             extern int poll_suppress_count;
1109             extern int interrupt_input_blocked;
1110             struct handler *c;
1111             Lisp_Object tag;
1112             int dest;
1113
1114             type = CONDITION_CASE;
1115           pushhandler:
1116             tag = POP;
1117             dest = FETCH2;
1118
1119             PUSH_HANDLER (c, tag, type);
1120             c->bytecode_dest = dest;
1121             c->bytecode_top = top;
1122
1123             if (sys_setjmp (c->jmp))
1124               {
1125                 struct handler *c = handlerlist;
1126                 int dest;
1127                 top = c->bytecode_top;
1128                 dest = c->bytecode_dest;
1129                 handlerlist = c->next;
1130                 PUSH (c->val);
1131                 CHECK_RANGE (dest);
1132                 /* Might have been re-set by longjmp!  */
1133                 stack.byte_string_start = SDATA (stack.byte_string);
1134                 stack.pc = stack.byte_string_start + dest;
1135               }
1136
1137             NEXT;
1138           }
1139
1140         CASE (Bpophandler):     /* New in 24.4.  */
1141           {
1142             handlerlist = handlerlist->next;
1143             NEXT;
1144           }
1145
1146         CASE (Bunwind_protect): /* FIXME: avoid closure for lexbind.  */
1147           {
1148             Lisp_Object handler = POP;
1149             /* Support for a function here is new in 24.4.  */
1150             record_unwind_protect (NILP (Ffunctionp (handler))
1151                                    ? unwind_body : bcall0,
1152                                    handler);
1153             NEXT;
1154           }
1155
1156         CASE (Bcondition_case):         /* Obsolete since 24.4.  */
1157           {
1158             Lisp_Object handlers, body;
1159             handlers = POP;
1160             body = POP;
1161             BEFORE_POTENTIAL_GC ();
1162             TOP = internal_lisp_condition_case (TOP, body, handlers);
1163             AFTER_POTENTIAL_GC ();
1164             NEXT;
1165           }
1166
1167         CASE (Btemp_output_buffer_setup): /* Obsolete since 24.1.  */
1168           BEFORE_POTENTIAL_GC ();
1169           CHECK_STRING (TOP);
1170           temp_output_buffer_setup (SSDATA (TOP));
1171           AFTER_POTENTIAL_GC ();
1172           TOP = Vstandard_output;
1173           NEXT;
1174
1175         CASE (Btemp_output_buffer_show): /* Obsolete since 24.1.  */
1176           {
1177             Lisp_Object v1;
1178             BEFORE_POTENTIAL_GC ();
1179             v1 = POP;
1180             temp_output_buffer_show (TOP);
1181             TOP = v1;
1182             /* pop binding of standard-output */
1183             unbind_to (SPECPDL_INDEX () - 1, Qnil);
1184             AFTER_POTENTIAL_GC ();
1185             NEXT;
1186           }
1187
1188         CASE (Bnth):
1189           {
1190             Lisp_Object v1, v2;
1191             EMACS_INT n;
1192             BEFORE_POTENTIAL_GC ();
1193             v1 = POP;
1194             v2 = TOP;
1195             CHECK_NUMBER (v2);
1196             n = XINT (v2);
1197             immediate_quit = 1;
1198             while (--n >= 0 && CONSP (v1))
1199               v1 = XCDR (v1);
1200             immediate_quit = 0;
1201             TOP = CAR (v1);
1202             AFTER_POTENTIAL_GC ();
1203             NEXT;
1204           }
1205
1206         CASE (Bsymbolp):
1207           TOP = SYMBOLP (TOP) ? Qt : Qnil;
1208           NEXT;
1209
1210         CASE (Bconsp):
1211           TOP = CONSP (TOP) ? Qt : Qnil;
1212           NEXT;
1213
1214         CASE (Bstringp):
1215           TOP = STRINGP (TOP) ? Qt : Qnil;
1216           NEXT;
1217
1218         CASE (Blistp):
1219           TOP = CONSP (TOP) || NILP (TOP) ? Qt : Qnil;
1220           NEXT;
1221
1222         CASE (Bnot):
1223           TOP = NILP (TOP) ? Qt : Qnil;
1224           NEXT;
1225
1226         CASE (Bcons):
1227           {
1228             Lisp_Object v1;
1229             v1 = POP;
1230             TOP = Fcons (TOP, v1);
1231             NEXT;
1232           }
1233
1234         CASE (Blist1):
1235           TOP = list1 (TOP);
1236           NEXT;
1237
1238         CASE (Blist2):
1239           {
1240             Lisp_Object v1;
1241             v1 = POP;
1242             TOP = list2 (TOP, v1);
1243             NEXT;
1244           }
1245
1246         CASE (Blist3):
1247           DISCARD (2);
1248           TOP = Flist (3, &TOP);
1249           NEXT;
1250
1251         CASE (Blist4):
1252           DISCARD (3);
1253           TOP = Flist (4, &TOP);
1254           NEXT;
1255
1256         CASE (BlistN):
1257           op = FETCH;
1258           DISCARD (op - 1);
1259           TOP = Flist (op, &TOP);
1260           NEXT;
1261
1262         CASE (Blength):
1263           BEFORE_POTENTIAL_GC ();
1264           TOP = Flength (TOP);
1265           AFTER_POTENTIAL_GC ();
1266           NEXT;
1267
1268         CASE (Baref):
1269           {
1270             Lisp_Object v1;
1271             BEFORE_POTENTIAL_GC ();
1272             v1 = POP;
1273             TOP = Faref (TOP, v1);
1274             AFTER_POTENTIAL_GC ();
1275             NEXT;
1276           }
1277
1278         CASE (Baset):
1279           {
1280             Lisp_Object v1, v2;
1281             BEFORE_POTENTIAL_GC ();
1282             v2 = POP; v1 = POP;
1283             TOP = Faset (TOP, v1, v2);
1284             AFTER_POTENTIAL_GC ();
1285             NEXT;
1286           }
1287
1288         CASE (Bsymbol_value):
1289           BEFORE_POTENTIAL_GC ();
1290           TOP = Fsymbol_value (TOP);
1291           AFTER_POTENTIAL_GC ();
1292           NEXT;
1293
1294         CASE (Bsymbol_function):
1295           BEFORE_POTENTIAL_GC ();
1296           TOP = Fsymbol_function (TOP);
1297           AFTER_POTENTIAL_GC ();
1298           NEXT;
1299
1300         CASE (Bset):
1301           {
1302             Lisp_Object v1;
1303             BEFORE_POTENTIAL_GC ();
1304             v1 = POP;
1305             TOP = Fset (TOP, v1);
1306             AFTER_POTENTIAL_GC ();
1307             NEXT;
1308           }
1309
1310         CASE (Bfset):
1311           {
1312             Lisp_Object v1;
1313             BEFORE_POTENTIAL_GC ();
1314             v1 = POP;
1315             TOP = Ffset (TOP, v1);
1316             AFTER_POTENTIAL_GC ();
1317             NEXT;
1318           }
1319
1320         CASE (Bget):
1321           {
1322             Lisp_Object v1;
1323             BEFORE_POTENTIAL_GC ();
1324             v1 = POP;
1325             TOP = Fget (TOP, v1);
1326             AFTER_POTENTIAL_GC ();
1327             NEXT;
1328           }
1329
1330         CASE (Bsubstring):
1331           {
1332             Lisp_Object v1, v2;
1333             BEFORE_POTENTIAL_GC ();
1334             v2 = POP; v1 = POP;
1335             TOP = Fsubstring (TOP, v1, v2);
1336             AFTER_POTENTIAL_GC ();
1337             NEXT;
1338           }
1339
1340         CASE (Bconcat2):
1341           BEFORE_POTENTIAL_GC ();
1342           DISCARD (1);
1343           TOP = Fconcat (2, &TOP);
1344           AFTER_POTENTIAL_GC ();
1345           NEXT;
1346
1347         CASE (Bconcat3):
1348           BEFORE_POTENTIAL_GC ();
1349           DISCARD (2);
1350           TOP = Fconcat (3, &TOP);
1351           AFTER_POTENTIAL_GC ();
1352           NEXT;
1353
1354         CASE (Bconcat4):
1355           BEFORE_POTENTIAL_GC ();
1356           DISCARD (3);
1357           TOP = Fconcat (4, &TOP);
1358           AFTER_POTENTIAL_GC ();
1359           NEXT;
1360
1361         CASE (BconcatN):
1362           op = FETCH;
1363           BEFORE_POTENTIAL_GC ();
1364           DISCARD (op - 1);
1365           TOP = Fconcat (op, &TOP);
1366           AFTER_POTENTIAL_GC ();
1367           NEXT;
1368
1369         CASE (Bsub1):
1370           {
1371             Lisp_Object v1;
1372             v1 = TOP;
1373             if (INTEGERP (v1))
1374               {
1375                 XSETINT (v1, XINT (v1) - 1);
1376                 TOP = v1;
1377               }
1378             else
1379               {
1380                 BEFORE_POTENTIAL_GC ();
1381                 TOP = Fsub1 (v1);
1382                 AFTER_POTENTIAL_GC ();
1383               }
1384             NEXT;
1385           }
1386
1387         CASE (Badd1):
1388           {
1389             Lisp_Object v1;
1390             v1 = TOP;
1391             if (INTEGERP (v1))
1392               {
1393                 XSETINT (v1, XINT (v1) + 1);
1394                 TOP = v1;
1395               }
1396             else
1397               {
1398                 BEFORE_POTENTIAL_GC ();
1399                 TOP = Fadd1 (v1);
1400                 AFTER_POTENTIAL_GC ();
1401               }
1402             NEXT;
1403           }
1404
1405         CASE (Beqlsign):
1406           {
1407             Lisp_Object v1, v2;
1408             BEFORE_POTENTIAL_GC ();
1409             v2 = POP; v1 = TOP;
1410             CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1);
1411             CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2);
1412             AFTER_POTENTIAL_GC ();
1413             if (FLOATP (v1) || FLOATP (v2))
1414               {
1415                 double f1, f2;
1416
1417                 f1 = (FLOATP (v1) ? XFLOAT_DATA (v1) : XINT (v1));
1418                 f2 = (FLOATP (v2) ? XFLOAT_DATA (v2) : XINT (v2));
1419                 TOP = (f1 == f2 ? Qt : Qnil);
1420               }
1421             else
1422               TOP = (XINT (v1) == XINT (v2) ? Qt : Qnil);
1423             NEXT;
1424           }
1425
1426         CASE (Bgtr):
1427           {
1428             Lisp_Object v1;
1429             BEFORE_POTENTIAL_GC ();
1430             v1 = POP;
1431             TOP = arithcompare (TOP, v1, ARITH_GRTR);
1432             AFTER_POTENTIAL_GC ();
1433             NEXT;
1434           }
1435
1436         CASE (Blss):
1437           {
1438             Lisp_Object v1;
1439             BEFORE_POTENTIAL_GC ();
1440             v1 = POP;
1441             TOP = arithcompare (TOP, v1, ARITH_LESS);
1442             AFTER_POTENTIAL_GC ();
1443             NEXT;
1444           }
1445
1446         CASE (Bleq):
1447           {
1448             Lisp_Object v1;
1449             BEFORE_POTENTIAL_GC ();
1450             v1 = POP;
1451             TOP = arithcompare (TOP, v1, ARITH_LESS_OR_EQUAL);
1452             AFTER_POTENTIAL_GC ();
1453             NEXT;
1454           }
1455
1456         CASE (Bgeq):
1457           {
1458             Lisp_Object v1;
1459             BEFORE_POTENTIAL_GC ();
1460             v1 = POP;
1461             TOP = arithcompare (TOP, v1, ARITH_GRTR_OR_EQUAL);
1462             AFTER_POTENTIAL_GC ();
1463             NEXT;
1464           }
1465
1466         CASE (Bdiff):
1467           BEFORE_POTENTIAL_GC ();
1468           DISCARD (1);
1469           TOP = Fminus (2, &TOP);
1470           AFTER_POTENTIAL_GC ();
1471           NEXT;
1472
1473         CASE (Bnegate):
1474           {
1475             Lisp_Object v1;
1476             v1 = TOP;
1477             if (INTEGERP (v1))
1478               {
1479                 XSETINT (v1, - XINT (v1));
1480                 TOP = v1;
1481               }
1482             else
1483               {
1484                 BEFORE_POTENTIAL_GC ();
1485                 TOP = Fminus (1, &TOP);
1486                 AFTER_POTENTIAL_GC ();
1487               }
1488             NEXT;
1489           }
1490
1491         CASE (Bplus):
1492           BEFORE_POTENTIAL_GC ();
1493           DISCARD (1);
1494           TOP = Fplus (2, &TOP);
1495           AFTER_POTENTIAL_GC ();
1496           NEXT;
1497
1498         CASE (Bmax):
1499           BEFORE_POTENTIAL_GC ();
1500           DISCARD (1);
1501           TOP = Fmax (2, &TOP);
1502           AFTER_POTENTIAL_GC ();
1503           NEXT;
1504
1505         CASE (Bmin):
1506           BEFORE_POTENTIAL_GC ();
1507           DISCARD (1);
1508           TOP = Fmin (2, &TOP);
1509           AFTER_POTENTIAL_GC ();
1510           NEXT;
1511
1512         CASE (Bmult):
1513           BEFORE_POTENTIAL_GC ();
1514           DISCARD (1);
1515           TOP = Ftimes (2, &TOP);
1516           AFTER_POTENTIAL_GC ();
1517           NEXT;
1518
1519         CASE (Bquo):
1520           BEFORE_POTENTIAL_GC ();
1521           DISCARD (1);
1522           TOP = Fquo (2, &TOP);
1523           AFTER_POTENTIAL_GC ();
1524           NEXT;
1525
1526         CASE (Brem):
1527           {
1528             Lisp_Object v1;
1529             BEFORE_POTENTIAL_GC ();
1530             v1 = POP;
1531             TOP = Frem (TOP, v1);
1532             AFTER_POTENTIAL_GC ();
1533             NEXT;
1534           }
1535
1536         CASE (Bpoint):
1537           {
1538             Lisp_Object v1;
1539             XSETFASTINT (v1, PT);
1540             PUSH (v1);
1541             NEXT;
1542           }
1543
1544         CASE (Bgoto_char):
1545           BEFORE_POTENTIAL_GC ();
1546           TOP = Fgoto_char (TOP);
1547           AFTER_POTENTIAL_GC ();
1548           NEXT;
1549
1550         CASE (Binsert):
1551           BEFORE_POTENTIAL_GC ();
1552           TOP = Finsert (1, &TOP);
1553           AFTER_POTENTIAL_GC ();
1554           NEXT;
1555
1556         CASE (BinsertN):
1557           op = FETCH;
1558           BEFORE_POTENTIAL_GC ();
1559           DISCARD (op - 1);
1560           TOP = Finsert (op, &TOP);
1561           AFTER_POTENTIAL_GC ();
1562           NEXT;
1563
1564         CASE (Bpoint_max):
1565           {
1566             Lisp_Object v1;
1567             XSETFASTINT (v1, ZV);
1568             PUSH (v1);
1569             NEXT;
1570           }
1571
1572         CASE (Bpoint_min):
1573           {
1574             Lisp_Object v1;
1575             XSETFASTINT (v1, BEGV);
1576             PUSH (v1);
1577             NEXT;
1578           }
1579
1580         CASE (Bchar_after):
1581           BEFORE_POTENTIAL_GC ();
1582           TOP = Fchar_after (TOP);
1583           AFTER_POTENTIAL_GC ();
1584           NEXT;
1585
1586         CASE (Bfollowing_char):
1587           {
1588             Lisp_Object v1;
1589             BEFORE_POTENTIAL_GC ();
1590             v1 = Ffollowing_char ();
1591             AFTER_POTENTIAL_GC ();
1592             PUSH (v1);
1593             NEXT;
1594           }
1595
1596         CASE (Bpreceding_char):
1597           {
1598             Lisp_Object v1;
1599             BEFORE_POTENTIAL_GC ();
1600             v1 = Fprevious_char ();
1601             AFTER_POTENTIAL_GC ();
1602             PUSH (v1);
1603             NEXT;
1604           }
1605
1606         CASE (Bcurrent_column):
1607           {
1608             Lisp_Object v1;
1609             BEFORE_POTENTIAL_GC ();
1610             XSETFASTINT (v1, current_column ());
1611             AFTER_POTENTIAL_GC ();
1612             PUSH (v1);
1613             NEXT;
1614           }
1615
1616         CASE (Bindent_to):
1617           BEFORE_POTENTIAL_GC ();
1618           TOP = Findent_to (TOP, Qnil);
1619           AFTER_POTENTIAL_GC ();
1620           NEXT;
1621
1622         CASE (Beolp):
1623           PUSH (Feolp ());
1624           NEXT;
1625
1626         CASE (Beobp):
1627           PUSH (Feobp ());
1628           NEXT;
1629
1630         CASE (Bbolp):
1631           PUSH (Fbolp ());
1632           NEXT;
1633
1634         CASE (Bbobp):
1635           PUSH (Fbobp ());
1636           NEXT;
1637
1638         CASE (Bcurrent_buffer):
1639           PUSH (Fcurrent_buffer ());
1640           NEXT;
1641
1642         CASE (Bset_buffer):
1643           BEFORE_POTENTIAL_GC ();
1644           TOP = Fset_buffer (TOP);
1645           AFTER_POTENTIAL_GC ();
1646           NEXT;
1647
1648         CASE (Binteractive_p):  /* Obsolete since 24.1.  */
1649           BEFORE_POTENTIAL_GC ();
1650           PUSH (call0 (intern ("interactive-p")));
1651           AFTER_POTENTIAL_GC ();
1652           NEXT;
1653
1654         CASE (Bforward_char):
1655           BEFORE_POTENTIAL_GC ();
1656           TOP = Fforward_char (TOP);
1657           AFTER_POTENTIAL_GC ();
1658           NEXT;
1659
1660         CASE (Bforward_word):
1661           BEFORE_POTENTIAL_GC ();
1662           TOP = Fforward_word (TOP);
1663           AFTER_POTENTIAL_GC ();
1664           NEXT;
1665
1666         CASE (Bskip_chars_forward):
1667           {
1668             Lisp_Object v1;
1669             BEFORE_POTENTIAL_GC ();
1670             v1 = POP;
1671             TOP = Fskip_chars_forward (TOP, v1);
1672             AFTER_POTENTIAL_GC ();
1673             NEXT;
1674           }
1675
1676         CASE (Bskip_chars_backward):
1677           {
1678             Lisp_Object v1;
1679             BEFORE_POTENTIAL_GC ();
1680             v1 = POP;
1681             TOP = Fskip_chars_backward (TOP, v1);
1682             AFTER_POTENTIAL_GC ();
1683             NEXT;
1684           }
1685
1686         CASE (Bforward_line):
1687           BEFORE_POTENTIAL_GC ();
1688           TOP = Fforward_line (TOP);
1689           AFTER_POTENTIAL_GC ();
1690           NEXT;
1691
1692         CASE (Bchar_syntax):
1693           {
1694             int c;
1695
1696             BEFORE_POTENTIAL_GC ();
1697             CHECK_CHARACTER (TOP);
1698             AFTER_POTENTIAL_GC ();
1699             c = XFASTINT (TOP);
1700             if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
1701               MAKE_CHAR_MULTIBYTE (c);
1702             XSETFASTINT (TOP, syntax_code_spec[SYNTAX (c)]);
1703           }
1704           NEXT;
1705
1706         CASE (Bbuffer_substring):
1707           {
1708             Lisp_Object v1;
1709             BEFORE_POTENTIAL_GC ();
1710             v1 = POP;
1711             TOP = Fbuffer_substring (TOP, v1);
1712             AFTER_POTENTIAL_GC ();
1713             NEXT;
1714           }
1715
1716         CASE (Bdelete_region):
1717           {
1718             Lisp_Object v1;
1719             BEFORE_POTENTIAL_GC ();
1720             v1 = POP;
1721             TOP = Fdelete_region (TOP, v1);
1722             AFTER_POTENTIAL_GC ();
1723             NEXT;
1724           }
1725
1726         CASE (Bnarrow_to_region):
1727           {
1728             Lisp_Object v1;
1729             BEFORE_POTENTIAL_GC ();
1730             v1 = POP;
1731             TOP = Fnarrow_to_region (TOP, v1);
1732             AFTER_POTENTIAL_GC ();
1733             NEXT;
1734           }
1735
1736         CASE (Bwiden):
1737           BEFORE_POTENTIAL_GC ();
1738           PUSH (Fwiden ());
1739           AFTER_POTENTIAL_GC ();
1740           NEXT;
1741
1742         CASE (Bend_of_line):
1743           BEFORE_POTENTIAL_GC ();
1744           TOP = Fend_of_line (TOP);
1745           AFTER_POTENTIAL_GC ();
1746           NEXT;
1747
1748         CASE (Bset_marker):
1749           {
1750             Lisp_Object v1, v2;
1751             BEFORE_POTENTIAL_GC ();
1752             v1 = POP;
1753             v2 = POP;
1754             TOP = Fset_marker (TOP, v2, v1);
1755             AFTER_POTENTIAL_GC ();
1756             NEXT;
1757           }
1758
1759         CASE (Bmatch_beginning):
1760           BEFORE_POTENTIAL_GC ();
1761           TOP = Fmatch_beginning (TOP);
1762           AFTER_POTENTIAL_GC ();
1763           NEXT;
1764
1765         CASE (Bmatch_end):
1766           BEFORE_POTENTIAL_GC ();
1767           TOP = Fmatch_end (TOP);
1768           AFTER_POTENTIAL_GC ();
1769           NEXT;
1770
1771         CASE (Bupcase):
1772           BEFORE_POTENTIAL_GC ();
1773           TOP = Fupcase (TOP);
1774           AFTER_POTENTIAL_GC ();
1775           NEXT;
1776
1777         CASE (Bdowncase):
1778           BEFORE_POTENTIAL_GC ();
1779           TOP = Fdowncase (TOP);
1780           AFTER_POTENTIAL_GC ();
1781         NEXT;
1782
1783       CASE (Bstringeqlsign):
1784           {
1785             Lisp_Object v1;
1786             BEFORE_POTENTIAL_GC ();
1787             v1 = POP;
1788             TOP = Fstring_equal (TOP, v1);
1789             AFTER_POTENTIAL_GC ();
1790             NEXT;
1791           }
1792
1793         CASE (Bstringlss):
1794           {
1795             Lisp_Object v1;
1796             BEFORE_POTENTIAL_GC ();
1797             v1 = POP;
1798             TOP = Fstring_lessp (TOP, v1);
1799             AFTER_POTENTIAL_GC ();
1800             NEXT;
1801           }
1802
1803         CASE (Bequal):
1804           {
1805             Lisp_Object v1;
1806             v1 = POP;
1807             TOP = Fequal (TOP, v1);
1808             NEXT;
1809           }
1810
1811         CASE (Bnthcdr):
1812           {
1813             Lisp_Object v1;
1814             BEFORE_POTENTIAL_GC ();
1815             v1 = POP;
1816             TOP = Fnthcdr (TOP, v1);
1817             AFTER_POTENTIAL_GC ();
1818             NEXT;
1819           }
1820
1821         CASE (Belt):
1822           {
1823             Lisp_Object v1, v2;
1824             if (CONSP (TOP))
1825               {
1826                 /* Exchange args and then do nth.  */
1827                 EMACS_INT n;
1828                 BEFORE_POTENTIAL_GC ();
1829                 v2 = POP;
1830                 v1 = TOP;
1831                 CHECK_NUMBER (v2);
1832                 AFTER_POTENTIAL_GC ();
1833                 n = XINT (v2);
1834                 immediate_quit = 1;
1835                 while (--n >= 0 && CONSP (v1))
1836                   v1 = XCDR (v1);
1837                 immediate_quit = 0;
1838                 TOP = CAR (v1);
1839               }
1840             else
1841               {
1842                 BEFORE_POTENTIAL_GC ();
1843                 v1 = POP;
1844                 TOP = Felt (TOP, v1);
1845                 AFTER_POTENTIAL_GC ();
1846               }
1847             NEXT;
1848           }
1849
1850         CASE (Bmember):
1851           {
1852             Lisp_Object v1;
1853             BEFORE_POTENTIAL_GC ();
1854             v1 = POP;
1855             TOP = Fmember (TOP, v1);
1856             AFTER_POTENTIAL_GC ();
1857             NEXT;
1858           }
1859
1860         CASE (Bassq):
1861           {
1862             Lisp_Object v1;
1863             BEFORE_POTENTIAL_GC ();
1864             v1 = POP;
1865             TOP = Fassq (TOP, v1);
1866             AFTER_POTENTIAL_GC ();
1867             NEXT;
1868           }
1869
1870         CASE (Bnreverse):
1871           BEFORE_POTENTIAL_GC ();
1872           TOP = Fnreverse (TOP);
1873           AFTER_POTENTIAL_GC ();
1874           NEXT;
1875
1876         CASE (Bsetcar):
1877           {
1878             Lisp_Object v1;
1879             BEFORE_POTENTIAL_GC ();
1880             v1 = POP;
1881             TOP = Fsetcar (TOP, v1);
1882             AFTER_POTENTIAL_GC ();
1883             NEXT;
1884           }
1885
1886         CASE (Bsetcdr):
1887           {
1888             Lisp_Object v1;
1889             BEFORE_POTENTIAL_GC ();
1890             v1 = POP;
1891             TOP = Fsetcdr (TOP, v1);
1892             AFTER_POTENTIAL_GC ();
1893             NEXT;
1894           }
1895
1896         CASE (Bcar_safe):
1897           {
1898             Lisp_Object v1;
1899             v1 = TOP;
1900             TOP = CAR_SAFE (v1);
1901             NEXT;
1902           }
1903
1904         CASE (Bcdr_safe):
1905           {
1906             Lisp_Object v1;
1907             v1 = TOP;
1908             TOP = CDR_SAFE (v1);
1909             NEXT;
1910           }
1911
1912         CASE (Bnconc):
1913           BEFORE_POTENTIAL_GC ();
1914           DISCARD (1);
1915           TOP = Fnconc (2, &TOP);
1916           AFTER_POTENTIAL_GC ();
1917           NEXT;
1918
1919         CASE (Bnumberp):
1920           TOP = (NUMBERP (TOP) ? Qt : Qnil);
1921           NEXT;
1922
1923         CASE (Bintegerp):
1924           TOP = INTEGERP (TOP) ? Qt : Qnil;
1925           NEXT;
1926
1927 #ifdef BYTE_CODE_SAFE
1928           /* These are intentionally written using 'case' syntax,
1929              because they are incompatible with the threaded
1930              interpreter.  */
1931
1932         case Bset_mark:
1933           BEFORE_POTENTIAL_GC ();
1934           error ("set-mark is an obsolete bytecode");
1935           AFTER_POTENTIAL_GC ();
1936           break;
1937         case Bscan_buffer:
1938           BEFORE_POTENTIAL_GC ();
1939           error ("scan-buffer is an obsolete bytecode");
1940           AFTER_POTENTIAL_GC ();
1941           break;
1942 #endif
1943
1944         CASE_ABORT:
1945           /* Actually this is Bstack_ref with offset 0, but we use Bdup
1946              for that instead.  */
1947           /* CASE (Bstack_ref): */
1948          call3 (intern ("error"),
1949                 build_string ("Invalid byte opcode: op=%s, ptr=%d"),
1950                 make_number (op),
1951                 make_number ((stack.pc - 1) - stack.byte_string_start));
1952
1953           /* Handy byte-codes for lexical binding.  */
1954         CASE (Bstack_ref1):
1955         CASE (Bstack_ref2):
1956         CASE (Bstack_ref3):
1957         CASE (Bstack_ref4):
1958         CASE (Bstack_ref5):
1959           {
1960             Lisp_Object *ptr = top - (op - Bstack_ref);
1961             PUSH (*ptr);
1962             NEXT;
1963           }
1964         CASE (Bstack_ref6):
1965           {
1966             Lisp_Object *ptr = top - (FETCH);
1967             PUSH (*ptr);
1968             NEXT;
1969           }
1970         CASE (Bstack_ref7):
1971           {
1972             Lisp_Object *ptr = top - (FETCH2);
1973             PUSH (*ptr);
1974             NEXT;
1975           }
1976         CASE (Bstack_set):
1977           /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos.  */
1978           {
1979             Lisp_Object *ptr = top - (FETCH);
1980             *ptr = POP;
1981             NEXT;
1982           }
1983         CASE (Bstack_set2):
1984           {
1985             Lisp_Object *ptr = top - (FETCH2);
1986             *ptr = POP;
1987             NEXT;
1988           }
1989         CASE (BdiscardN):
1990           op = FETCH;
1991           if (op & 0x80)
1992             {
1993               op &= 0x7F;
1994               top[-op] = TOP;
1995             }
1996           DISCARD (op);
1997           NEXT;
1998
1999         CASE_DEFAULT
2000         CASE (Bconstant):
2001 #ifdef BYTE_CODE_SAFE
2002           if (op < Bconstant)
2003             {
2004               emacs_abort ();
2005             }
2006           if ((op -= Bconstant) >= const_length)
2007             {
2008               emacs_abort ();
2009             }
2010           PUSH (vectorp[op]);
2011 #else
2012           PUSH (vectorp[op - Bconstant]);
2013 #endif
2014           NEXT;
2015         }
2016     }
2017
2018  exit:
2019
2020   byte_stack_list = byte_stack_list->next;
2021
2022   /* Binds and unbinds are supposed to be compiled balanced.  */
2023   if (SPECPDL_INDEX () != count)
2024     {
2025       if (SPECPDL_INDEX () > count)
2026         unbind_to (count, Qnil);
2027       error ("binding stack not balanced (serious byte compiler bug)");
2028     }
2029
2030   return result;
2031 }
2032
2033 void
2034 syms_of_bytecode (void)
2035 {
2036   defsubr (&Sbyte_code);
2037
2038 #ifdef BYTE_CODE_METER
2039
2040   DEFVAR_LISP ("byte-code-meter", Vbyte_code_meter,
2041                doc: /* A vector of vectors which holds a histogram of byte-code usage.
2042 \(aref (aref byte-code-meter 0) CODE) indicates how many times the byte
2043 opcode CODE has been executed.
2044 \(aref (aref byte-code-meter CODE1) CODE2), where CODE1 is not 0,
2045 indicates how many times the byte opcodes CODE1 and CODE2 have been
2046 executed in succession.  */);
2047
2048   DEFVAR_BOOL ("byte-metering-on", byte_metering_on,
2049                doc: /* If non-nil, keep profiling information on byte code usage.
2050 The variable byte-code-meter indicates how often each byte opcode is used.
2051 If a symbol has a property named `byte-code-meter' whose value is an
2052 integer, it is incremented each time that symbol's function is called.  */);
2053
2054   byte_metering_on = 0;
2055   Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
2056   DEFSYM (Qbyte_code_meter, "byte-code-meter");
2057   {
2058     int i = 256;
2059     while (i--)
2060       ASET (Vbyte_code_meter, i,
2061            Fmake_vector (make_number (256), make_number (0)));
2062   }
2063 #endif
2064 }