+/*
+ * very-low-level utilities for runtime support
+ */
+
+/*
+ * This software is part of the SBCL system. See the README file for
+ * more information.
+ *
+ * This software is derived from the CMU CL system, which was
+ * written at Carnegie Mellon University and released into the
+ * public domain. The software is in the public domain and is
+ * provided with absolutely no warranty. See the COPYING and CREDITS
+ * files for more information.
+ */
+\f
#include "sbcl.h"
#include "lispregs.h"
#include "globals.h"
#include "genesis/fdefn.h"
#include "genesis/closure.h"
+#include "genesis/funcallable-instance.h"
+#include "genesis/return-pc.h"
#include "genesis/simple-fun.h"
#include "genesis/static-symbols.h"
li reg_ALLOC, 1
.set reorder
- /* Mark us as in Lisp land. */
- sw zero, foreign_function_call_active
-
/* Load the allocation pointer, preserving the low-bit of alloc */
lw reg_BSP, dynamic_space_free_pointer
addu reg_ALLOC, reg_BSP
.set noreorder
bgez reg_NL4, 1f
subu reg_ALLOC, 1
- break 0x10
+ break 0x0, 0x10
1: .set reorder
/* Pass in args */
lw reg_A5, 20(reg_CFP)
/* Calculate LRA */
- la reg_LRA, lra + OTHER_POINTER_LOWTAG
+ la reg_LRA, lra - RETURN_PC_RETURN_POINT_OFFSET
/* Indirect closure */
- lw reg_CODE, -1(reg_LEXENV)
+ lw reg_CODE, CLOSURE_FUN_OFFSET(reg_LEXENV)
+
+ addu reg_LIP, reg_CODE, SIMPLE_FUN_CODE_OFFSET
+
+ /* Mark us as in Lisp land. */
+ sw zero, foreign_function_call_active
/* Jump into lisp land. */
- addu reg_LIP, reg_CODE, 6*4 - FUN_POINTER_LOWTAG
jr reg_LIP
- .set noreorder
.align 3
-#ifdef irix
- /* This particular KLUDGE is kept here as a reminder; for more
- details, see irix-asm-munge.c from CMUCL's lisp directory.
- Other examples have been deleted from later in the file in the
- hope that they will not be needed. */
-.globl mipsmungelra /* for our munging afterwards in irix-asm-munge */
-mipsmungelra:
-#endif
-lra:
- .word RETURN_PC_HEADER_WIDETAG
+ .set noreorder
+lra: .word RETURN_PC_HEADER_WIDETAG
/* Multiple value return spot, clear stack. */
move reg_CSP, reg_OCFP
- nop
+ nop
/* Single value return spot. */
- /* Pass one return value back to C land. */
- move v0, reg_A0 # reg_CFUNC
-
/* Nested lisp -> C calls may have clobbered gp. */
lw gp, framesize-16(sp)
addu reg_ALLOC, 1
.set reorder
+ /* Mark us as in C land. */
+ sw reg_CSP, foreign_function_call_active
+
/* Save LISP state. */
subu reg_NL0, reg_ALLOC, 1
sw reg_NL0, dynamic_space_free_pointer
sw reg_CSP, current_control_stack_pointer
sw reg_CFP, current_control_frame_pointer
- /* Mark us as in C land. */
- sw reg_CSP, foreign_function_call_active
-
/* Check for interrupt */
.set noreorder
bgez reg_NL4, 1f
subu reg_ALLOC, 1
- break 0x10
+ break 0x0, 0x10
1: .set reorder
+ /* Pass one return value back to C land. For a 64bit value, we may
+ need to clobber v1 aka reg_NL4. */
+ move v0, reg_A0 # reg_CFUNC
+ move v1, reg_A1 # reg_NL4
+
/* Restore C regs */
lw ra, framesize-8(sp)
lw s8, framesize-12(sp)
* Transfering control from Lisp into C
*/
NESTED(call_into_c, 0, ra)
- /* The stack frame was already set up from lisp. We have
- to fake the correct gp value for this function, though. */
+ /* The C stack frame was already set up from lisp, and the
+ argument registers as well. We have to fake the correct
+ gp value for this function, though. */
.set noreorder
+ /* reg_NL3 is AT. */
.set noat
lui gp, %hi(_gp_disp)
addiu gp, %lo(_gp_disp)
.set at
.set reorder
+ /* Setup the lisp stack. */
move reg_OCFP, reg_CFP
move reg_CFP, reg_CSP
addu reg_CSP, reg_CFP, 32
- subu reg_LIP, reg_CODE
- addu reg_LIP, OTHER_POINTER_LOWTAG
- sw reg_LIP, (reg_CFP)
- sw reg_CODE, 4(reg_CFP)
- sw gp, 8(reg_CFP)
-
/* Set the pseudo-atomic flag. */
.set noreorder
li reg_NL4, 0
addu reg_ALLOC, 1
.set reorder
+ /* Mark us as in C land. */
+ sw reg_CSP, foreign_function_call_active
+
+ /* Convert the return address to an offset and save it on the stack. */
+ subu reg_NFP, reg_LIP, reg_CODE
+ addu reg_NFP, OTHER_POINTER_LOWTAG
+ sw reg_LRA, (reg_CFP)
+ sw reg_CODE, 4(reg_CFP)
+ sw gp, 8(reg_CFP)
+
/* Save LISP state. */
subu reg_A0, reg_ALLOC, 1
sw reg_A0, dynamic_space_free_pointer
sw reg_CSP, current_control_stack_pointer
sw reg_CFP, current_control_frame_pointer
- /* Mark us as in C land. */
- sw reg_CSP, foreign_function_call_active
-
/* Check for interrupt */
.set noreorder
bgez reg_NL4, 1f
subu reg_ALLOC, 1
- break 0x10
+ break 0x0, 0x10
1: .set reorder
/* Into C land we go. */
- move t9, reg_CFUNC
+ move t9, reg_CFUNC # reg_ALLOC
jalr t9
- lw gp, 8(reg_CFP)
-
- li reg_NIL, NIL
+ lw gp, 8(reg_CFP)
- /* Clear unsaved boxed descriptor regs */
+ /* Pass 64bit return value to lisp land. */
+ move reg_NL0, v0 # reg_CFUNC
+ move reg_NL1, v1 # reg_NL4
+
+ /*
+ * Clear boxed descriptor registers before allowing an interrupt.
+ * We can't rely on C saving some of those registers, they might
+ * have been GCed in the meanwhile.
+ */
li reg_A0, 0 # t0
li reg_A1, 0 # t1
li reg_A2, 0 # t2
li reg_A5, 0 # t5
li reg_FDEFN, 0 # t6
li reg_LEXENV, 0 # t7
+ /*
+ * reg_NFP and reg_OCFP are pointing to fixed locations and are
+ * preserved by C.
+ */
+ li reg_LRA, 0 # s2
+ li reg_L0, 0 # s3
li reg_L1, 0 # t8
+ li reg_CODE, 0 # s8
+ li reg_LIP, 0 # ra
/* Turn on pseudo-atomic. */
.set noreorder
li reg_ALLOC, 1
.set reorder
- /* Mark us as in Lisp land. */
- sw zero, foreign_function_call_active
-
/* Load the allocation pointer, preserving the low-bit of alloc */
lw reg_BSP, dynamic_space_free_pointer
addu reg_ALLOC, reg_BSP
lw reg_BSP, current_binding_stack_pointer
/* Restore LRA & CODE */
- lw reg_LIP, (reg_CFP)
+ lw reg_LRA, (reg_CFP)
lw reg_CODE, 4(reg_CFP)
- subu reg_LIP, OTHER_POINTER_LOWTAG
+ subu reg_LIP, reg_NFP, OTHER_POINTER_LOWTAG
addu reg_LIP, reg_CODE
/* Check for interrupt */
.set noreorder
bgez reg_NL4, 1f
subu reg_ALLOC, 1
- break 0x10
+ break 0x0, 0x10
1: .set reorder
/* Reset the lisp stack. */
move reg_CSP, reg_CFP
move reg_CFP, reg_OCFP
+ /* Mark us as in Lisp land. */
+ sw zero, foreign_function_call_active
+
/* Return to LISP. */
jr reg_LIP
END(call_into_c)
- EXPORT(start_of_tramps)
-
/*
+ * Trampolines follow the Lisp calling convention.
+ *
* The undefined-function trampoline.
*/
+ .align 3 /* minimum alignment for a lisp object */
+ .word SIMPLE_FUN_HEADER_WIDETAG /* header */
+ .word undefined_tramp - SIMPLE_FUN_CODE_OFFSET /* self */
+ .word NIL /* next */
+ .word NIL /* name */
+ .word NIL /* arglist */
+ .word NIL /* type */
LEAF(undefined_tramp)
- break 10
- .byte 4
- .byte UNDEFINED_FUN_ERROR
- .byte 254
- .byte (0xc0 + sc_DescriptorReg)
- .byte 1
+ /* Point reg_CODE to the header and tag it as function, since
+ the debugger regards a function pointer in reg_CODE which
+ doesn't point to a code object as undefined function. */
+ lui reg_CODE, %hi(undefined_tramp)
+ addiu reg_CODE, %lo(undefined_tramp)
+ addiu reg_CODE, - 24 + FUN_POINTER_LOWTAG
+ .set noreorder
+ b 1f
+ break 0x0, trap_Cerror
+ /* Error data length. */
+ .byte 4
+ /* Error number. */
+ .byte UNDEFINED_FUN_ERROR
+ /* Magic value 254 means a 16bit little endian value follows.
+ See debug-var-io.lisp. */
+ .byte 254
+ /* reg_FDEFN is #14. */
+ .byte ((14 << 5) + sc_DescriptorReg) % 0x100
+ .byte ((14 << 5) + sc_DescriptorReg) / 0x100
.align 2
+ .set reorder
+1: lw reg_CODE, FDEFN_FUN_OFFSET(reg_FDEFN)
+ lw reg_LIP, SIMPLE_FUN_CODE_OFFSET(reg_CODE)
+ jr reg_LIP
END(undefined_tramp)
/*
* The closure trampoline.
*/
+ .align 5 /* common MIPS cacheline size */
+ .word 0 /* pad 1 */
+ .word 0 /* pad 2 */
+ .word SIMPLE_FUN_HEADER_WIDETAG /* header */
+ .word closure_tramp - SIMPLE_FUN_CODE_OFFSET /* self */
+ .word NIL /* next */
+ .word NIL /* name */
+ .word NIL /* arglist */
+ .word NIL /* type */
LEAF(closure_tramp)
lw reg_LEXENV, FDEFN_FUN_OFFSET(reg_FDEFN)
- lw reg_L0, CLOSURE_FUN_OFFSET(reg_LEXENV)
- addu reg_LIP, reg_L0, SIMPLE_FUN_CODE_OFFSET
+ lw reg_CODE, CLOSURE_FUN_OFFSET(reg_LEXENV)
+ addu reg_LIP, reg_CODE, SIMPLE_FUN_CODE_OFFSET
jr reg_LIP
END(closure_tramp)
- EXPORT(end_of_tramps)
+/*
+ * The trampoline for funcallable instances
+ */
+ .globl funcallable_instance_tramp
+ .align 3
+ .word SIMPLE_FUN_HEADER_WIDETAG
+funcallable_instance_tramp = . + 1
+ .word funcallable_instance_tramp
+ .word NIL
+ .word NIL
+ .word NIL
+ .word NIL
+
+ lw reg_LEXENV, FUNCALLABLE_INSTANCE_FUNCTION_OFFSET(reg_LEXENV)
+ lw reg_CODE, CLOSURE_FUN_OFFSET(reg_LEXENV)
+ addu reg_LIP, reg_CODE, SIMPLE_FUN_CODE_OFFSET
+ jr reg_LIP
+ nop
/*
- * Function-end breakpoint magic.
+ * Function-end breakpoint magic. This is truely magic, the code is
+ * copied and has to be relocatable. It also needs a properly aligned
+ * header tag after the fun_end_breakpoint_guts symbol.
*/
+ .align 3 /* minimum alignment for a lisp object */
LEAF(fun_end_breakpoint_guts)
- .set noreorder
- .align 3
- .word RETURN_PC_HEADER_WIDETAG
-
- b multiple_value_return
+ .set noreorder
+ .word RETURN_PC_HEADER_WIDETAG
+ b multiple_value_return
nop
+ .set reorder
+
+ /* single value return */
move reg_OCFP, reg_CSP
addu reg_CSP, 4
multiple_value_return:
FEXPORT(fun_end_breakpoint_trap)
- break trap_FunEndBreakpoint
-1: b 1b
- nop
-
+ break 0x0, trap_FunEndBreakpoint
+ b multiple_value_return
EXPORT(fun_end_breakpoint_end)
- .set reorder
END(fun_end_breakpoint_guts)
projects / sbcl.git / blobdiff