+/*
+ * 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/return-pc.h"
+#include "genesis/funcallable-instance.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 - RETURN_PC_RETURN_POINT_OFFSET
+ la reg_LRA, lra + OTHER_POINTER_LOWTAG
/* Indirect closure */
lw reg_CODE, CLOSURE_FUN_OFFSET(reg_LEXENV)
- /* Jump into lisp land. */
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. */
jr reg_LIP
- .align 2
+ .align 3
.set noreorder
lra: .word RETURN_PC_HEADER_WIDETAG
/* Nested lisp -> C calls may have clobbered gp. */
lw gp, framesize-16(sp)
+ /* Mark us as in C land. */
+ sw reg_CSP, foreign_function_call_active
+
/* Set the pseudo-atomic flag. */
li reg_NL4, 0
addu reg_ALLOC, 1
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
move reg_CFP, reg_CSP
addu reg_CSP, reg_CFP, 32
+ /* Mark us as in C land. */
+ sw reg_CSP, foreign_function_call_active
+
/* Set the pseudo-atomic flag. */
.set noreorder
li reg_NL4, 0
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. */
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
/* 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)
.word NIL /* name */
.word NIL /* arglist */
.word NIL /* type */
+ .word NIL /* xrefs */
LEAF(undefined_tramp)
/* 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
+ addiu reg_CODE, -SIMPLE_FUN_CODE_OFFSET
.set noreorder
b 1f
- break trap_Cerror
+ break 0x0, trap_Cerror
/* Error data length. */
.byte 4
/* Error number. */
See debug-var-io.lisp. */
.byte 254
/* reg_FDEFN is #14. */
- .byte ((14 << 5) + sc_DescriptorReg) % 0x100
- .byte ((14 << 5) + sc_DescriptorReg) / 0x100
+ .byte ((14 << 6) + sc_DescriptorReg) % 0x100
+ .byte ((14 << 6) + sc_DescriptorReg) / 0x100
.align 2
.set reorder
1: lw reg_CODE, FDEFN_FUN_OFFSET(reg_FDEFN)
.word NIL /* name */
.word NIL /* arglist */
.word NIL /* type */
+ .word NIL /* xrefs */
LEAF(closure_tramp)
lw reg_LEXENV, FDEFN_FUN_OFFSET(reg_FDEFN)
lw reg_CODE, CLOSURE_FUN_OFFSET(reg_LEXENV)
END(closure_tramp)
/*
- * Function-end breakpoint magic.
+ * The trampoline for funcallable instances
*/
- .align 3 /* minimum alignment for a lisp object */
- .set noreorder
- .word RETURN_PC_HEADER_WIDETAG
+ .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
+ .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. 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.
+ */
+
+/*
+ * For an explanation of the magic involved in function-end
+ * breakpoints, see the implementation in ppc-assem.S.
+ */
+
+ .align 3 /* minimum alignment for a lisp object */
LEAF(fun_end_breakpoint_guts)
- b multiple_value_return
+ .set noreorder
+ .word RETURN_PC_HEADER_WIDETAG + 0x800
+ b multiple_value_return
nop
- .set reorder
+ .set reorder
/* single value return */
multiple_value_return:
FEXPORT(fun_end_breakpoint_trap)
- break trap_FunEndBreakpoint
+ .set noreorder
b multiple_value_return
+ break 0x0, trap_FunEndBreakpoint
+ .set reorder
EXPORT(fun_end_breakpoint_end)
END(fun_end_breakpoint_guts)
+
+
+ .align 3 /* minimum alignment for a lisp object */
+ LEAF(do_pending_interrupt)
+ break 0x0, trap_PendingInterrupt
+ jr reg_LIP
+ END(do_pending_interrupt)
projects / sbcl.git / blobdiff