X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fppc-assem.S;h=51b6b32434bf271c9abf15ae8eec735ff90260ce;hb=bf40ae88bc289fd765a33861cc4bc0853ed483ba;hp=dc400f278775af0362c6c31b8d1b1bed4b9cc044;hpb=c1b4849c95bad4f3535fba2b9307fd37e15bcf6d;p=sbcl.git diff --git a/src/runtime/ppc-assem.S b/src/runtime/ppc-assem.S index dc400f2..51b6b32 100644 --- a/src/runtime/ppc-assem.S +++ b/src/runtime/ppc-assem.S @@ -4,30 +4,82 @@ #include "lispregs.h" #include "globals.h" - +#include "genesis/simple-fun.h" +#include "genesis/fdefn.h" +#include "genesis/closure.h" +#include "genesis/funcallable-instance.h" +#include "genesis/static-symbols.h" +#ifdef LISP_FEATURE_SB_THREAD +#include "genesis/thread.h" +#endif + +#ifdef LISP_FEATURE_DARWIN +#define CSYMBOL(x) _ ## x +#else +#define CSYMBOL(x) x +#endif + +#if defined LISP_FEATURE_DARWIN +#define FUNCDEF(x) .text @ \ + .align 3 @ \ +_##x: + +#define GFUNCDEF(x) .globl _ ## x @ \ + FUNCDEF(x) +#else #define FUNCDEF(x) .text ; \ .align 3 ; \ .type x,@function ; \ x: + #define GFUNCDEF(x) .globl x ; \ FUNCDEF(x) +#endif +#if defined LISP_FEATURE_DARWIN +#define SET_SIZE(x) +#else #define SET_SIZE(x) .size x,.-x +#endif /* Load a register from a global, using the register as an intermediary */ /* The register will be a fixnum for one instruction, so this is gc-safe */ +#if defined LISP_FEATURE_DARWIN +#define load(reg,global) \ + lis reg,ha16(global) @ \ + lwz reg,lo16(global)(reg) ; Comment +#define store(reg,temp,global) \ + lis temp,ha16(global) @\ + stw reg,lo16(global)(temp) ; Comment +#else #define load(reg,global) \ lis reg,global@ha; lwz reg,global@l(reg) #define store(reg,temp,global) \ lis temp,global@ha; stw reg,global@l(temp) +#endif #define FIRST_SAVE_FPR 14 /* lowest-numbered non-volatile FPR */ +#ifdef LISP_FEATURE_DARWIN +#define FIRST_SAVE_GPR 13 /* lowest-numbered non-volatile GPR */ +#define NGPR_SAVE_BYTES(n) ((32-(n))*4) +#define FRAME_ARG_BYTES(n) (((((n)+6)*4)+15)&~15) +#else #define FIRST_SAVE_GPR 14 /* lowest-numbered non-volatile GPR */ -#define NFPR_SAVE_BYTES(n) ((32-(n))*8) #define NGPR_SAVE_BYTES(n) ((32-(~1&((n)+1)))*4) #define FRAME_ARG_BYTES(n) (((((n)+2)*4)+15)&~15) +#endif +#define NFPR_SAVE_BYTES(n) ((32-(n))*8) +#ifdef LISP_FEATURE_DARWIN +#define FRAME_SIZE(first_g,first_f,out_arg_words,savecr) \ +(NFPR_SAVE_BYTES(first_f)+ NGPR_SAVE_BYTES(first_g)+ FRAME_ARG_BYTES(out_arg_words)) +#define SAVE_FPR(n) stfd f##n,-8*(32- n)(r11) +#define SAVE_GPR(n) stw r##n,-4*(32- n)(r11) +#define FULL_FRAME_SIZE (FRAME_SIZE(FIRST_SAVE_GPR,FIRST_SAVE_FPR,8,1)+15&~15) +#define RESTORE_FPR(n) lfd f##n,-8*(32- n)(r11) +#define RESTORE_GPR(n) lwz r##n,-4*(32- n)(r11) +#else #define FRAME_SIZE(first_g,first_f,out_arg_words,savecr) \ (NFPR_SAVE_BYTES(first_f)+ NGPR_SAVE_BYTES(first_g)+ FRAME_ARG_BYTES(out_arg_words+savecr)) #define SAVE_FPR(n) stfd n,-8*(32-(n))(11) @@ -36,6 +88,106 @@ x: #define RESTORE_FPR(n) lfd n,-8*(32-(n))(11) #define RESTORE_GPR(n) lwz n,-4*(32-(n))(11) +#endif + +#ifdef LISP_FEATURE_DARWIN +#define C_FULL_PROLOG \ + nop @\ + nop @ \ + mfcr REG(0) @ \ + stw REG(0),4(REG(1)) @ \ + mflr REG(0) @ \ + stw REG(0),8(REG(1)) @ \ + mr REG(11),REG(1) @ \ + stwu REG(1),-FULL_FRAME_SIZE(REG(1)) @ \ + SAVE_FPR(14) @ \ + SAVE_FPR(15) @ \ + SAVE_FPR(16) @ \ + SAVE_FPR(17) @ \ + SAVE_FPR(18) @ \ + SAVE_FPR(19) @ \ + SAVE_FPR(20) @ \ + SAVE_FPR(21) @ \ + SAVE_FPR(22) @ \ + SAVE_FPR(23) @ \ + SAVE_FPR(24) @ \ + SAVE_FPR(25) @ \ + SAVE_FPR(26) @ \ + SAVE_FPR(27) @ \ + SAVE_FPR(28) @ \ + SAVE_FPR(29) @ \ + SAVE_FPR(30) @ \ + SAVE_FPR(31) @ \ + la REG(11),-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(REG(11)) @ \ + SAVE_GPR(13) @ \ + SAVE_GPR(14) @ \ + SAVE_GPR(15) @ \ + SAVE_GPR(16) @ \ + SAVE_GPR(17) @ \ + SAVE_GPR(18) @ \ + SAVE_GPR(19) @ \ + SAVE_GPR(20) @ \ + SAVE_GPR(21) @ \ + SAVE_GPR(22) @ \ + SAVE_GPR(23) @ \ + SAVE_GPR(24) @ \ + SAVE_GPR(25) @ \ + SAVE_GPR(26) @ \ + SAVE_GPR(27) @ \ + SAVE_GPR(28) @ \ + SAVE_GPR(29) @ \ + SAVE_GPR(30) @ \ + SAVE_GPR(31) + + +#define C_FULL_EPILOG \ + la REG(11),FULL_FRAME_SIZE-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(REG(1)) @ \ + RESTORE_GPR(13) @ \ + RESTORE_GPR(14) @ \ + RESTORE_GPR(15) @ \ + RESTORE_GPR(16) @ \ + RESTORE_GPR(17) @ \ + RESTORE_GPR(18) @ \ + RESTORE_GPR(19) @ \ + RESTORE_GPR(20) @ \ + RESTORE_GPR(21) @ \ + RESTORE_GPR(22) @ \ + RESTORE_GPR(23) @ \ + RESTORE_GPR(24) @ \ + RESTORE_GPR(25) @ \ + RESTORE_GPR(26) @ \ + RESTORE_GPR(27) @ \ + RESTORE_GPR(28) @ \ + RESTORE_GPR(29) @ \ + RESTORE_GPR(30) @ \ + RESTORE_GPR(31) @ \ + la REG(11),NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(REG(11)) @ \ + RESTORE_FPR(14) @ \ + RESTORE_FPR(15) @ \ + RESTORE_FPR(16) @ \ + RESTORE_FPR(17) @ \ + RESTORE_FPR(18) @ \ + RESTORE_FPR(19) @ \ + RESTORE_FPR(20) @ \ + RESTORE_FPR(21) @ \ + RESTORE_FPR(22) @ \ + RESTORE_FPR(23) @ \ + RESTORE_FPR(24) @ \ + RESTORE_FPR(25) @ \ + RESTORE_FPR(26) @ \ + RESTORE_FPR(27) @ \ + RESTORE_FPR(28) @ \ + RESTORE_FPR(29) @ \ + RESTORE_FPR(30) @ \ + RESTORE_FPR(31) @ \ + lwz REG(1),0(REG(1)) @ \ + lwz REG(0),4(REG(1)) @ \ + mtcr REG(0) @ \ + lwz REG(0),8(REG(1)) @ \ + mtlr REG(0) @ \ + +#else + #define C_FULL_PROLOG \ mflr 0 ; \ stw 0,4(1) ; \ @@ -77,10 +229,13 @@ x: SAVE_GPR(28) ; \ SAVE_GPR(29) ; \ SAVE_GPR(30) ; \ - SAVE_GPR(31) - + SAVE_GPR(31) ; \ + mfcr 0 ; \ + stw 0,8(1) #define C_FULL_EPILOG \ + lwz 5,8(1) ; \ + mtcrf 255,5 ; \ la 11,FULL_FRAME_SIZE-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(1) ; \ RESTORE_GPR(14) ; \ RESTORE_GPR(15) ; \ @@ -123,9 +278,27 @@ x: lwz 0,4(1) ; \ mtlr 0 ; \ +#endif + +/* gas can't parse nnnnLU; redefine */ +#if BACKEND_PAGE_BYTES == 65536 +# undef BACKEND_PAGE_BYTES +# define BACKEND_PAGE_BYTES 65536 +#elif BACKEND_PAGE_BYTES == 4096 +# undef BACKEND_PAGE_BYTES +# define BACKEND_PAGE_BYTES 4096 +#else +# error BACKEND_PAGE_BYTES mismatch +#endif + +#ifdef LISP_FEATURE_SB_SAFEPOINT +/* OAOOM because we don't have the C headers here. */ +# define THREAD_CSP_PAGE_SIZE 4096 + +/* the CSP page sits right before the thread */ +# define THREAD_SAVED_CSP_OFFSET (-THREAD_CSP_PAGE_SIZE) +#endif - - .text /* @@ -135,8 +308,33 @@ x: GFUNCDEF(call_into_lisp) C_FULL_PROLOG - mfcr 0 - stw 0,8(1) + /* NL0 - function, NL1 - frame pointer, NL2 - nargs. */ +#if defined(LISP_FEATURE_SB_THREAD) + /* We need to obtain a pointer to our TLS block before we do + * anything else. For this, we call pthread_getspecific(). + * We've preserved all of the callee-saves registers, so we + * can use them to stash our arguments temporarily while we + * make the call. */ + mr reg_A0, reg_NL0 + mr reg_A1, reg_NL1 + mr reg_A2, reg_NL2 + + /* Call out to obtain our TLS block. */ + load(reg_NL0,CSYMBOL(specials)) + /* This won't work on darwin: wrong fixup style. And is it + * supposed to be lis/ori or lis/addi? Or does it differ + * between darwin and everything else again? */ + lis reg_CFUNC,CSYMBOL(pthread_getspecific)@h + ori reg_CFUNC,reg_CFUNC,CSYMBOL(pthread_getspecific)@l + mtctr reg_CFUNC + bctrl + mr reg_THREAD, reg_NL0 + + /* Restore our original parameters. */ + mr reg_NL2, reg_A2 + mr reg_NL1, reg_A1 + mr reg_NL0, reg_A0 +#endif /* store(reg_POLL,11,saver2) */ /* Initialize tagged registers */ li reg_ZERO,0 @@ -152,25 +350,42 @@ x: li reg_A3,0 li reg_L0,0 li reg_L1,0 +#if !defined(LISP_FEATURE_SB_THREAD) li reg_L2,0 +#endif li reg_LIP,0 +#ifdef LISP_FEATURE_DARWIN + lis reg_NULL,hi16(NIL) + ori reg_NULL,reg_NULL,lo16(NIL) +#else lis reg_NULL,NIL@h ori reg_NULL,reg_NULL,NIL@l - +#endif /* Turn on pseudo-atomic */ - li reg_NL3,-4 - li reg_ALLOC,4 - store(reg_ZERO,reg_NL4,foreign_function_call_active) - load(reg_NL4,dynamic_space_free_pointer) + li reg_ALLOC,flag_PseudoAtomic +#if defined(LISP_FEATURE_SB_THREAD) + stw reg_ZERO,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD) + lwz reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD) + lwz reg_CSP,THREAD_CONTROL_STACK_POINTER_OFFSET(reg_THREAD) + lwz reg_OCFP,THREAD_CONTROL_FRAME_POINTER_OFFSET(reg_THREAD) +#else + store(reg_ZERO,reg_NL4,CSYMBOL(foreign_function_call_active)) + load(reg_BSP,CSYMBOL(current_binding_stack_pointer)) + load(reg_CSP,CSYMBOL(current_control_stack_pointer)) + load(reg_OCFP,CSYMBOL(current_control_frame_pointer)) +#endif + /* This is important for CHENEYGC: It's the allocation + * pointer. It's also important for ROOM on GENCGC: + * It's a pointer to the end of dynamic space, used to + * determine where to stop in MAP-ALLOCATED-OBJECTS. */ + load(reg_NL4,CSYMBOL(dynamic_space_free_pointer)) add reg_ALLOC,reg_ALLOC,reg_NL4 - load(reg_BSP,current_binding_stack_pointer) - load(reg_CSP,current_control_stack_pointer) - load(reg_OCFP,current_control_frame_pointer) /* No longer atomic, and check for interrupt */ - add reg_ALLOC,reg_ALLOC,reg_NL3 - twlti reg_ALLOC,0 + subi reg_ALLOC,reg_ALLOC,flag_PseudoAtomic + andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted + twnei reg_NL3, 0 /* Pass in the arguments */ @@ -182,13 +397,18 @@ x: lwz reg_A3,12(reg_CFP) /* Calculate LRA */ - lis reg_LRA,lra@ha - addi reg_LRA,reg_LRA,lra@l +#ifdef LISP_FEATURE_DARWIN + lis reg_LRA,ha16(lra) + addi reg_LRA,reg_LRA,lo16(lra) +#else + lis reg_LRA,lra@h + ori reg_LRA,reg_LRA,lra@l +#endif addi reg_LRA,reg_LRA,OTHER_POINTER_LOWTAG /* Function is an indirect closure */ lwz reg_CODE,SIMPLE_FUN_SELF_OFFSET(reg_LEXENV) - addi reg_LIP,reg_CODE,6*4-FUN_POINTER_LOWTAG + addi reg_LIP,reg_CODE,SIMPLE_FUN_CODE_OFFSET mtctr reg_LIP slwi reg_NARGS,reg_NL2,2 bctr @@ -203,32 +423,40 @@ lra: /* Return the one value. */ - mr 3,reg_A0 + mr REG(3),reg_A0 /* Turn on pseudo-atomic */ - li reg_NL3,-4 - la reg_ALLOC,4(reg_ALLOC) + la reg_ALLOC,flag_PseudoAtomic(reg_ALLOC) + +#if defined(LISP_FEATURE_SB_THREAD) + /* Store lisp state */ + stw reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD) + stw reg_CSP,THREAD_CONTROL_STACK_POINTER_OFFSET(reg_THREAD) + stw reg_CFP,THREAD_CONTROL_FRAME_POINTER_OFFSET(reg_THREAD) + /* No longer in Lisp. */ + stw reg_ALLOC,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD) +#else /* Store lisp state */ clrrwi reg_NL1,reg_ALLOC,3 - store(reg_NL1,reg_NL2,dynamic_space_free_pointer) + store(reg_NL1,reg_NL2,CSYMBOL(dynamic_space_free_pointer)) /* store(reg_POLL,reg_NL2,poll_flag) */ /* load(reg_NL2,current_thread) */ - store(reg_BSP,reg_NL2,current_binding_stack_pointer) - store(reg_CSP,reg_NL2,current_control_stack_pointer) - store(reg_CFP,reg_NL2,current_control_frame_pointer) + store(reg_BSP,reg_NL2,CSYMBOL(current_binding_stack_pointer)) + store(reg_CSP,reg_NL2,CSYMBOL(current_control_stack_pointer)) + store(reg_CFP,reg_NL2,CSYMBOL(current_control_frame_pointer)) /* load(reg_POLL,saver2) */ /* No longer in Lisp. */ - store(reg_NL1,reg_NL2,foreign_function_call_active) + store(reg_NL1,reg_NL2,CSYMBOL(foreign_function_call_active)) +#endif /* Check for interrupt */ - add reg_ALLOC,reg_ALLOC,reg_NL3 - twlti reg_ALLOC,0 - + subi reg_ALLOC, reg_ALLOC, flag_PseudoAtomic + andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted + twnei reg_NL3,0 + /* Back to C */ - lwz 5,8(1) - mtcrf 255,5 C_FULL_EPILOG blr SET_SIZE(call_into_lisp) @@ -256,37 +484,63 @@ lra: mr reg_NARGS,reg_NL3 /* Turn on pseudo-atomic */ - li reg_NL3,-4 - la reg_ALLOC,4(reg_ALLOC) + la reg_ALLOC,flag_PseudoAtomic(reg_ALLOC) /* Convert the return address to an offset and save it on the stack. */ sub reg_NFP,reg_LIP,reg_CODE la reg_NFP,OTHER_POINTER_LOWTAG(reg_NFP) stw reg_NFP,4(reg_CFP) +#ifdef LISP_FEATURE_SB_THREAD + /* Store Lisp state */ + stw reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD) + stw reg_CSP,THREAD_CONTROL_STACK_POINTER_OFFSET(reg_THREAD) + stw reg_CFP,THREAD_CONTROL_FRAME_POINTER_OFFSET(reg_THREAD) + + /* No longer in Lisp. */ + stw reg_CSP,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD) +#else /* Store Lisp state */ clrrwi reg_NFP,reg_ALLOC,3 - store(reg_NFP,reg_CFUNC,dynamic_space_free_pointer) + store(reg_NFP,reg_CFUNC,CSYMBOL(dynamic_space_free_pointer)) /* load(reg_CFUNC,current_thread) */ - store(reg_BSP,reg_CFUNC,current_binding_stack_pointer) - store(reg_CSP,reg_CFUNC,current_control_stack_pointer) - store(reg_CFP,reg_CFUNC,current_control_frame_pointer) + store(reg_BSP,reg_CFUNC,CSYMBOL(current_binding_stack_pointer)) + store(reg_CSP,reg_CFUNC,CSYMBOL(current_control_stack_pointer)) + store(reg_CFP,reg_CFUNC,CSYMBOL(current_control_frame_pointer)) /* No longer in Lisp */ - store(reg_CSP,reg_CFUNC,foreign_function_call_active) + store(reg_CSP,reg_CFUNC,CSYMBOL(foreign_function_call_active)) +#endif /* load(reg_POLL,saver2) */ /* Disable pseudo-atomic; check pending interrupt */ - add reg_ALLOC,reg_ALLOC,reg_NL3 - twlti reg_ALLOC,0 + subi reg_ALLOC, reg_ALLOC, flag_PseudoAtomic + andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted + twnei reg_NL3, 0 + +#ifdef LISP_FEATURE_SB_SAFEPOINT + /* OK to run GC without stopping this thread from this point on. */ + stw reg_CSP,THREAD_SAVED_CSP_OFFSET(reg_THREAD) +#endif + mr reg_NL3,reg_NARGS +#ifdef LISP_FEATURE_DARWIN + /* PowerOpen (i.e. OS X) requires the callee address in r12 + (a.k.a. CFUNC), so move it back there, too. */ + mfctr reg_CFUNC +#endif /* Into C we go. */ bctrl /* Re-establish NIL */ +#ifdef LISP_FEATURE_DARWIN + lis reg_NULL,hi16(NIL) + ori reg_NULL,reg_NULL,lo16(NIL) +#else lis reg_NULL,NIL@h ori reg_NULL,reg_NULL,NIL@l +#endif /* And reg_ZERO */ li reg_ZERO,0 @@ -305,22 +559,42 @@ lra: li reg_A3,0 li reg_L0,0 li reg_L1,0 +#if !defined(LISP_FEATURE_SB_THREAD) + /* reg_L2 is our TLS block pointer. */ li reg_L2,0 +#endif li reg_LIP,0 +# ifdef LISP_FEATURE_SB_SAFEPOINT + /* No longer OK to run GC except at safepoints. */ + stw reg_ZERO,THREAD_SAVED_CSP_OFFSET(reg_THREAD) +# endif + /* Atomic ... */ - li reg_NL3,-4 - li reg_ALLOC,4 + li reg_ALLOC,flag_PseudoAtomic + +#if defined(LISP_FEATURE_SB_THREAD) + /* No longer in foreign function call. */ + stw reg_ZERO,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD) + /* The binding stack pointer isn't preserved by C. */ + lwz reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD) +#else /* No long in foreign function call. */ - store(reg_ZERO,reg_NL2,foreign_function_call_active) + store(reg_ZERO,reg_NL2,CSYMBOL(foreign_function_call_active)) /* The free pointer may have moved */ - load(reg_NL4,dynamic_space_free_pointer) - add reg_ALLOC,reg_ALLOC,reg_NL4 + /* (moved below) */ /* The BSP wasn't preserved by C, so load it */ - load(reg_BSP,current_binding_stack_pointer) + load(reg_BSP,CSYMBOL(current_binding_stack_pointer)) +#endif + /* This is important for CHENEYGC: It's the allocation + * pointer. It's also important for ROOM on GENCGC: + * It's a pointer to the end of dynamic space, used to + * determine where to stop in MAP-ALLOCATED-OBJECTS. */ + load(reg_NL4,CSYMBOL(dynamic_space_free_pointer)) + add reg_ALLOC,reg_ALLOC,reg_NL4 /* Other lisp stack/frame pointers were preserved by C. I can't imagine why they'd have moved */ @@ -332,8 +606,10 @@ lra: la reg_LIP,-OTHER_POINTER_LOWTAG(reg_LIP) /* No longer atomic */ - add reg_ALLOC,reg_ALLOC,reg_NL3 - twlti reg_ALLOC,0 + subi reg_ALLOC, reg_ALLOC, flag_PseudoAtomic + andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted + twnei reg_NL3, 0 + mtlr reg_LIP /* Reset the lisp stack. */ @@ -346,40 +622,54 @@ lra: SET_SIZE(call_into_c) GFUNCDEF(xundefined_tramp) - .globl undefined_tramp - .byte 0,0,0,SIMPLE_FUN_HEADER_WIDETAG /* type_FunctionHeader */ - - .byte 18<<2 -undefined_tramp: - .byte 0,0,24 - .long undefined_tramp - .long NIL - .long NIL - .long NIL - .long NIL + .globl CSYMBOL(undefined_tramp) + .long SIMPLE_FUN_HEADER_WIDETAG /* header */ + .long CSYMBOL(undefined_tramp) - SIMPLE_FUN_CODE_OFFSET /* self */ + .long NIL /* next */ + .long NIL /* name */ + .long NIL /* arglist */ + .long NIL /* type */ + .long NIL /* xref */ +CSYMBOL(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. */ + /* We are given that reg_LIP points to undefined_tramp by + virtue of the calling convention. */ + addi reg_CODE,reg_LIP,-SIMPLE_FUN_CODE_OFFSET + + /* If we are called with stack arguments (or in a tail-call + scenario), we end up with an allocated stack frame, but the + frame link information is uninitialized. Fix things by + allocating and initializing our stack frame "properly". */ + cmpwi cr0,reg_NARGS,16 + bt gt,1f + addi reg_CSP,reg_CFP,16 + b 2f +1: add reg_CSP,reg_CFP,reg_NARGS +2: stw reg_OCFP,0(reg_CFP) + stw reg_LRA,4(reg_CFP) + + /* Now that the preliminaries are dealt with, actually trap. */ twllei reg_ZERO,trap_Cerror .byte 4 .byte UNDEFINED_FUN_ERROR - .byte 254, 140, 2 /* 140? sparc says sc_descriptorReg */ + .byte 254, sc_DescriptorReg+0x40, 1 /* 140? sparc says sc_descriptorReg */ + /* This stuff is for the continuable error. I don't think there's + * any support for it on the lisp side */ .align 2 1: lwz reg_CODE,FDEFN_RAW_ADDR_OFFSET(reg_FDEFN) la reg_LIP,SIMPLE_FUN_CODE_OFFSET(reg_CODE) mtctr reg_LIP bctr - + mr reg_CSP,reg_CFP + b 1b + SET_SIZE(xundefined_tramp) GFUNCDEF(xclosure_tramp) - .globl closure_tramp - .byte 0,0,0,SIMPLE_FUN_HEADER_WIDETAG - .byte 18<<2 -closure_tramp: - .byte 0,0,24 - .long closure_tramp - .long NIL - .long NIL - .long NIL - .long NIL + .globl CSYMBOL(closure_tramp) +CSYMBOL(closure_tramp): lwz reg_LEXENV,FDEFN_FUN_OFFSET(reg_FDEFN) lwz reg_CODE,CLOSURE_FUN_OFFSET(reg_LEXENV) la reg_LIP,SIMPLE_FUN_CODE_OFFSET(reg_CODE) @@ -388,29 +678,177 @@ closure_tramp: SET_SIZE(xclosure_tramp) - GFUNCDEF(fun_end_breakpoint_trap) - .long 0 - SET_SIZE(fun_end_breakpoint_trap) - - GFUNCDEF(fun_end_breakpoint) - .long 0 - SET_SIZE(fun_end_breakpoint) - + GFUNCDEF(xfuncallable_instance_tramp) + .globl CSYMBOL(funcallable_instance_tramp) + .long SIMPLE_FUN_HEADER_WIDETAG +CSYMBOL(funcallable_instance_tramp) = . + 1 + .long CSYMBOL(funcallable_instance_tramp) + .long NIL + .long NIL + .long NIL + .long NIL + .long NIL + lwz reg_LEXENV,FUNCALLABLE_INSTANCE_FUNCTION_OFFSET(reg_LEXENV) + lwz reg_FDEFN,CLOSURE_FUN_OFFSET(reg_LEXENV) + addi reg_LIP,reg_FDEFN,SIMPLE_FUN_CODE_OFFSET + mtctr reg_LIP + bctr + SET_SIZE(funcallable_instance_tramp) + + /* The fun_end_breakpoint support here is considered by the + authors of the other $ARCH-assem.S files to be magic, and it + is. It is a small fragment of code that is copied into a heap + code-object when needed, and contains an LRA object, code to + convert a single-value return to unknown-values format, and a + trap_FunEndBreakpoint. */ GFUNCDEF(fun_end_breakpoint_guts) - .long 0 - SET_SIZE(fun_end_breakpoint_guts) - - GFUNCDEF(fun_end_breakpoint_end) - .long 0 - SET_SIZE(fun_end_breakpoint_end) + .globl CSYMBOL(fun_end_breakpoint_trap) + .globl CSYMBOL(fun_end_breakpoint_end) + + /* Due to pointer verification in MAKE-LISP-OBJ, this must + include its header data (the offset from the start of the + code-object to the LRA). The code-object header is five + words, there are two words of constants, and the instruction + space is doubleword-aligned, making an offset of eight. + This is header data for a widetag, so shift left eight bits + and add. */ + .long RETURN_PC_HEADER_WIDETAG + 0x800 + + /* We are receiving unknown multiple values, thus must deal + with the single-value and multiple-value cases separately. */ + b fun_end_breakpoint_multiple_values + nop + /* Compute the correct value for reg_CODE based on the LRA. + This is a "simple" matter of subtracting a constant from + reg_LRA (where the LRA is stored by the return sequence) to + obtain a tagged pointer to the enclosing code component. Both + values are tagged OTHER_POINTER_LOWTAG, so we just have to + account for the eight words (see calculation for + RETURN_PC_HEADER_WIDETAG, above) between the two addresses. + Restoring reg_CODE doesn't appear to be strictly necessary + here, but let's observe the niceties.*/ + addi reg_CODE, reg_LRA, -32 + + /* Multiple values are stored relative to reg_OCFP, which we + set to be the current top-of-stack. */ + mr reg_OCFP, reg_CSP + + /* Reserve a save location for the one value we have. */ + addi reg_CSP, reg_CSP, 4 + + /* Record the number of values we have as a FIXNUM. */ + li reg_NARGS, 4 + + /* Blank the remaining arg-passing registers. */ + mr reg_A1, reg_NULL + mr reg_A2, reg_NULL + mr reg_A3, reg_NULL + + /* And branch to our trap. */ + b CSYMBOL(fun_end_breakpoint_trap) + +fun_end_breakpoint_multiple_values: + /* Compute the correct value for reg_CODE. See the + explanation for the single-value case, above. */ + addi reg_CODE, reg_LRA, -32 + + /* The actual magic trap. */ +CSYMBOL(fun_end_breakpoint_trap): + twllei reg_ZERO, trap_FunEndBreakpoint + + /* Finally, the debugger needs to know where the end of the + fun_end_breakpoint_guts are, so that it may calculate its size + in order to populate out a suitably-sized code object. */ +CSYMBOL(fun_end_breakpoint_end): + SET_SIZE(fun_end_breakpoint_guts) + GFUNCDEF(ppc_flush_cache_line) - dcbf 0,3 + dcbf 0,REG(3) sync - icbi 0,3 + icbi 0,REG(3) sync isync blr SET_SIZE(ppc_flush_cache_line) + GFUNCDEF(do_pending_interrupt) + twllei reg_ZERO, trap_PendingInterrupt + blr +/* King Nato's branch has a nop here. Do we need this? */ + SET_SIZE(do_pending_interrupt) + +#if defined LISP_FEATURE_GENCGC + + GFUNCDEF(fpu_save) + stfd FREG(1), 0(REG(3)) + stfd FREG(2), 8(REG(3)) + stfd FREG(3), 16(REG(3)) + stfd FREG(4), 24(REG(3)) + stfd FREG(5), 32(REG(3)) + stfd FREG(6), 40(REG(3)) + stfd FREG(7), 48(REG(3)) + stfd FREG(8), 56(REG(3)) + stfd FREG(9), 64(REG(3)) + stfd FREG(10), 72(REG(3)) + stfd FREG(11), 80(REG(3)) + stfd FREG(12), 88(REG(3)) + stfd FREG(13), 96(REG(3)) + stfd FREG(14), 104(REG(3)) + stfd FREG(15), 112(REG(3)) + stfd FREG(16), 120(REG(3)) + stfd FREG(17), 128(REG(3)) + stfd FREG(18), 136(REG(3)) + stfd FREG(19), 144(REG(3)) + stfd FREG(20), 152(REG(3)) + stfd FREG(21), 160(REG(3)) + stfd FREG(22), 168(REG(3)) + stfd FREG(23), 176(REG(3)) + stfd FREG(24), 184(REG(3)) + stfd FREG(25), 192(REG(3)) + stfd FREG(26), 200(REG(3)) + stfd FREG(27), 208(REG(3)) + stfd FREG(28), 216(REG(3)) + stfd FREG(29), 224(REG(3)) + stfd FREG(30), 232(REG(3)) + stfd FREG(31), 240(REG(3)) + blr + SET_SIZE(fpu_save) + + GFUNCDEF(fpu_restore) + lfd FREG(1), 0(REG(3)) + lfd FREG(2), 8(REG(3)) + lfd FREG(3), 16(REG(3)) + lfd FREG(4), 24(REG(3)) + lfd FREG(5), 32(REG(3)) + lfd FREG(6), 40(REG(3)) + lfd FREG(7), 48(REG(3)) + lfd FREG(8), 56(REG(3)) + lfd FREG(9), 64(REG(3)) + lfd FREG(10), 72(REG(3)) + lfd FREG(11), 80(REG(3)) + lfd FREG(12), 88(REG(3)) + lfd FREG(13), 96(REG(3)) + lfd FREG(14), 104(REG(3)) + lfd FREG(15), 112(REG(3)) + lfd FREG(16), 120(REG(3)) + lfd FREG(17), 128(REG(3)) + lfd FREG(18), 136(REG(3)) + lfd FREG(19), 144(REG(3)) + lfd FREG(20), 152(REG(3)) + lfd FREG(21), 160(REG(3)) + lfd FREG(22), 168(REG(3)) + lfd FREG(23), 176(REG(3)) + lfd FREG(24), 184(REG(3)) + lfd FREG(25), 192(REG(3)) + lfd FREG(26), 200(REG(3)) + lfd FREG(27), 208(REG(3)) + lfd FREG(28), 216(REG(3)) + lfd FREG(29), 224(REG(3)) + lfd FREG(30), 232(REG(3)) + lfd FREG(31), 240(REG(3)) + blr + SET_SIZE(fpu_restore) + +#endif