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