1 /* Copyright (C) 2001, 2009, 2010 Free Software Foundation, Inc.
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public License
5 * as published by the Free Software Foundation; either version 3 of
6 * the License, or (at your option) any later version.
8 * This library is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
27 #include "libguile/bdw-gc.h"
28 #include <gc/gc_mark.h>
33 #include "instructions.h"
38 /* I sometimes use this for debugging. */
39 #define vm_puts(OBJ) \
41 scm_display (OBJ, scm_current_error_port ()); \
42 scm_newline (scm_current_error_port ()); \
45 /* The VM has a number of internal assertions that shouldn't normally be
46 necessary, but might be if you think you found a bug in the VM. */
47 #define VM_ENABLE_ASSERTIONS
49 /* We can add a mode that ensures that all stack items above the stack pointer
50 are NULL. This is useful for checking the internal consistency of the VM's
51 assumptions and its operators, but isn't necessary for normal operation. It
52 will ensure that assertions are enabled. Slows down the VM by about 30%. */
53 /* NB! If you enable this, search for NULLING in throw.c */
54 /* #define VM_ENABLE_STACK_NULLING */
56 /* #define VM_ENABLE_PARANOID_ASSERTIONS */
58 #if defined (VM_ENABLE_STACK_NULLING) && !defined (VM_ENABLE_ASSERTIONS)
59 #define VM_ENABLE_ASSERTIONS
62 /* When defined, arrange so that the GC doesn't scan the VM stack beyond its
63 current SP. This should help avoid excess data retention. See
64 http://thread.gmane.org/gmane.comp.programming.garbage-collection.boehmgc/3001
66 #define VM_ENABLE_PRECISE_STACK_GC_SCAN
75 scm_i_vm_cont_print (SCM x
, SCM port
, scm_print_state
*pstate
)
77 scm_puts ("#<vm-continuation ", port
);
78 scm_uintprint (SCM_UNPACK (x
), 16, port
);
82 /* In theory, a number of vm instances can be active in the call trace, and we
83 only want to reify the continuations of those in the current continuation
84 root. I don't see a nice way to do this -- ideally it would involve dynwinds,
85 and previous values of the *the-vm* fluid within the current continuation
86 root. But we don't have access to continuation roots in the dynwind stack.
87 So, just punt for now, we just capture the continuation for the current VM.
89 While I'm on the topic, ideally we could avoid copying the C stack if the
90 continuation root is inside VM code, and call/cc was invoked within that same
91 call to vm_run; but that's currently not implemented.
94 scm_i_vm_capture_stack (SCM
*stack_base
, SCM
*fp
, SCM
*sp
, scm_t_uint8
*ra
,
95 scm_t_uint8
*mvra
, scm_t_uint32 flags
)
97 struct scm_vm_cont
*p
;
99 p
= scm_gc_malloc (sizeof (*p
), "capture_vm_cont");
100 p
->stack_size
= sp
- stack_base
+ 1;
101 p
->stack_base
= scm_gc_malloc (p
->stack_size
* sizeof (SCM
),
103 #if defined(VM_ENABLE_STACK_NULLING) && 0
104 /* Tail continuations leave their frame on the stack for subsequent
105 application, but don't capture the frame -- so there are some elements on
106 the stack then, and this check doesn't work, so disable it for now. */
107 if (sp
>= vp
->stack_base
)
108 if (!vp
->sp
[0] || vp
->sp
[1])
110 memset (p
->stack_base
, 0, p
->stack_size
* sizeof (SCM
));
116 memcpy (p
->stack_base
, stack_base
, (sp
+ 1 - stack_base
) * sizeof (SCM
));
117 p
->reloc
= p
->stack_base
- stack_base
;
119 return scm_cell (scm_tc7_vm_cont
, (scm_t_bits
)p
);
123 vm_return_to_continuation (SCM vm
, SCM cont
, size_t n
, SCM
*argv
)
126 struct scm_vm_cont
*cp
;
129 argv_copy
= alloca (n
* sizeof(SCM
));
130 memcpy (argv_copy
, argv
, n
* sizeof(SCM
));
132 vp
= SCM_VM_DATA (vm
);
133 cp
= SCM_VM_CONT_DATA (cont
);
135 if (n
== 0 && !cp
->mvra
)
136 scm_misc_error (NULL
, "Too few values returned to continuation",
139 if (vp
->stack_size
< cp
->stack_size
+ n
+ 1)
140 scm_misc_error ("vm-engine", "not enough space to reinstate continuation",
141 scm_list_2 (vm
, cont
));
143 #ifdef VM_ENABLE_STACK_NULLING
145 scm_t_ptrdiff nzero
= (vp
->sp
- cp
->sp
);
147 memset (vp
->stack_base
+ cp
->stack_size
, 0, nzero
* sizeof (SCM
));
148 /* actually nzero should always be negative, because vm_reset_stack will
149 unwind the stack to some point *below* this continuation */
154 memcpy (vp
->stack_base
, cp
->stack_base
, cp
->stack_size
* sizeof (SCM
));
156 if (n
== 1 || !cp
->mvra
)
160 *vp
->sp
= argv_copy
[0];
165 for (i
= 0; i
< n
; i
++)
168 *vp
->sp
= argv_copy
[i
];
171 *vp
->sp
= scm_from_size_t (n
);
177 scm_i_vm_capture_continuation (SCM vm
)
179 struct scm_vm
*vp
= SCM_VM_DATA (vm
);
180 return scm_i_vm_capture_stack (vp
->stack_base
, vp
->fp
, vp
->sp
, vp
->ip
, NULL
, 0);
184 vm_dispatch_hook (SCM vm
, int hook_num
)
190 vp
= SCM_VM_DATA (vm
);
191 hook
= vp
->hooks
[hook_num
];
193 if (SCM_LIKELY (scm_is_false (hook
))
194 || scm_is_null (SCM_HOOK_PROCEDURES (hook
)))
198 frame
= scm_c_make_frame (vm
, vp
->fp
, vp
->sp
, vp
->ip
, 0);
199 scm_c_run_hookn (hook
, &frame
, 1);
203 static void vm_abort (SCM vm
, size_t n
, scm_t_int64 cookie
) SCM_NORETURN
;
205 vm_abort (SCM vm
, size_t n
, scm_t_int64 vm_cookie
)
209 SCM tag
, tail
, *argv
;
211 /* FIXME: VM_ENABLE_STACK_NULLING */
212 tail
= *(SCM_VM_DATA (vm
)->sp
--);
214 tail_len
= scm_ilength (tail
);
216 scm_misc_error ("vm-engine", "tail values to abort should be a list",
219 tag
= SCM_VM_DATA (vm
)->sp
[-n
];
220 argv
= alloca ((n
+ tail_len
) * sizeof (SCM
));
221 for (i
= 0; i
< n
; i
++)
222 argv
[i
] = SCM_VM_DATA (vm
)->sp
[-(n
-1-i
)];
223 for (; i
< n
+ tail_len
; i
++, tail
= scm_cdr (tail
))
224 argv
[i
] = scm_car (tail
);
225 /* NULLSTACK (n + 1) */
226 SCM_VM_DATA (vm
)->sp
-= n
+ 1;
228 scm_c_abort (vm
, tag
, n
+ tail_len
, argv
, vm_cookie
);
232 vm_reinstate_partial_continuation (SCM vm
, SCM cont
, SCM intwinds
,
233 size_t n
, SCM
*argv
, scm_t_int64 vm_cookie
)
236 struct scm_vm_cont
*cp
;
237 SCM
*argv_copy
, *base
;
240 argv_copy
= alloca (n
* sizeof(SCM
));
241 memcpy (argv_copy
, argv
, n
* sizeof(SCM
));
243 vp
= SCM_VM_DATA (vm
);
244 cp
= SCM_VM_CONT_DATA (cont
);
245 base
= SCM_FRAME_UPPER_ADDRESS (vp
->fp
) + 1;
247 #define RELOC(scm_p) (scm_p + cp->reloc + (base - cp->stack_base))
249 if ((base
- vp
->stack_base
) + cp
->stack_size
+ n
+ 1 > vp
->stack_size
)
250 scm_misc_error ("vm-engine",
251 "not enough space to instate partial continuation",
252 scm_list_2 (vm
, cont
));
254 memcpy (base
, cp
->stack_base
, cp
->stack_size
* sizeof (SCM
));
256 /* now relocate frame pointers */
259 for (fp
= RELOC (cp
->fp
);
260 SCM_FRAME_LOWER_ADDRESS (fp
) > base
;
261 fp
= SCM_FRAME_DYNAMIC_LINK (fp
))
262 SCM_FRAME_SET_DYNAMIC_LINK (fp
, RELOC (SCM_FRAME_DYNAMIC_LINK (fp
)));
265 vp
->sp
= base
- 1 + cp
->stack_size
;
266 vp
->fp
= RELOC (cp
->fp
);
269 /* now push args. ip is in a MV context. */
270 for (i
= 0; i
< n
; i
++)
273 *vp
->sp
= argv_copy
[i
];
276 *vp
->sp
= scm_from_size_t (n
);
278 /* Finally, rewind the dynamic state.
280 We have to treat prompts specially, because we could be rewinding the
281 dynamic state from a different thread, or just a different position on the
282 C and/or VM stack -- so we need to reset the jump buffers so that an abort
283 comes back here, with appropriately adjusted sp and fp registers. */
286 SCM newwinds
= scm_i_dynwinds ();
287 for (; scm_is_pair (intwinds
); intwinds
= scm_cdr (intwinds
), delta
--)
289 SCM x
= scm_car (intwinds
);
290 if (SCM_PROMPT_P (x
))
291 /* the jmpbuf will be reset by our caller */
292 x
= scm_c_make_prompt (SCM_PROMPT_TAG (x
),
293 RELOC (SCM_PROMPT_REGISTERS (x
)->fp
),
294 RELOC (SCM_PROMPT_REGISTERS (x
)->sp
),
295 SCM_PROMPT_REGISTERS (x
)->ip
,
296 SCM_PROMPT_ESCAPE_P (x
),
299 newwinds
= scm_cons (x
, newwinds
);
301 scm_dowinds (newwinds
, delta
);
308 * VM Internal functions
311 /* Unfortunately we can't snarf these: snarfed things are only loaded up from
312 (system vm vm), which might not be loaded before an error happens. */
313 static SCM sym_vm_run
, sym_vm_error
, sym_keyword_argument_error
, sym_debug
;
316 scm_i_vm_print (SCM x
, SCM port
, scm_print_state
*pstate
)
318 const struct scm_vm
*vm
;
320 vm
= SCM_VM_DATA (x
);
322 scm_puts ("#<vm ", port
);
325 case SCM_VM_REGULAR_ENGINE
:
326 scm_puts ("regular-engine ", port
);
329 case SCM_VM_DEBUG_ENGINE
:
330 scm_puts ("debug-engine ", port
);
334 scm_puts ("unknown-engine ", port
);
336 scm_uintprint (SCM_UNPACK (x
), 16, port
);
337 scm_puts (">", port
);
341 really_make_boot_program (long nargs
)
344 scm_t_uint8 text
[] = { scm_op_mv_call
, 0, 0, 0, 1,
345 scm_op_make_int8_1
, scm_op_halt
};
346 struct scm_objcode
*bp
;
349 if (SCM_UNLIKELY (nargs
> 255 || nargs
< 0))
350 scm_misc_error ("vm-engine", "too many args when making boot procedure",
351 scm_list_1 (scm_from_long (nargs
)));
353 text
[1] = (scm_t_uint8
)nargs
;
355 bp
= scm_malloc (sizeof (struct scm_objcode
) + sizeof (text
));
356 memcpy (SCM_C_OBJCODE_BASE (bp
), text
, sizeof (text
));
357 bp
->len
= sizeof(text
);
360 u8vec
= scm_c_take_bytevector ((scm_t_int8
*)bp
,
361 sizeof (struct scm_objcode
) + sizeof (text
));
362 ret
= scm_make_program (scm_bytecode_to_objcode (u8vec
),
363 SCM_BOOL_F
, SCM_BOOL_F
);
364 SCM_SET_CELL_WORD_0 (ret
, SCM_CELL_WORD_0 (ret
) | SCM_F_PROGRAM_IS_BOOT
);
368 #define NUM_BOOT_PROGS 8
370 vm_make_boot_program (long nargs
)
372 static SCM programs
[NUM_BOOT_PROGS
] = { 0, };
374 if (SCM_UNLIKELY (!programs
[0]))
377 for (i
= 0; i
< NUM_BOOT_PROGS
; i
++)
378 programs
[i
] = really_make_boot_program (i
);
381 if (SCM_LIKELY (nargs
< NUM_BOOT_PROGS
))
382 return programs
[nargs
];
384 return really_make_boot_program (nargs
);
393 resolve_variable (SCM what
, SCM program_module
)
395 if (SCM_LIKELY (scm_is_symbol (what
)))
397 if (SCM_LIKELY (scm_module_system_booted_p
398 && scm_is_true (program_module
)))
400 return scm_module_lookup (program_module
, what
);
403 SCM v
= scm_sym2var (what
, SCM_BOOL_F
, SCM_BOOL_F
);
404 if (scm_is_false (v
))
405 scm_misc_error (NULL
, "unbound variable: ~S", scm_list_1 (what
));
413 /* compilation of @ or @@
414 `what' is a three-element list: (MODNAME SYM INTERFACE?)
415 INTERFACE? is #t if we compiled @ or #f if we compiled @@
417 mod
= scm_resolve_module (SCM_CAR (what
));
418 if (scm_is_true (SCM_CADDR (what
)))
419 mod
= scm_module_public_interface (mod
);
420 if (scm_is_false (mod
))
421 scm_misc_error (NULL
, "no such module: ~S",
422 scm_list_1 (SCM_CAR (what
)));
424 return scm_module_lookup (mod
, SCM_CADR (what
));
428 #define VM_DEFAULT_STACK_SIZE (64 * 1024)
430 #define VM_NAME vm_regular_engine
431 #define FUNC_NAME "vm-regular-engine"
432 #define VM_ENGINE SCM_VM_REGULAR_ENGINE
433 #include "vm-engine.c"
438 #define VM_NAME vm_debug_engine
439 #define FUNC_NAME "vm-debug-engine"
440 #define VM_ENGINE SCM_VM_DEBUG_ENGINE
441 #include "vm-engine.c"
446 static const scm_t_vm_engine vm_engines
[] =
447 { vm_regular_engine
, vm_debug_engine
};
449 #ifdef VM_ENABLE_PRECISE_STACK_GC_SCAN
451 /* The GC "kind" for the VM stack. */
452 static int vm_stack_gc_kind
;
458 #define FUNC_NAME "make_vm"
463 vp
= scm_gc_malloc (sizeof (struct scm_vm
), "vm");
465 vp
->stack_size
= VM_DEFAULT_STACK_SIZE
;
467 #ifdef VM_ENABLE_PRECISE_STACK_GC_SCAN
468 vp
->stack_base
= (SCM
*)
469 GC_generic_malloc (vp
->stack_size
* sizeof (SCM
), vm_stack_gc_kind
);
471 /* Keep a pointer to VP so that `vm_stack_mark ()' can know what the stack
473 *vp
->stack_base
= PTR2SCM (vp
);
477 vp
->stack_base
= scm_gc_malloc (vp
->stack_size
* sizeof (SCM
),
481 #ifdef VM_ENABLE_STACK_NULLING
482 memset (vp
->stack_base
, 0, vp
->stack_size
* sizeof (SCM
));
484 vp
->stack_limit
= vp
->stack_base
+ vp
->stack_size
;
486 vp
->sp
= vp
->stack_base
- 1;
488 vp
->engine
= SCM_VM_DEBUG_ENGINE
;
489 vp
->options
= SCM_EOL
;
491 for (i
= 0; i
< SCM_VM_NUM_HOOKS
; i
++)
492 vp
->hooks
[i
] = SCM_BOOL_F
;
494 return scm_cell (scm_tc7_vm
, (scm_t_bits
)vp
);
498 #ifdef VM_ENABLE_PRECISE_STACK_GC_SCAN
500 /* Mark the VM stack region between its base and its current top. */
501 static struct GC_ms_entry
*
502 vm_stack_mark (GC_word
*addr
, struct GC_ms_entry
*mark_stack_ptr
,
503 struct GC_ms_entry
*mark_stack_limit
, GC_word env
)
506 const struct scm_vm
*vm
;
508 /* The first word of the VM stack should contain a pointer to the
510 vm
= * ((struct scm_vm
**) addr
);
513 || (SCM
*) addr
!= vm
->stack_base
- 1
514 || vm
->stack_limit
- vm
->stack_base
!= vm
->stack_size
)
515 /* ADDR must be a pointer to a free-list element, which we must ignore
516 (see warning in <gc/gc_mark.h>). */
517 return mark_stack_ptr
;
519 for (word
= (GC_word
*) vm
->stack_base
; word
<= (GC_word
*) vm
->sp
; word
++)
520 mark_stack_ptr
= GC_MARK_AND_PUSH ((* (GC_word
**) word
),
521 mark_stack_ptr
, mark_stack_limit
,
524 return mark_stack_ptr
;
527 #endif /* VM_ENABLE_PRECISE_STACK_GC_SCAN */
531 scm_c_vm_run (SCM vm
, SCM program
, SCM
*argv
, int nargs
)
533 struct scm_vm
*vp
= SCM_VM_DATA (vm
);
534 return vm_engines
[vp
->engine
](vm
, program
, argv
, nargs
);
537 SCM_DEFINE (scm_vm_apply
, "vm-apply", 3, 0, 0,
538 (SCM vm
, SCM program
, SCM args
),
540 #define FUNC_NAME s_scm_vm_apply
545 SCM_VALIDATE_VM (1, vm
);
546 SCM_VALIDATE_PROC (2, program
);
548 nargs
= scm_ilength (args
);
549 if (SCM_UNLIKELY (nargs
< 0))
550 scm_wrong_type_arg_msg (FUNC_NAME
, 3, args
, "list");
552 argv
= alloca(nargs
* sizeof(SCM
));
553 for (i
= 0; i
< nargs
; i
++)
555 argv
[i
] = SCM_CAR (args
);
556 args
= SCM_CDR (args
);
559 return scm_c_vm_run (vm
, program
, argv
, nargs
);
563 /* Scheme interface */
565 SCM_DEFINE (scm_vm_version
, "vm-version", 0, 0, 0,
568 #define FUNC_NAME s_scm_vm_version
570 return scm_from_locale_string (PACKAGE_VERSION
);
574 SCM_DEFINE (scm_the_vm
, "the-vm", 0, 0, 0,
577 #define FUNC_NAME s_scm_the_vm
579 scm_i_thread
*t
= SCM_I_CURRENT_THREAD
;
581 if (SCM_UNLIKELY (scm_is_false ((t
->vm
))))
589 SCM_DEFINE (scm_vm_p
, "vm?", 1, 0, 0,
592 #define FUNC_NAME s_scm_vm_p
594 return scm_from_bool (SCM_VM_P (obj
));
598 SCM_DEFINE (scm_make_vm
, "make-vm", 0, 0, 0,
601 #define FUNC_NAME s_scm_make_vm,
607 SCM_DEFINE (scm_vm_ip
, "vm:ip", 1, 0, 0,
610 #define FUNC_NAME s_scm_vm_ip
612 SCM_VALIDATE_VM (1, vm
);
613 return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm
)->ip
);
617 SCM_DEFINE (scm_vm_sp
, "vm:sp", 1, 0, 0,
620 #define FUNC_NAME s_scm_vm_sp
622 SCM_VALIDATE_VM (1, vm
);
623 return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm
)->sp
);
627 SCM_DEFINE (scm_vm_fp
, "vm:fp", 1, 0, 0,
630 #define FUNC_NAME s_scm_vm_fp
632 SCM_VALIDATE_VM (1, vm
);
633 return scm_from_ulong ((unsigned long) SCM_VM_DATA (vm
)->fp
);
637 #define VM_DEFINE_HOOK(n) \
640 SCM_VALIDATE_VM (1, vm); \
641 vp = SCM_VM_DATA (vm); \
642 if (scm_is_false (vp->hooks[n])) \
643 vp->hooks[n] = scm_make_hook (SCM_I_MAKINUM (1)); \
644 return vp->hooks[n]; \
647 SCM_DEFINE (scm_vm_boot_hook
, "vm-boot-hook", 1, 0, 0,
650 #define FUNC_NAME s_scm_vm_boot_hook
652 VM_DEFINE_HOOK (SCM_VM_BOOT_HOOK
);
656 SCM_DEFINE (scm_vm_halt_hook
, "vm-halt-hook", 1, 0, 0,
659 #define FUNC_NAME s_scm_vm_halt_hook
661 VM_DEFINE_HOOK (SCM_VM_HALT_HOOK
);
665 SCM_DEFINE (scm_vm_next_hook
, "vm-next-hook", 1, 0, 0,
668 #define FUNC_NAME s_scm_vm_next_hook
670 VM_DEFINE_HOOK (SCM_VM_NEXT_HOOK
);
674 SCM_DEFINE (scm_vm_break_hook
, "vm-break-hook", 1, 0, 0,
677 #define FUNC_NAME s_scm_vm_break_hook
679 VM_DEFINE_HOOK (SCM_VM_BREAK_HOOK
);
683 SCM_DEFINE (scm_vm_enter_hook
, "vm-enter-hook", 1, 0, 0,
686 #define FUNC_NAME s_scm_vm_enter_hook
688 VM_DEFINE_HOOK (SCM_VM_ENTER_HOOK
);
692 SCM_DEFINE (scm_vm_apply_hook
, "vm-apply-hook", 1, 0, 0,
695 #define FUNC_NAME s_scm_vm_apply_hook
697 VM_DEFINE_HOOK (SCM_VM_APPLY_HOOK
);
701 SCM_DEFINE (scm_vm_exit_hook
, "vm-exit-hook", 1, 0, 0,
704 #define FUNC_NAME s_scm_vm_exit_hook
706 VM_DEFINE_HOOK (SCM_VM_EXIT_HOOK
);
710 SCM_DEFINE (scm_vm_return_hook
, "vm-return-hook", 1, 0, 0,
713 #define FUNC_NAME s_scm_vm_return_hook
715 VM_DEFINE_HOOK (SCM_VM_RETURN_HOOK
);
719 SCM_DEFINE (scm_vm_option
, "vm-option", 2, 0, 0,
722 #define FUNC_NAME s_scm_vm_option
724 SCM_VALIDATE_VM (1, vm
);
725 return scm_assq_ref (SCM_VM_DATA (vm
)->options
, key
);
729 SCM_DEFINE (scm_set_vm_option_x
, "set-vm-option!", 3, 0, 0,
730 (SCM vm
, SCM key
, SCM val
),
732 #define FUNC_NAME s_scm_set_vm_option_x
734 SCM_VALIDATE_VM (1, vm
);
735 SCM_VM_DATA (vm
)->options
736 = scm_assq_set_x (SCM_VM_DATA (vm
)->options
, key
, val
);
737 return SCM_UNSPECIFIED
;
741 SCM_DEFINE (scm_vm_trace_level
, "vm-trace-level", 1, 0, 0,
744 #define FUNC_NAME s_scm_vm_trace_level
746 SCM_VALIDATE_VM (1, vm
);
747 return scm_from_int (SCM_VM_DATA (vm
)->trace_level
);
751 SCM_DEFINE (scm_set_vm_trace_level_x
, "set-vm-trace-level!", 2, 0, 0,
754 #define FUNC_NAME s_scm_set_vm_trace_level_x
756 SCM_VALIDATE_VM (1, vm
);
757 SCM_VM_DATA (vm
)->trace_level
= scm_to_int (level
);
758 return SCM_UNSPECIFIED
;
767 SCM
scm_load_compiled_with_vm (SCM file
)
769 SCM program
= scm_make_program (scm_load_objcode (file
),
770 SCM_BOOL_F
, SCM_BOOL_F
);
772 return scm_c_vm_run (scm_the_vm (), program
, NULL
, 0);
776 scm_bootstrap_vm (void)
778 scm_c_register_extension ("libguile-" SCM_EFFECTIVE_VERSION
,
780 (scm_t_extension_init_func
)scm_init_vm
, NULL
);
782 sym_vm_run
= scm_from_locale_symbol ("vm-run");
783 sym_vm_error
= scm_from_locale_symbol ("vm-error");
784 sym_keyword_argument_error
= scm_from_locale_symbol ("keyword-argument-error");
785 sym_debug
= scm_from_locale_symbol ("debug");
787 #ifdef VM_ENABLE_PRECISE_STACK_GC_SCAN
789 GC_new_kind (GC_new_free_list (),
790 GC_MAKE_PROC (GC_new_proc (vm_stack_mark
), 0),
799 #ifndef SCM_MAGIC_SNARFER
800 #include "libguile/vm.x"