X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fmips-assem.S;h=1982ee86b8b741ab455209a8323be502a69ff72f;hb=37d3828773e2f847bb1ed7522b0af4fb8e736fc8;hp=1c37e2ed8d287d1fbea5c3c05eb738339734cc25;hpb=449088454569070e400f9f562c247bdc17cf60b5;p=sbcl.git diff --git a/src/runtime/mips-assem.S b/src/runtime/mips-assem.S index 1c37e2e..1982ee8 100644 --- a/src/runtime/mips-assem.S +++ b/src/runtime/mips-assem.S @@ -1,8 +1,24 @@ +/* + * 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. + */ + #include "sbcl.h" #include "lispregs.h" #include "globals.h" #include "genesis/fdefn.h" #include "genesis/closure.h" +#include "genesis/funcallable-instance.h" #include "genesis/simple-fun.h" #include "genesis/static-symbols.h" @@ -121,9 +137,6 @@ symbol: 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 @@ -137,7 +150,7 @@ symbol: .set noreorder bgez reg_NL4, 1f subu reg_ALLOC, 1 - break 0x10 + break 0x0, 0x10 1: .set reorder /* Pass in args */ @@ -155,24 +168,19 @@ symbol: la reg_LRA, lra + OTHER_POINTER_LOWTAG /* 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 @@ -183,6 +191,9 @@ lra: /* 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 @@ -195,14 +206,11 @@ lra: 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 @@ -234,9 +242,11 @@ lra: * 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) @@ -246,15 +256,13 @@ lra: .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) + /* Mark us as in C land. */ + sw reg_CSP, foreign_function_call_active /* Set the pseudo-atomic flag. */ .set noreorder @@ -262,6 +270,13 @@ lra: addu reg_ALLOC, 1 .set reorder + /* 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 @@ -269,29 +284,28 @@ lra: 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) - + lw gp, 8(reg_CFP) + /* Pass 64bit return value to lisp land. */ move reg_NL0, v0 # reg_CFUNC move reg_NL1, v1 # reg_NL4 - li reg_NIL, NIL - - /* Clear unsaved boxed descriptor regs */ + /* + * 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 @@ -300,7 +314,15 @@ lra: 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 @@ -308,9 +330,6 @@ lra: 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 @@ -318,16 +337,16 @@ lra: 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. */ @@ -335,48 +354,113 @@ lra: 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 */ + .word NIL /* xrefs */ LEAF(undefined_tramp) - break trap_Error - .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, -SIMPLE_FUN_CODE_OFFSET + .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 */ + .word NIL /* xrefs */ 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) - /* - * Function-end breakpoint magic. + * The trampoline for funcallable instances */ + .globl funcallable_instance_tramp .align 3 - LEAF(fun_end_breakpoint_guts) - .set noreorder - .word RETURN_PC_HEADER_WIDETAG + .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 - b multiple_value_return +/* + * 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) + .set noreorder + .word RETURN_PC_HEADER_WIDETAG + 0x800 + b multiple_value_return nop - .set reorder + .set reorder + + /* single value return */ move reg_OCFP, reg_CSP addu reg_CSP, 4 @@ -390,7 +474,16 @@ lra: 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)