mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-04-30 03:40:34 +02:00
0007507340
Adapt VM stack to grow downward. This will make native compilation look more like the VM code, as we will be able to use native CALL instructions, taking proper advantage of the return address buffer. * libguile/continuations.c (scm_i_continuation_to_frame): Record offsets from stack top. * libguile/control.c (scm_i_prompt_pop_abort_args_x): Adapt for reversed order of arguments, and instead of relying on the abort to push on the number of arguments, make the caller save the stack depth, which allows us to compute the number of arguments ourselves. (reify_partial_continuation, scm_c_abort): Adapt to reversed stack order. * libguile/dynstack.c (scm_dynstack_wind_prompt): Since we wind the stack in a downward direction, subtract the reloc instead of adding it. * libguile/dynstack.h (SCM_F_DYNSTACK_PROMPT_ESCAPE_ONLY): Remove flag; instead rely on prompt-establishing code to save the stack depth. * libguile/eval.c (eval): Remove extraneous "volatile" declarations for variables that are not re-set between the setjmp and any longjmp. Adapt to save stack depth before instating the prompt. * libguile/foreign.c (scm_i_foreign_call): Adapt to receive arguments in reverse order. * libguile/frames.c (frame_stack_top, scm_i_frame_stack_top): Adapt to compute stack top instead of stack bottom. (scm_c_frame_closure): Adapt to stack growth change. (scm_frame_num_locals, scm_frame_local_ref, scm_frame_set_x): Use union data type to access stack. (RELOC): Reformat. (scm_c_frame_previous): Adapt to stack growth change. * libguile/frames.h: Adapt stack diagram to indicate that the stack grows up. (union scm_vm_stack_element): New data type used to access items on the stack. (SCM_FRAME_PREVIOUS_SP) (SCM_FRAME_RETURN_ADDRESS, SCM_FRAME_SET_RETURN_ADDRESS) (SCM_FRAME_DYNAMIC_LINK, SCM_FRAME_SET_DYNAMIC_LINK) (SCM_FRAME_LOCAL, SCM_FRAME_NUM_LOCALS): Adapt to stack representation change. (SCM_FRAME_SLOT): New helper. (SCM_VM_FRAME_FP, SCM_VM_FRAME_SP): Adapt to stack growth change. * libguile/stacks.c (scm_make_stack): Record offsets from top of stack. * libguile/throw.c (catch): Adapt to scm_i_prompt_pop_abort_args_x change. * libguile/vm-engine.c (ALLOC_FRAME, RESET_FRAME): (FRAME_LOCALS_COUNT_FROM): Adapt to stack growth change. (LOCAL_ADDRESS): Use SCM_FRAME_SLOT to get the address as the proper data type. (RETURN_ONE_VALUE, RETURN_VALUE_LIST): Adapt to stack growth change. (apply): Shuffling up the SMOB apply args can cause the stack to expand, so use ALLOC_FRAME instead of RESET_FRAME. (vm_engine): Adapt for stack growth change. * libguile/vm.c (vm_increase_sp, vm_push_sp, vm_restore_sp): Adapt to stack representation change. (scm_i_vm_cont_to_frame): Adapt to take offsets from the top. (scm_i_vm_capture_stack): Adapt to capture from the top. (vm_return_to_continuation_inner): Adapt for data type changes. (vm_return_to_continuation): Likewise, and instead of looping, just splat the saved arguments on with memcpy. (vm_dispatch_hook): Adapt to receive arguments in the reverse order. Adapt callers. (vm_abort): There is never a tail argument. Adapt to stack representation change. (vm_reinstate_partial_continuation) (vm_reinstate_partial_continuation_inner): Adapt to stack growth change. (allocate_stack, free_stack): Adapt to data type change. (expand_stack): Don't try to mremap(), as you can't grow a mapping from the bottom. Without knowing that there's a free mapping space right below the old stack, which there usually isn't on Linux, we have to copy. We can't use MAP_GROWSDOWN because Linux is buggy. (make_vm): Adapt to stack representation changes. (return_unused_stack_to_os): Round down instead of up, as the stack grows down. (scm_i_vm_mark_stack): Adapt to walk up the stack. (scm_i_vm_free_stack): Adapt to scm_vm changes. (vm_expand_stack_inner, reset_stack_limit, vm_expand_stack): Adapt to the stack growing down. (scm_call_n): Adapt to the stack growing down. Don't allow argv to point into the stack. * libguile/vm.h (struct scm_vm, struct scm_vm_cont): Adapt to hold the stack top and bottom.
112 lines
4 KiB
C
112 lines
4 KiB
C
#ifndef SCM_FOREIGN_H
|
||
#define SCM_FOREIGN_H
|
||
|
||
/* Copyright (C) 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public License
|
||
* as published by the Free Software Foundation; either version 3 of
|
||
* the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful, but
|
||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* Lesser General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU Lesser General Public
|
||
* License along with this library; if not, write to the Free Software
|
||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
||
* 02110-1301 USA
|
||
*/
|
||
|
||
#include "libguile/__scm.h"
|
||
|
||
/* A "foreign pointer" is a wrapped C pointer. It is represented by a
|
||
cell whose second word is a pointer. The first word has the
|
||
`scm_tc7_pointer' type code.
|
||
|
||
The basic idea is that we can help the programmer to avoid cutting herself,
|
||
but we won't take away her knives. */
|
||
|
||
enum scm_t_foreign_type
|
||
{
|
||
SCM_FOREIGN_TYPE_VOID,
|
||
SCM_FOREIGN_TYPE_FLOAT,
|
||
SCM_FOREIGN_TYPE_DOUBLE,
|
||
SCM_FOREIGN_TYPE_UINT8,
|
||
SCM_FOREIGN_TYPE_INT8,
|
||
SCM_FOREIGN_TYPE_UINT16,
|
||
SCM_FOREIGN_TYPE_INT16,
|
||
SCM_FOREIGN_TYPE_UINT32,
|
||
SCM_FOREIGN_TYPE_INT32,
|
||
SCM_FOREIGN_TYPE_UINT64,
|
||
SCM_FOREIGN_TYPE_INT64,
|
||
SCM_FOREIGN_TYPE_LAST = SCM_FOREIGN_TYPE_INT64
|
||
};
|
||
|
||
typedef enum scm_t_foreign_type scm_t_foreign_type;
|
||
|
||
typedef void (*scm_t_pointer_finalizer) (void *);
|
||
|
||
#define SCM_POINTER_P(x) (SCM_HAS_TYP7 (x, scm_tc7_pointer))
|
||
#define SCM_VALIDATE_POINTER(pos, x) \
|
||
SCM_MAKE_VALIDATE (pos, x, POINTER_P)
|
||
#define SCM_POINTER_VALUE(x) \
|
||
((void *) SCM_CELL_WORD_1 (x))
|
||
|
||
SCM_API void *scm_to_pointer (SCM pointer);
|
||
SCM_API SCM scm_from_pointer (void *, scm_t_pointer_finalizer);
|
||
|
||
SCM_API SCM scm_alignof (SCM type);
|
||
SCM_API SCM scm_sizeof (SCM type);
|
||
SCM_API SCM scm_pointer_address (SCM pointer);
|
||
SCM_API SCM scm_pointer_to_scm (SCM pointer);
|
||
SCM_API SCM scm_scm_to_pointer (SCM scm);
|
||
SCM_API SCM scm_pointer_to_bytevector (SCM pointer, SCM type,
|
||
SCM offset, SCM len);
|
||
SCM_API SCM scm_set_pointer_finalizer_x (SCM pointer, SCM finalizer);
|
||
SCM_API SCM scm_bytevector_to_pointer (SCM bv, SCM offset);
|
||
|
||
SCM_INTERNAL SCM scm_pointer_p (SCM obj);
|
||
SCM_INTERNAL SCM scm_make_pointer (SCM address, SCM finalizer);
|
||
SCM_INTERNAL void scm_i_pointer_print (SCM pointer, SCM port,
|
||
scm_print_state *pstate);
|
||
|
||
SCM_INTERNAL SCM scm_dereference_pointer (SCM pointer);
|
||
SCM_INTERNAL SCM scm_string_to_pointer (SCM string, SCM encoding);
|
||
SCM_INTERNAL SCM scm_pointer_to_string (SCM pointer, SCM length, SCM encoding);
|
||
|
||
|
||
|
||
/* Foreign functions */
|
||
|
||
/* The goal is to make it so that calling a foreign function doesn't cause any
|
||
heap allocation. That means we need native Scheme formats for all kinds of
|
||
arguments.
|
||
|
||
For "value" types like s64 or f32, we just use native Scheme value types.
|
||
(Note that in both these cases, allocation is possible / likely, as the
|
||
value might need to be boxed, but perhaps we won't worry about that. Hmm.)
|
||
|
||
For everything else, we use foreign pointers. This includes arrays, pointer
|
||
arguments and return vals, struct args and return vals, and out and in/out
|
||
arguments.
|
||
*/
|
||
|
||
union scm_vm_stack_element;
|
||
|
||
SCM_API SCM scm_pointer_to_procedure (SCM return_type, SCM func_ptr,
|
||
SCM arg_types);
|
||
SCM_API SCM scm_procedure_to_pointer (SCM return_type, SCM func_ptr,
|
||
SCM arg_types);
|
||
SCM_INTERNAL SCM scm_i_foreign_call (SCM foreign,
|
||
const union scm_vm_stack_element *argv);
|
||
SCM_INTERNAL int scm_i_foreign_arity (SCM foreign,
|
||
int *req, int *opt, int *rest);
|
||
|
||
|
||
|
||
SCM_INTERNAL void scm_register_foreign (void);
|
||
|
||
|
||
#endif /* SCM_FOREIGN_H */
|