blob: 8c0730704429d477f46862cd0858c9fb06b96ea2 [file] [log] [blame]
/*
+ * 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 <kenaaker@silverbacksystems.com>
+ *
+ * Marco Bucci <marco.bucci@inwind.it>
+ * 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 */