{
ARGS1 (x);
RETURN (scm_from_bool (scm_is_false (x)));
+ DEAD (x);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (!scm_is_false (x)));
+ DEAD (x);
NEXT;
}
{
ARGS2 (x, y);
RETURN (scm_from_bool (scm_is_eq (x, y)));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
{
ARGS2 (x, y);
RETURN (scm_from_bool (!scm_is_eq (x, y)));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (scm_is_null (x)));
+ DEAD (x);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (!scm_is_null (x)));
+ DEAD (x);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_eqv_p (x, y));
}
+ DEAD (x);
+ DEAD (y);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_equal_p (x, y));
}
+ DEAD (x);
+ DEAD (y);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (scm_is_pair (x)));
+ DEAD (x);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (scm_ilength (x) >= 0));
+ DEAD (x);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (scm_is_symbol (x)));
+ DEAD (x);
NEXT;
}
{
ARGS1 (x);
RETURN (scm_from_bool (SCM_I_IS_VECTOR (x)));
+ DEAD (x);
NEXT;
}
ARGS2 (x, y);
CONS (x, x, y);
RETURN (x);
+ DEAD (x);
+ DEAD (y);
NEXT;
}
ARGS1 (x);
VM_VALIDATE_CONS (x, "car");
RETURN (SCM_CAR (x));
+ DEAD (x);
NEXT;
}
ARGS1 (x);
VM_VALIDATE_CONS (x, "cdr");
RETURN (SCM_CDR (x));
+ DEAD (x);
NEXT;
}
POP2 (y, x);
VM_VALIDATE_CONS (x, "set-car!");
SCM_SETCAR (x, y);
+ DEAD (x);
+ DEAD (y);
NEXT;
}
POP2 (y, x);
VM_VALIDATE_CONS (x, "set-cdr!");
SCM_SETCDR (x, y);
+ DEAD (x);
+ DEAD (y);
NEXT;
}
SYNC_REGISTER (); \
RETURN (srel (x, y)); \
} \
+ DEAD (x); \
+ DEAD (y); \
NEXT; \
}
if (SCM_FIXABLE (n)) \
{ \
RETURN (SCM_I_MAKINUM (n)); \
+ DEAD (x); \
+ DEAD (y); \
NEXT; \
} \
} \
SYNC_REGISTER (); \
RETURN (SFUNC (x, y)); \
+ DEAD (x); \
+ DEAD (y); \
NEXT; \
}
ASM_ADD (x, y);
SYNC_REGISTER ();
RETURN (scm_sum (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
#endif
}
if (SCM_LIKELY (SCM_I_INUMP (result)))
{
RETURN (result);
+ DEAD (result);
NEXT;
}
+ DEAD (result);
}
SYNC_REGISTER ();
RETURN (scm_sum (x, SCM_I_MAKINUM (1)));
+ DEAD (x);
NEXT;
}
ASM_SUB (x, y);
SYNC_REGISTER ();
RETURN (scm_difference (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
#endif
}
if (SCM_LIKELY (SCM_I_INUMP (result)))
{
RETURN (result);
+ DEAD (result);
NEXT;
}
+ DEAD (result);
}
SYNC_REGISTER ();
RETURN (scm_difference (x, SCM_I_MAKINUM (1)));
+ DEAD (x);
NEXT;
}
ARGS2 (x, y);
SYNC_REGISTER ();
RETURN (scm_product (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
ARGS2 (x, y);
SYNC_REGISTER ();
RETURN (scm_divide (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
ARGS2 (x, y);
SYNC_REGISTER ();
RETURN (scm_quotient (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
ARGS2 (x, y);
SYNC_REGISTER ();
RETURN (scm_remainder (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
ARGS2 (x, y);
SYNC_REGISTER ();
RETURN (scm_modulo (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
/* Right shift, will be a fixnum. */
{
RETURN (SCM_I_MAKINUM (SCM_I_INUM (x) >> -SCM_I_INUM (y)));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
else
(SCM_SRS (nn, (SCM_I_FIXNUM_BIT-1 - bits_to_shift)) + 1)
<= 1))
{
+ DEAD (x);
+ DEAD (y);
RETURN (SCM_I_MAKINUM (nn << bits_to_shift));
NEXT;
}
}
SYNC_REGISTER ();
RETURN (scm_ash (x, y));
+ DEAD (x);
+ DEAD (y);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_logand (x, y));
}
+ DEAD (x);
+ DEAD (y);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_logior (x, y));
}
+ DEAD (x);
+ DEAD (y);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_logxor (x, y));
}
+ DEAD (x);
+ DEAD (y);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_vector_ref (vect, idx));
}
+ DEAD (vect);
+ DEAD (idx);
NEXT;
}
SYNC_REGISTER ();
scm_vector_set_x (vect, idx, val);
}
+ DEAD (vect);
+ DEAD (idx);
+ DEAD (val);
NEXT;
}
SYNC_REGISTER ();
PRE_CHECK_UNDERFLOW (len);
ret = scm_from_contiguous_array (shape, sp - len + 1, len);
+ DEAD (shape);
DROPN (len);
PUSH (ret);
+ DEAD (ret);
NEXT;
}
{
ARGS1 (obj);
RETURN (scm_from_bool (SCM_STRUCTP (obj)));
+ DEAD (obj);
NEXT;
}
ARGS1 (obj);
VM_VALIDATE_STRUCT (obj, "struct_vtable");
RETURN (SCM_STRUCT_VTABLE (obj));
+ DEAD (obj);
NEXT;
}
}
else
ret = scm_c_make_structv (vtable, 0, n - 1, (scm_t_bits *) inits);
+ DEAD (vtable);
DROPN (n);
PUSH (ret);
+ DEAD (ret);
NEXT;
}
{
scm_t_bits *data = SCM_STRUCT_DATA (obj);
RETURN (SCM_PACK (data[index]));
+ DEAD (obj);
+ DEAD (pos);
NEXT;
}
}
SYNC_REGISTER ();
RETURN (scm_struct_ref (obj, pos));
+ DEAD (obj);
+ DEAD (pos);
NEXT;
}
{
scm_t_bits *data = SCM_STRUCT_DATA (obj);
data[index] = SCM_UNPACK (val);
+ /* FIXME: Shouldn't be returning anything, right? */
RETURN (val);
+ DEAD (obj);
+ DEAD (pos);
+ DEAD (val);
NEXT;
}
}
SYNC_REGISTER ();
RETURN (scm_struct_set_x (obj, pos, val));
+ DEAD (obj);
+ DEAD (pos);
+ DEAD (val);
NEXT;
}
SYNC_REGISTER ();
RETURN (scm_class_of (obj));
}
+ DEAD (obj);
NEXT;
}
size_t slot;
ARGS2 (instance, idx);
slot = SCM_I_INUM (idx);
+ DEAD (idx);
RETURN (SCM_PACK (SCM_STRUCT_DATA (instance) [slot]));
+ DEAD (instance);
NEXT;
}
size_t slot;
POP3 (val, idx, instance);
slot = SCM_I_INUM (idx);
+ DEAD (idx);
SCM_STRUCT_DATA (instance) [slot] = SCM_UNPACK (val);
+ DEAD (instance);
+ DEAD (val);
NEXT;
}
SCM endianness; \
POP (endianness); \
if (scm_is_eq (endianness, scm_i_native_endianness)) \
- goto VM_LABEL (bv_##stem##_native_ref); \
+ { \
+ DEAD (endianness); \
+ goto VM_LABEL (bv_##stem##_native_ref); \
+ } \
{ \
ARGS2 (bv, idx); \
SYNC_REGISTER (); \
RETURN (scm_bytevector_##fn_stem##_ref (bv, idx, endianness)); \
+ DEAD (bv); \
+ DEAD (idx); \
+ DEAD (endianness); \
NEXT; \
} \
}
SYNC_REGISTER (); \
RETURN (scm_bytevector_ ## fn_stem ## _ref (bv, idx)); \
} \
+ DEAD (bv); \
+ DEAD (idx); \
NEXT; \
}
SYNC_REGISTER (); \
RETURN (scm_bytevector_ ## stem ## _native_ref (bv, idx)); \
} \
+ DEAD (bv); \
+ DEAD (idx); \
NEXT; \
}
RETURN (scm_from_double (*float_ptr)); \
else \
RETURN (scm_bytevector_ ## fn_stem ## _native_ref (bv, idx)); \
+ DEAD (bv); \
+ DEAD (idx); \
NEXT; \
}
SCM endianness; \
POP (endianness); \
if (scm_is_eq (endianness, scm_i_native_endianness)) \
- goto VM_LABEL (bv_##stem##_native_set); \
+ { \
+ DEAD (endianness); \
+ goto VM_LABEL (bv_##stem##_native_set); \
+ } \
{ \
SCM bv, idx, val; POP3 (val, idx, bv); \
SYNC_REGISTER (); \
scm_bytevector_##fn_stem##_set_x (bv, idx, val, endianness); \
+ DEAD (bv); \
+ DEAD (idx); \
+ DEAD (val); \
+ DEAD (endianness); \
NEXT; \
} \
}
SYNC_REGISTER (); \
scm_bytevector_ ## fn_stem ## _set_x (bv, idx, val); \
} \
+ DEAD (bv); \
+ DEAD (idx); \
+ DEAD (val); \
NEXT; \
}
SYNC_REGISTER (); \
scm_bytevector_ ## stem ## _native_set_x (bv, idx, val); \
} \
+ DEAD (bv); \
+ DEAD (idx); \
+ DEAD (val); \
NEXT; \
}
SYNC_REGISTER (); \
scm_bytevector_ ## fn_stem ## _native_set_x (bv, idx, val); \
} \
+ DEAD (bv); \
+ DEAD (idx); \
+ DEAD (val); \
NEXT; \
}
{
SCM x = *sp;
PUSH (x);
+ DEAD (x);
NEXT;
}
memcpy (SCM_I_VECTOR_WELTS(vect), sp, sizeof(SCM) * len);
NULLSTACK (len);
*sp = vect;
+ DEAD (vect);
NEXT;
}
{
SCM o = VARIABLE_REF (x);
*sp = o;
+ DEAD (o);
}
NEXT;
}
else
*sp = scm_from_bool (VARIABLE_BOUNDP (x));
+ DEAD (x);
NEXT;
}
VM_DEFINE_INSTRUCTION (27, toplevel_ref, "toplevel-ref", 1, 0, 1)
{
unsigned objnum = FETCH ();
- SCM what, resolved;
+ SCM what;
CHECK_OBJECT (objnum);
what = OBJECT_REF (objnum);
if (!SCM_VARIABLEP (what))
{
+ SCM resolved;
SYNC_REGISTER ();
resolved = resolve_variable (what, scm_program_module (program));
if (!VARIABLE_BOUNDP (resolved))
goto vm_error_unbound;
}
what = resolved;
+ DEAD (resolved);
OBJECT_SET (objnum, what);
}
PUSH (VARIABLE_REF (what));
+ DEAD (what);
NEXT;
}
VM_DEFINE_INSTRUCTION (28, long_toplevel_ref, "long-toplevel-ref", 2, 0, 1)
{
- SCM what, resolved;
+ SCM what;
unsigned int objnum = FETCH ();
objnum <<= 8;
objnum += FETCH ();
if (!SCM_VARIABLEP (what))
{
+ SCM resolved;
SYNC_REGISTER ();
resolved = resolve_variable (what, scm_program_module (program));
if (!VARIABLE_BOUNDP (resolved))
goto vm_error_unbound;
}
what = resolved;
+ DEAD (resolved);
OBJECT_SET (objnum, what);
}
PUSH (VARIABLE_REF (what));
+ DEAD (what);
NEXT;
}
SCM x;
POP (x);
LOCAL_SET (FETCH (), x);
+ DEAD (x);
NEXT;
}
i += FETCH ();
POP (x);
LOCAL_SET (i, x);
+ DEAD (x);
NEXT;
}
}
VARIABLE_SET (what, *sp);
+ DEAD (what);
DROP ();
NEXT;
}
}
VARIABLE_SET (what, *sp);
+ DEAD (what);
DROP ();
NEXT;
}
ip += offset; \
if (offset < 0) \
VM_HANDLE_INTERRUPTS; \
- NEXT; \
}
VM_DEFINE_INSTRUCTION (34, br, "br", 3, 0, 0)
SCM x;
POP (x);
BR (scm_is_true (x));
+ DEAD (x);
+ NEXT;
}
VM_DEFINE_INSTRUCTION (36, br_if_not, "br-if-not", 3, 0, 0)
SCM x;
POP (x);
BR (scm_is_false (x));
+ DEAD (x);
+ NEXT;
}
VM_DEFINE_INSTRUCTION (37, br_if_eq, "br-if-eq", 3, 0, 0)
SCM x, y;
POP2 (y, x);
BR (scm_is_eq (x, y));
+ DEAD (x);
+ DEAD (y);
+ NEXT;
}
VM_DEFINE_INSTRUCTION (38, br_if_not_eq, "br-if-not-eq", 3, 0, 0)
SCM x, y;
POP2 (y, x);
BR (!scm_is_eq (x, y));
+ DEAD (x);
+ DEAD (y);
+ NEXT;
}
VM_DEFINE_INSTRUCTION (39, br_if_null, "br-if-null", 3, 0, 0)
SCM x;
POP (x);
BR (scm_is_null (x));
+ DEAD (x);
+ NEXT;
}
VM_DEFINE_INSTRUCTION (40, br_if_not_null, "br-if-not-null", 3, 0, 0)
SCM x;
POP (x);
BR (!scm_is_null (x));
+ DEAD (x);
+ NEXT;
}
\f
goto vm_error_kwargs_invalid_keyword;
}
+ DEAD (kw);
+
NEXT;
}
/* No need to check for underflow. */
CONS (rest, *sp--, rest);
PUSH (rest);
+ DEAD (rest);
NEXT;
}
/* No need to check for underflow. */
CONS (rest, *sp--, rest);
LOCAL_SET (i, rest);
+ DEAD (rest);
NEXT;
}
abort ();
}
+ DEAD (pointer);
NULLSTACK_FOR_NONLOCAL_EXIT ();
if (SCM_UNLIKELY (SCM_VALUESP (ret)))
ret = scm_struct_ref (ret, SCM_INUM0);
nvalues = scm_ilength (ret);
PUSH_LIST (ret, scm_is_null);
+ DEAD (ret);
goto vm_return_values;
}
else
{
PUSH (ret);
+ DEAD (ret);
goto vm_return;
}
}
abort ();
}
+ DEAD (smob);
NULLSTACK_FOR_NONLOCAL_EXIT ();
if (SCM_UNLIKELY (SCM_VALUESP (ret)))
ret = scm_struct_ref (ret, SCM_INUM0);
nvalues = scm_ilength (ret);
PUSH_LIST (ret, scm_is_null);
+ DEAD (ret);
goto vm_return_values;
}
else
{
PUSH (ret);
+ DEAD (ret);
goto vm_return;
}
}
ret = scm_i_foreign_call (foreign, sp - nargs + 1);
+ DEAD (foreign);
NULLSTACK_FOR_NONLOCAL_EXIT ();
if (SCM_UNLIKELY (SCM_VALUESP (ret)))
ret = scm_struct_ref (ret, SCM_INUM0);
nvalues = scm_ilength (ret);
PUSH_LIST (ret, scm_is_null);
+ DEAD (ret);
goto vm_return_values;
}
else
{
PUSH (ret);
+ DEAD (ret);
goto vm_return;
}
}
sp - (fp - 1), fp);
scm_i_reinstate_continuation (contregs);
- /* no NEXT */
+ /* no DEAD, no NEXT */
abort ();
}
POP2 (intwinds, vmcont);
SYNC_REGISTER ();
if (SCM_UNLIKELY (!SCM_VM_CONT_REWINDABLE_P (vmcont)))
- { finish_args = vmcont;
+ {
+ finish_args = vmcont;
goto vm_error_continuation_not_rewindable;
}
prevwinds = scm_i_dynwinds ();
vm_reinstate_partial_continuation (vm, vmcont, intwinds, sp + 1 - fp, fp,
vm_cookie);
+ DEAD (vmcont);
+ DEAD (intwinds);
/* Rewind prompt jmpbuffers, if any. */
{
for (; !scm_is_eq (winds, prevwinds); winds = scm_cdr (winds))
if (SCM_PROMPT_P (scm_car (winds)) && SCM_PROMPT_SETJMP (scm_car (winds)))
break;
+ DEAD (winds);
}
+ DEAD (prevwinds);
CACHE_REGISTER ();
program = SCM_FRAME_PROGRAM (fp);
SCM x;
POP (x);
nargs = scm_to_int (x);
+ DEAD (x);
/* FIXME: should truncate values? */
goto vm_tail_call;
}
SCM x;
POP (x);
nargs = scm_to_int (x);
+ DEAD (x);
/* FIXME: should truncate values? */
goto vm_call;
}
}
PUSH_LIST (ls, SCM_NULL_OR_NIL_P);
+ DEAD (ls);
nargs += len - 2;
goto vm_call;
}
PUSH_LIST (ls, SCM_NULL_OR_NIL_P);
+ DEAD (ls);
nargs += len - 2;
goto vm_tail_call;
SYNC_ALL ();
vm_cont = scm_i_vm_capture_stack (vp->stack_base, fp, sp, ip, NULL, 0);
cont = scm_i_make_continuation (&first, vm, vm_cont);
+ DEAD (vm_cont);
if (first)
{
PUSH (SCM_PACK (0)); /* dynamic link */
PUSH (SCM_PACK (0)); /* mvra */
PUSH (SCM_PACK (0)); /* ra */
PUSH (proc);
+ DEAD (proc);
PUSH (cont);
+ DEAD (cont);
nargs = 1;
goto vm_call;
}
So, pull our regs back down from the vp, and march on to the
next instruction. */
+ DEAD (proc);
+ DEAD (cont);
CACHE_REGISTER ();
program = SCM_FRAME_PROGRAM (fp);
CACHE_PROGRAM ();
SCM_FRAME_MV_RETURN_ADDRESS (fp),
0);
cont = scm_i_make_continuation (&first, vm, vm_cont);
+ DEAD (vm_cont);
if (first)
{
PUSH (proc);
+ DEAD (proc);
PUSH (cont);
+ DEAD (cont);
nargs = 1;
goto vm_tail_call;
}
else
{
+ DEAD (proc);
+ DEAD (cont);
/* Otherwise, cache regs and NEXT, as above. Invoking the continuation
does a return from the frame, either to the RA or
MVRA. */
/* Set return value (sp is already pushed) */
*sp = ret;
+
+ DEAD (ret);
}
/* Restore the last program */
goto vm_error_improper_list;
}
+ DEAD (l);
goto vm_return_values;
}
SCM n;
POP (n);
nvalues = scm_to_int (n);
+ DEAD (n);
ASSERT (nvalues >= 0);
goto vm_return_values;
}
int nbinds, rest;
POP (x);
nvalues = scm_to_int (x);
+ DEAD (x);
nbinds = FETCH ();
rest = FETCH ();
POP (val);
SYNC_BEFORE_GC ();
LOCAL_SET (FETCH (), scm_cell (scm_tc7_variable, SCM_UNPACK (val)));
+ DEAD (val);
NEXT;
}
SCM v = LOCAL_REF (FETCH ());
ASSERT_BOUND_VARIABLE (v);
PUSH (VARIABLE_REF (v));
+ DEAD (v);
NEXT;
}
POP (val);
ASSERT_VARIABLE (v);
VARIABLE_SET (v, val);
+ DEAD (v);
+ DEAD (val);
NEXT;
}
v = FREE_VARIABLE_REF (idx);
ASSERT_BOUND_VARIABLE (v);
PUSH (VARIABLE_REF (v));
+ DEAD (v);
NEXT;
}
v = FREE_VARIABLE_REF (idx);
ASSERT_BOUND_VARIABLE (v);
VARIABLE_SET (v, val);
+ DEAD (v);
+ DEAD (val);
NEXT;
}
sp[-len] = closure;
for (n = 0; n < len; n++)
SCM_PROGRAM_FREE_VARIABLE_SET (closure, n, sp[-len + 1 + n]);
+ DEAD (closure);
DROPN (len);
NEXT;
}
len = SCM_PROGRAM_NUM_FREE_VARIABLES (x);
for (n = 0; n < len; n++)
SCM_PROGRAM_FREE_VARIABLE_SET (x, n, sp[-len + 1 + n]);
+ DEAD (x);
DROPN (len);
NEXT;
}
VARIABLE_SET (scm_sym2var (sym, scm_current_module_lookup_closure (),
SCM_BOOL_T),
val);
+ DEAD (sym);
+ DEAD (val);
NEXT;
}
vm_engine that can be assigned *has* been assigned. So we need to pull
all our state back from the ip/fp/sp.
*/
+ DEAD (k);
+ DEAD (prompt);
CACHE_REGISTER ();
program = SCM_FRAME_PROGRAM (fp);
CACHE_PROGRAM ();
NEXT;
}
+ DEAD (k);
+ DEAD (prompt);
+
/* Otherwise setjmp returned for the first time, so we go to execute the
prompt's body. */
NEXT;
goto vm_error_not_a_thunk;
}
scm_i_set_dynwinds (scm_cons (scm_cons (wind, unwind), scm_i_dynwinds ()));
+ DEAD (wind);
+ DEAD (unwind);
NEXT;
}
scm_i_swap_with_fluids (wf, current_thread->dynamic_state);
scm_i_set_dynwinds (scm_cons (wf, scm_i_dynwinds ()));
+ DEAD (wf);
NEXT;
}
wf = scm_car (scm_i_dynwinds ());
scm_i_set_dynwinds (scm_cdr (scm_i_dynwinds ()));
scm_i_swap_with_fluids (wf, current_thread->dynamic_state);
+ DEAD (wf);
NEXT;
}
|| ((num = SCM_I_FLUID_NUM (*sp)) >= SCM_SIMPLE_VECTOR_LENGTH (fluids)))
{
/* Punt dynstate expansion and error handling to the C proc. */
+ DEAD (fluids);
SYNC_REGISTER ();
*sp = scm_fluid_ref (*sp);
}
else
{
SCM val = SCM_SIMPLE_VECTOR_REF (fluids, num);
+ DEAD (fluids);
if (scm_is_eq (val, SCM_UNDEFINED))
val = SCM_I_FLUID_DEFAULT (*sp);
if (SCM_UNLIKELY (scm_is_eq (val, SCM_UNDEFINED)))
}
else
SCM_SIMPLE_VECTOR_SET (fluids, num, val);
-
+ DEAD (fluids);
+ DEAD (fluid);
+ DEAD (val);
NEXT;
}