/* + * QuickThreads -- Threads-building toolkit. + * Copyright (c) 1993 by David Keppel + * + * Permission to use, copy, modify and distribute this software and + * its documentation for any purpose and without fee is hereby + * granted, provided that the above copyright notice and this notice + * appear in all copies. This software is provided as a + * proof-of-concept and for demonstration purposes; there is no + * representation about the suitability of this software for any + * purpose. + * + * PowerPC-Sys5 thread switching module. + * + * This software is largely based on the original PowerPC-Linux porting + * developed by Ken Aaker + * + * Marco Bucci + * December 2002 + * + */ #ifndef QUICKTHREADS_POWERPC_H #define QUICKTHREADS_POWERPC_H /***************************************************************************** * * DESCRIPTION * * This is the QuickThreads switching module implementation for PowerPC * running under System V ABI (Application Binary Interface) [2]. It was * developed by porting the MacOS X version and tested under LinuxPPC. * * Notice that this is not the same than the PowerPC Mach ABI used by MacOSX * [1]. * * IMPLEMENTATION NOTES * * 1) Porting on System V ABI * Excluding the variant argument calling convention, Mach and System V ABI * are enough similar and it could be possible to use some simple macro, to * adapt the code for both the ABIs. Actually, the only relevant difference * is in the linkage area structure and in the position where the Link and * the Condition registers are saved. As to the calling conventions, there * are differences with floating points argument passing and with variant * argument lists. Notice that, on Mach, the caller's stack frame allocates * space to hold all arguments ([1] p.51), while on System V, the caller's * stack frame allocates space to hold just the arguments that don't fit into * registers ([2] p.3.18). * * 2) Variant argument list implementation * Variant argument calling on a RISC machine is not easy to implement since * parameters are passed via registers instead of via stack. In a general * variant argument implementation, the caller's stack must map the whole * parameter list following the rules related to the use of the GPR and FPR * parameter registers and the stack alignment ([2] p.3-21). * This implementation is quite simple and not general. It works under the * hypothesis that arguments are 4-bytes aligned integers. * * 3) This heather file organisation * I preferred to not make confusion between macros that are needed (i.e. * directly used) by QuickThreads and internal "implementation" macros. You * will find QuickThreds macros in the end of this header. Sometime they just * refer to an analogous "internal" macro. On the top, there are the macros * that I used to make more clean (I hope) the implementation. I could include * some system heather (as to stack layout definitions, prologs and epilogs, * etc.), but I preferred to have a self-contained heather in order to make * all more clear for mantaining and for possible porting on another ABI. * * * REFERENCES * * [1] - Mach-O Runtime Architecture * Runtime Concepts and Conventions for Mac OS X Programs * Preliminary July 2002 * * [2] - SYSTEM V APPLICATION BINARY INTERFACE * PowerPC Processor Supplement * September 1995 * *****************************************************************************/ /***************************************************************************** * * PowerPC System V Stack frame (see [2]) * ................ + + | | +--------------------------+ | | Caller's LR + CALLER'S LINKAGE AREA + backchain -> | | Caller's backchain +==========================+ | | FPR31 + FPR SAVE AREA + .............. + + | | FPRn +--------------------------+ | | GPR31 + GPR SAVE AREA + .............. + + | | GPRn +--------------------------+ | | + ALIGNMEBNT PAD + .............. + (if needed) + | | +--------------------------+ | CR SAVE | +--------------------------+ | | + LOCAL VARIABLES AREA + .............. + + | | +--------------------------+ | | PAR(n-7) + + | | + PARAMETER AREA + .............. + for FUTURE call + | | PAR(9) + + SP + 8 -> | | PAR(8) +--------------------------+ SP + 4 -> | | LR callee-save for FUTURE call + LINKAGE AREA + SP -> | | backchain +==========================+ STACK TOP (lower address) Stack grows down | V * NOTE: * * 1) In this figure parameter are supposed to be integer 4-bytes aligned and * are numbered 0, 1, 2,... n. * * 2) Parameter are allocated in the CALLER's parameter area. This area must * be large enough to hold all parameters that cannot fit in registers (no * more parameter registers are available); * * 3) The callee saves LR in the caller's linkage area. CR as all other * callee's state are saved in its own stack frame. * *****************************************************************************/ /***************************************************************************** * * Stack initialization for a single argument thread * top + QUICKTHREADS_STKBASE -> STACK BOTTOM (higher address) +==========================+ | | + + .............. + + | | +--------------------------+ top + QUICKTHREADS_ONLY_INDEX * 4 -> | only param | PAR(3) + + top + QUICKTHREADS_USER_INDEX * 4 -> | userf param | PAR(2) + + top + QUICKTHREADS_ARGT_INDEX * 4 -> | t param | PAR(1) + + top + QUICKTHREADS_ARGU_INDEX * 4 -> | u param | PAR(0) +--------------------------+ top + QUICKTHREADS_RETURN_INDEX * 4 -> | qt_start | LR save + + top + QUICKTHREADS_BLOCKI_FRAME_SIZE -> | top + QUICKTHREADS_STKBASE | backchain +==========================+ | | + + .............. + + | | +--------------------------+ | | + + top -> |top + QUICKTHREADS_BLOCKI_FRAME_SIZE| backchain +==========================+ STACK TOP (lower address) Stack grows down | V ***************************************************************************** * * Stack initialization for a variant argument thread * bottom -> STACK BOTTOM (higher address) +==========================+ | | + + .............. + + top + QUICKTHREADS_VSTKBASE -> | arg(0) | PAR(4) +--------------------------+ top + QUICKTHREADS_CLEANUP_INDEX * 4 -> | cleanup param | PAR(3) + + top + QUICKTHREADS_USER_INDEX * 4 -> | userf param | PAR(2) + + top + QUICKTHREADS_VSTARTUP_INDEX * 4 ->| startup param | PAR(1) + + top + QUICKTHREADS_ARGT_INDEX * 4 -> | t param | PAR(0) +--------------------------+ top + QUICKTHREADS_RETURN_INDEX * 4 -> | qt_start | LR save + + top + QUICKTHREADS_BLOCKI_FRAME_SIZE -> | top + QUICKTHREADS_STKBASE | backchain +==========================+ | | + + .............. + + | | +--------------------------+ | | + + top -> |top + QUICKTHREADS_BLOCKI_FRAME_SIZE| backchain +==========================+ STACK TOP (lower address) Stack grows down | V * NOTE: * * Parameters are passed to "qt_start" or to "qt_vstart" putting them into * the stack frames of "qt_start" or "qt_vstart" themselves. This not a * conventional parameter passing because parameters should be put into the * caller's stack, not into the callee's one. Actually we must consider * that as a preload of the parameter area that "qt_start" or "qt_vstart" * will use for their own calls. * Be aware of the fact that, during a call, the caller's parameter area is, * in a certain sense, volatile. In facts, the callee can save parameter * registers on the caller's parameter area. * *****************************************************************************/ /***************************************************************************** Define PowerPC System V related macros *****************************************************************************/ typedef unsigned long PPC_W; /* Stack pointer must always be a multiple of 16 */ #define PPC_STACK_INCR 16 #define PPC_ROUND_STACK(length) \ (((length)+PPC_STACK_INCR-1) & ~(PPC_STACK_INCR-1)) #define PPC_LINKAGE_AREA 8 #define PPC_LR_SAVE 4 #define PPC_PARAM_AREA(n) (4*(n)) #define PPC_GPR_SAVE_AREA (4*19) /* GPR13-GPR31 must be saved */ #define PPC_FPR_SAVE_AREA (8*18) /* FPR14-FPR31 must be saved */ /* Define parameter offset on the stack. * NOTICE: Parameters are numbered 0, 1, ..., n. */ #define PPC_PAR(i) (PPC_LINKAGE_AREA+(i)*4) /***************************************************************************** Define stack frames *****************************************************************************/ /* Define the "qt_blocki" and "qt_abort" stack frame. We use the same stack * frame for both. * top + S -> +==========================+ top + S - 4 -> | | GPR31 + GPR SAVE AREA + .............. + + top + S - 19 * 4 -> | | GPR13 +--------------------------+ | | + ALIGNMEBNT PAD + .............. + (if needed) + | | +--------------------------+ top + 8 -> | CR SAVE | +--------------------------+ | | + LINKAGE AREA + top -> | | +==========================+ */ #define QUICKTHREADS_BLOCKI_FRAME_SIZE \ PPC_ROUND_STACK(PPC_LINKAGE_AREA+4+PPC_GPR_SAVE_AREA) #define QUICKTHREADS_BLOCKI_CR_SAVE 8 /* Offset to the base of the GPR save area. Save from GPR13 to GPR31 * increasing address. */ #define QUICKTHREADS_BLOCKI_GPR_SAVE(i) (QUICKTHREADS_BLOCKI_FRAME_SIZE-4+(i-31)*4) /* Define the "qt_block" stack frame. Notice that since "qt_black" calls * "qt_blocki", GPR registers are saved into "qt_blocki" stack frame. * top + S -> +==========================+ top + S - 8 -> | | FPR31 + FPR SAVE AREA + .............. + + top + S - 18 * 8 -> | | FPR14 +--------------------------+ | | + ALIGNMEBNT PAD + .............. + (if needed) + | | +--------------------------+ | | + LINKAGE AREA + top -> | | +==========================+ */ #define QUICKTHREADS_BLOCK_FRAME_SIZE \ PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_FPR_SAVE_AREA) /* Offset to the location where registers are saved. */ #define QUICKTHREADS_BLOCK_FPR_SAVE(i) (QUICKTHREADS_BLOCK_FRAME_SIZE-8+(i-31)*8) /* Define the "qt_start" frame size. It consists just of the linkage area and * the parameter area. * +==========================+ | | + ALIGNMEBNT PAD + .............. + (if needed) + | | +--------------------------+ | | only par + + | | userf par + PARAMETER AREA + | | t par + + top + 8 -> | | u par +--------------------------+ | | + LINKAGE AREA + top -> | | +==========================+ */ #define QUICKTHREADS_START_FRAME_SIZE PPC_ROUND_STACK(PPC_LINKAGE_AREA+PPC_PARAM_AREA(4)) /* Define the "qt_vstart" frame. It consists of the linkage area, the fix parameter * area, the variant argument list and a local variable area used in "qt_vstart" * implementation. * backchain -> +==========================+ backchain - 4 -> | | + LOCAL VARIABLES AREA + .............. + + | | +--------------------------+ | | + ALIGNMEBNT PAD + .............. + (if needed) + | | +--------------------------+ | | arg(n) + + | | + VARIABLE ARGUMENT LIST + .............. + for userf call + | | arg(1) + + top + 8 + 16 -> | | arg(0) +--------------------------+ | | cleanup par + + | | userf par + PARAMETER AREA + | | startup par + + top + 8 -> | | t par +--------------------------+ | | + LINKAGE AREA + top -> | | +==========================+ */ #define QUICKTHREADS_VARGS_LOCAL_AREA (4*4) /* local variable area */ /* The offset the stack will be moved back before to call "userf(...)". * The linckage area must be moved to be adiacent to the part of the variant * argument list that is in the stack. Notice that, since the first 8 * parameters are passed via registers, the offset is equal to the size of * 4+8 parameters. */ #define QUICKTHREADS_VARGS_BKOFF PPC_PARAM_AREA(4+8) #define QUICKTHREADS_VSTART_FRAME_SIZE(varbytes) \ PPC_ROUND_STACK(PPC_LINKAGE_AREA+QUICKTHREADS_VARGS_BKOFF+(varbytes)+ \ QUICKTHREADS_VARGS_LOCAL_AREA) /* Offset to the base of the varian argument list */ #define QUICKTHREADS_VSTART_LIST_BASE (PPC_LINKAGE_AREA+PPC_PARAM_AREA(4)) /* Notice that qt_start and qt_vstart have no parameters, actually their * parameters are written in their stack frame during thread initialization */ extern void qt_start(void); extern void qt_vstart(void); /* Offset (in words) of the location where the block routine saves its return * address (i.e. LR). SP points the top of the block routine stack and, * following ppc calling conventions, the return address is saved in the * previous (caller's) stack frame. */ #define QUICKTHREADS_RETURN_INDEX ((QUICKTHREADS_BLOCKI_FRAME_SIZE+PPC_LR_SAVE)/sizeof(PPC_W)) /* static variable used to get the stack bottom in "VARGS" initialization */ static void *qt_sp_bottom_save; #define QUICKTHREADS_ARG_INDEX(i) ((QUICKTHREADS_BLOCKI_FRAME_SIZE+PPC_PAR(i))/sizeof(PPC_W)) /***************************************************************************** QuickThreads needed definitions *****************************************************************************/ #define QUICKTHREADS_GROW_DOWN #define QUICKTHREADS_STKALIGN PPC_STACK_INCR typedef PPC_W qt_word_t; /* This macro is used by "QUICKTHREADS_ARGS" to initialize a single argument thread. * - set "qt_start" as the "qt_block" or "qt_blocki" return address; * - set the top of the stack backchain; * - set the next backchain (not needed, but just to be "clean"). */ #define QUICKTHREADS_ARGS_MD(sp) \ (QUICKTHREADS_SPUT (sp, QUICKTHREADS_RETURN_INDEX, qt_start), \ QUICKTHREADS_SPUT (sp, 0, sp+QUICKTHREADS_BLOCKI_FRAME_SIZE), \ QUICKTHREADS_SPUT (sp, QUICKTHREADS_BLOCKI_FRAME_SIZE/sizeof(PPC_W), \ sp+QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_START_FRAME_SIZE)) /* This macro is used by "QUICKTHREADS_VARGS" to initialize a variant argument thread. * It returns the pointer to the top of the argument list. * We also use it to get the stack bottom via a static variable. This is a bit * "dirty", it could be better to do it in "qt_vargs", but we don't want change * anything out of this file. * We need the stack bottom to allocate a local variable area used by * "qt_vstart". */ #define QUICKTHREADS_VARGS_MD0(sp, varbytes) \ ((qt_sp_bottom_save = sp), \ ((qt_t *)(((char *)(sp)) - \ (QUICKTHREADS_VSTART_FRAME_SIZE(varbytes)-QUICKTHREADS_VSTART_LIST_BASE)))) /* This macro is used by "QUICKTHREADS_VARGS" to initialize a variant argument thread. * - set "qt_start" as the "qt_block" or "qt_blocki" return address; * - set the top of the stackback chain; * - set the next backchain (it points the stack botton). */ #define QUICKTHREADS_VARGS_MD1(sp) \ (QUICKTHREADS_SPUT (sp, QUICKTHREADS_RETURN_INDEX, qt_vstart), \ QUICKTHREADS_SPUT (sp, 0, sp+QUICKTHREADS_BLOCKI_FRAME_SIZE), \ QUICKTHREADS_SPUT (sp, (QUICKTHREADS_BLOCKI_FRAME_SIZE)/sizeof(PPC_W), \ qt_sp_bottom_save)) /* Activate "qt_vargs" as the initialization routine for the variant * argument threads */ #define QUICKTHREADS_VARGS_DEFAULT /* Override "qt_vargs" with "qt_vargs_stdarg". * On LinuxPPC "qt_vargs" doesn't work, "qt_vargs_stdarg" uses a more * standard way to retrieve arguments from the variant list. */ #define QUICKTHREADS_VARGS(sp, nbytes, vargs, pt, startup, vuserf, cleanup) \ ((qt_t *)qt_vargs_stdarg (sp, nbytes, vargs, pt, startup, vuserf, cleanup)) /* This macro is used by "QUICKTHREADS_ADJ(sp)" to get the stack top form the stack * bottom during a single argument thread initialization. * It is the space we need to allocate for a single argument thread: the stack * frame for the block routine ("qt_block" or "qt_blocki") and for "qt_start". */ #define QUICKTHREADS_STKBASE \ (QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_START_FRAME_SIZE) /* This macro is used by "QUICKTHREADS_VADJ(sp)" to get the stack top from the base * of the variant argument list during a variant argument thread initialization. */ #define QUICKTHREADS_VSTKBASE (QUICKTHREADS_BLOCKI_FRAME_SIZE+QUICKTHREADS_VSTART_LIST_BASE) /* The *index* (positive offset) of where to put each value. */ #define QUICKTHREADS_ARGU_INDEX QUICKTHREADS_ARG_INDEX(0) #define QUICKTHREADS_ARGT_INDEX QUICKTHREADS_ARG_INDEX(1) #define QUICKTHREADS_USER_INDEX QUICKTHREADS_ARG_INDEX(2) #define QUICKTHREADS_ONLY_INDEX QUICKTHREADS_ARG_INDEX(3) #define QUICKTHREADS_VARGT_INDEX QUICKTHREADS_ARG_INDEX(0) #define QUICKTHREADS_VSTARTUP_INDEX QUICKTHREADS_ARG_INDEX(1) #define QUICKTHREADS_VUSERF_INDEX QUICKTHREADS_ARG_INDEX(2) #define QUICKTHREADS_VCLEANUP_INDEX QUICKTHREADS_ARG_INDEX(3) #endif /* ndef QUICKTHREADS_POWERPC_H */