; pa-risc.s -- assembly support. ; 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. ; This file (pa-risc.s) is part of the port of QuickThreads for ; PA-RISC 1.1 architecture. This file implements context switches ; and thread startup. It was written in 1994 by Uwe Reder ; (`uereder@cip.informatik.uni-erlangen.de') for the Operating ; Systems Department (IMMD4) at the University of Erlangen/Nuernberg ; Germany. ; Callee saves general registers gr3..gr18, ; floating-point registers fr12..fr21. .CODE .IMPORT $$dyncall, MILLICODE .IMPORT qt_error, CODE .EXPORT qt_blocki, ENTRY .EXPORT qt_block, ENTRY .EXPORT qt_abort, ENTRY .EXPORT qt_start, ENTRY .EXPORT qt_vstart, ENTRY ; arg0: ptr to function (helper) to call once curr is suspended ; and control is on arg3's stack. ; arg1: 1'th arg to *arg0. ; arg2: 2'th arg to *arg0. ; arg3: sp of new thread. qt_blocki .PROC .CALLINFO CALLER, FRAME=0, SAVE_RP, ENTRY_GR=18 .ENTRY stw %rp,-20(%sp) ; save rp to old frame-marker stwm %r3,128(%sp) ; save callee-saves general registers stw %r4,-124(%sp) stw %r5,-120(%sp) stw %r6,-116(%sp) stw %r7,-112(%sp) stw %r8,-108(%sp) stw %r9,-104(%sp) stw %r10,-100(%sp) stw %r11,-96(%sp) stw %r12,-92(%sp) stw %r13,-88(%sp) stw %r14,-84(%sp) stw %r15,-80(%sp) stw %r16,-76(%sp) stw %r17,-72(%sp) stw %r18,-68(%sp) qt_abort copy %arg0,%r22 ; helper to be called by $$dyncall copy %sp,%arg0 ; pass current sp as arg0 to helper copy %arg3,%sp ; set new sp .CALL bl $$dyncall,%mrp ; call helper copy %mrp,%rp ldw -68(%sp),%r18 ; restore general registers ldw -72(%sp),%r17 ldw -76(%sp),%r16 ldw -80(%sp),%r15 ldw -84(%sp),%r14 ldw -88(%sp),%r13 ldw -92(%sp),%r12 ldw -96(%sp),%r11 ldw -100(%sp),%r10 ldw -104(%sp),%r9 ldw -108(%sp),%r8 ldw -112(%sp),%r7 ldw -116(%sp),%r6 ldw -120(%sp),%r5 ldw -124(%sp),%r4 ldw -148(%sp),%rp ; restore return-pointer bv %r0(%rp) ; return to caller ldwm -128(%sp),%r3 .EXIT .PROCEND qt_block .PROC .CALLINFO CALLER, FRAME=0, SAVE_RP, ENTRY_FR=21 .ENTRY stw %rp,-20(%sp) ; save rp to old frame-marker fstds,ma %fr12,8(%sp) ; save callee-saves float registers fstds,ma %fr13,8(%sp) fstds,ma %fr14,8(%sp) fstds,ma %fr15,8(%sp) fstds,ma %fr16,8(%sp) fstds,ma %fr17,8(%sp) fstds,ma %fr18,8(%sp) fstds,ma %fr19,8(%sp) fstds,ma %fr20,8(%sp) fstds,ma %fr21,8(%sp) .CALL bl qt_blocki,%rp ldo 48(%sp),%sp ldo -48(%sp),%sp fldds,mb -8(%sp),%fr21 ; restore callee-saves float registers fldds,mb -8(%sp),%fr20 fldds,mb -8(%sp),%fr19 fldds,mb -8(%sp),%fr18 fldds,mb -8(%sp),%fr17 fldds,mb -8(%sp),%fr16 fldds,mb -8(%sp),%fr15 fldds,mb -8(%sp),%fr14 fldds,mb -8(%sp),%fr13 ldw -28(%sp),%rp ; restore return-pointer bv %r0(%rp) ; return to caller. fldds,mb -8(%sp),%fr12 .EXIT .PROCEND qt_start .PROC .CALLINFO CALLER, FRAME=0 .ENTRY copy %r18,%arg0 ; set user arg `pu'. copy %r17,%arg1 ; ... user function pt. copy %r16,%arg2 ; ... user function userf. ; %r22 is a caller-saves register copy %r15,%r22 ; function to be called by $$dyncall .CALL ; in=%r22 bl $$dyncall,%mrp ; call `only'. copy %mrp,%rp bl,n qt_error,%r0 ; `only' erroniously returned. .EXIT .PROCEND ; Varargs ; ; First, call `startup' with the `pt' argument. ; ; Next, call the user's function with all arguments. ; We don't know whether arguments are integers, 32-bit floating-points or ; even 64-bit floating-points, so we reload all the registers, possibly ; with garbage arguments. The thread creator provided non-garbage for ; the arguments that the callee actually uses, so the callee never gets ; garbage. ; ; -48 -44 -40 -36 -32 ; | arg3 | arg2 | arg1 | arg0 | ; ----------------------------- ; integers: arg3 arg2 arg1 arg0 ; 32-bit fps: farg3 farg2 farg1 farg0 ; 64-bit fps: <---farg3--> <---farg1--> ; ; Finally, call `cleanup' with the `pt' argument and with the return value ; from the user's function. It is an error for `cleanup' to return. qt_vstart .PROC .CALLINFO CALLER, FRAME=0 .ENTRY ; Because the startup function may damage the fixed arguments ; on the stack (PA-RISC Procedure Calling Conventions Reference ; Manual, 2.4 Fixed Arguments Area), we allocate a seperate ; stack frame for it. ldo 64(%sp),%sp ; call: void startup(void *pt) copy %r15,%arg0 ; `pt' is arg0 to `startup'. copy %r16,%r22 .CALL bl $$dyncall,%mrp ; Call `startup'. copy %mrp,%rp ldo -64(%sp),%sp ; call: void *qt_vuserf_t(...) ldw -36(%sp),%arg0 ; Load args to integer registers. ldw -40(%sp),%arg1 ldw -44(%sp),%arg2 ldw -48(%sp),%arg3 ; Index of fld[w|d]s only ranges from -16 to 15, so we ; take r22 to be our new base register. ldo -32(%sp),%r22 fldws -4(%r22),%farg0 ; Load args to floating-point registers. fldds -8(%r22),%farg1 fldws -12(%r22),%farg2 fldds -16(%r22),%farg3 copy %r17,%r22 .CALL bl $$dyncall,%mrp ; Call `userf'. copy %mrp,%rp ; call: void cleanup(void *pt, void *vuserf_return) copy %r15,%arg0 ; `pt' is arg0 to `cleanup'. copy %ret0,%arg1 ; Return-value is arg1 to `cleanup'. copy %r18,%r22 .CALL bl $$dyncall,%mrp ; Call `cleanup'. copy %mrp,%rp bl,n qt_error,%r0 .EXIT .PROCEND