Subversion Repositories openrisc

;@(#)signal.s   2.15 90/10/14 21:57:55, AMD

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; Copyright 1990 Advanced Micro Devices, Inc.

;

; This software is the property of Advanced Micro Devices, Inc  (AMD)  which

; specifically  grants the user the right to modify, use and distribute this

; software provided this notice is not removed or altered.  All other rights

; are reserved by AMD.

;

; AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS

; SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL

; DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR

; USE OF THIS SOFTWARE.

;

; So that all may benefit from your experience, please report  any  problems

; or  suggestions about this software to the 29K Technical Support Center at

; 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or

; 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.

;

; Advanced Micro Devices, Inc.

; 29K Support Products

; Mail Stop 573

; 5900 E. Ben White Blvd.

; Austin, TX 78741

; 800-292-9263

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

        .file   "signal.s"

; SigEntry is the address of an array of C-level user code signal handlers.

; They must return to the top-level before doing a sigret() return function.

; Nested signals are supported.

        .extern V_SPILL, V_FILL

        .extern fill            ; In crt0.s

        .align  4

        .comm   WindowSize, 4

        .data

SigEntry:

        .word   0                ; reserved

        .word   0                ; adds. of #2 SIGINT handler

        .word   0                ; reserved

        .word   0                ; reserved

        .word   0                ; reserved

        .word   0                ; reserved

        .word   0                ; reserved

        .word   0                ; adds. of #8 SIGFPE handler

        .text

        .reg    v0,     gr96

        .reg    v1,     gr97

        .reg    v2,     gr98

        .reg    v3,     gr99

        .reg    tav,    gr121

        .reg    tpc,    gr122

        .reg    lrp,    gr123

        .reg    slp,    gr124

        .reg    msp,    gr125

        .reg    rab,    gr126

        .reg    rfb,    gr127

;=================================================================== setjmp()

; int

; setjmp(label_t jmpbuf)

; {

;       *jmpbuf = {gr1, msp, lr0, lr1};

;       return 0;

; }

;

        .global _setjmp

_setjmp:

        store   0, 0, gr1, lr2

        add     lr2, lr2, 4

        store   0, 0, msp, lr2

        add     lr2, lr2, 4

        store   0, 0, lr0, lr2

        add     lr2, lr2, 4

        store   0, 0, lr1, lr2

        jmpi    lr0

         const  v0, 0

;

;==================================================================== longjmp()

; int

; longjmp(label_t jmpbuf, int value)

; {

;       /* BUG: check for this

;         if (msp > jmpbuf->msp || gr1 > jmpbuf->gr1)

;               longjmperror();

;        */

;

;       gr1 = jmpbuf->gr1;

;       lr2addr = jmpbuf->gr1 + 8;

;       msp = jmpbuf->msp;

;

;       /* saved lr1 is invalid if saved lr2addr > rfb */

;       if (lr2addr > rfb) {

;               /*

;                * None of the registers are useful.

;                * Set rfb to lr2addr - 512 & rab to rfb - 512.

;                * the FILL assert will take care of filling

;                */

;               lr1 = jmpbuf->lr1;

;               rab = lr2addr - windowsize;

;               rfb = lr2addr;

;       }

;

;       lr0 = jmpbuf->lr0;

;       if (rfb < lr1)

;               raise V_FILL;

;       return value;

; }

;

        .global _longjmp

_longjmp:

        load    0, 0, tav, lr2          ; copy in gr1

        add     v1, lr2, 4              ; v1 points to msp

        ; make sure we return a non-zero value

        cpeq    v0, lr3, 0

        srl     v0, v0, 31

        or      v0, lr3, v0

        add     gr1, tav, 0             ; now update gr1

        add     tav, tav, 8             ; calculate lr2addr

        load    0, 0, msp, v1           ; update msp from jmpbuf

        cpleu   v3, tav, rfb            ; if (lr2addr > rfb)

        jmpt    v3, $1                  ; {

         add    v1, v1, 4               ; v1 points to lr0

        add     v2, v1, 4               ;       v2 points to lr1

        load    0, 0, lr1, v2           ;       lr1 = value from jmpbuf

        sub     v3, rfb, rab            ;

        sub     rab, tav, v3            ;       rab = lr2addr - windowsize

        add     rfb, tav, 0             ;       rfb = lr2addr

$1:     ; }

        load    0, 0, lr0, v1

        jmpi    lr0

         asgeu   V_FILL, rfb, lr1       ; may fill from rfb to lr1

;

;================================================================== sigcode

; About to deliver a signal to a user mode signal handler.

;       msp+(15*4) = signal_number

;       msp+(14*4) = gr1

;       msp+(13*4) = rab

;       msp+(12*4) = PC0

;       msp+(11*4) = PC1

;       msp+(10*4) = PC2

;       msp+( 9*4) = CHA

;       msp+( 8*4) = CHD

;       msp+( 7*4) = CHC

;       msp+( 6*4) = ALU

;       msp+( 5*4) = OPS

;       msp+( 4*4) = gr121

;       msp+( 3*4) = gr99

;       msp+( 2*4) = gr98

;       msp+( 1*4) = gr97

;       msp        = gr96

; The state of all the registers (except for msp, chc and rab)

; is the same as when the process was interrupted.

;

; We must make the stack and window consistent before calling the handler

; The orignal rab value is on the stack. The interrupt handler placed

; rfb-Windowsize in rab. This is required to support nested interrupts.

;

; Note that the window becomes incosistent only during certain

; critical sections in spill, fill, longjmp and sigcode.

;       rfb - rab > windowsize => we are in spill

;       rfb - rab < windowsize => we are in fill

;       gr1 + 8   > rfb        => we are in long-longjmp case

; In case of spill, fill and lonjmp; rab is modified first,

; so if we are in one of these critical sections,

; we set rab to rfb - WINDOWSIZE.

;

        .equ    SIGCTX_SIZE,            (16)*4

        .equ    SIGCTX_SIGNUMB,         (15)*4

        .equ    SIGCTX_GR1_OFFSET,      (14)*4

        .equ    SIGCTX_RAB_OFFSET,      (13)*4

        .equ    SIGCTX_PC0_OFFSET,      (12)*4

        .equ    SIGCTX_PC1_OFFSET,      (11)*4

        .equ    SIGCTX_PC2_OFFSET,      (10)*4

        .equ    SIGCTX_CHC_OFFSET,      (7)*4

        .equ    SIGCTX_OPS_OFFSET,      (5)*4

        .equ    SIGCTX_TAV_OFFSET,      (4)*4

        .global sigcode

sigcode:

; --------------------------------------------------------  R-Stack fixup

        const   v0, WindowSize          ; get register cache size

        consth  v0, WindowSize

        load    0, 0, v0, v0

        add     v2, msp, SIGCTX_RAB_OFFSET

        load    0, 0, v2, v2            ; get interrupted rab value

        sub     v1, rfb, v2             ; determine if  rfb-rab <= WINDOW_SIZE

        cpgeu   v1, v1, v0              ;

        jmpt    v1, nfill               ; jmp if spill or 'normal' interrupt

        add     v1, gr1, 8

         cpgt   v1, v1, rfb             ; interrupted longjmp can look like fill

        jmpf    v1, nfill               ; test for long-longjmp interruption

         nop                            ; jmp if gr1+8 <= rfb

; Fixup signal stack to re-start interrupted fill

; backup pc1 -- this is needed for the partial fill case.

; Clear chc so an interrupted load/store does not restart.

; Reset rab to a window distance below rfb, rab shall be

; decremented again on re-starting the interrupted fill.

; The interrupt handler set rab=rfb-WindowSize.

;

        add     v0, msp, SIGCTX_RAB_OFFSET

        store   0, 0, rab, v0           ; re-store (rfb-WindowSize) for rab

        const   v2, fill

        consth  v2, fill

        add     v0, msp, SIGCTX_PC1_OFFSET

        store   0, 0, v2, v0

        sub     v2, v2, 4               ; determine pc0

        add     v0, msp, SIGCTX_PC0_OFFSET

        store   0, 0, v2, v0

        const   v2, 0                   ; clear chc

        add     v0, msp, SIGCTX_CHC_OFFSET

        store   0, 0, v2, v0

nfill:

        cpgt    v0, gr1, rfb            ; if gr1 > rfb then gr1 = rfb

        jmpt    v0, lower

         cplt   v0, gr1, rab            ; if gr1 < rab then gr1 = rab

        jmpt    v0, raise

         nop

; -------------------------------------------------------- save_regs

sig1:   sub     msp, msp, (4+2+25)*4    ; reserve space for regs

        mfsr    gr96, ipc

        mfsr    gr97, ipa

        mfsr    gr98, ipb

        mfsr    gr99, q

        mtsrim  cr, 4-1

        storem  0, 0, gr96, msp

;                                        "push" registers stack support

        add     gr96, lr1, 0

        add     gr97, rfb, 0

        mtsrim  cr, 2-1

        add     gr99, msp, 2*4

        storem  0, 0, gr96, gr99

;                                         "push" remaining global registers

        mtsrim  cr, 25-1                ; gr100-gr124

        add     gr96, msp, (4+2)*4

        storem  0, 0, gr100, gr96

;

; -------------------------------------------------------- Dummy Call

        .equ    RALLOC, 4*4             ; make space for function calls

        add     v0, rfb, 0              ; store original rfb

        sub     gr1, gr1, RALLOC

        asgeu   V_SPILL, gr1, rab

        add     lr1, v0, 0              ; set lr1 = original rfb

        add     v1, msp, (4+2+25)*4 + SIGCTX_SIGNUMB

        load    0, 0, lr2, v1           ; restore signal number

        sub     v1, lr2, 1              ; get handler index

        sll     v1, v1, 2               ; point to addresses

;

; -------------------------------------------------------- call C-level

; Handler must not use HIF services other than the _sigret() type.

        const   v0, SigEntry

        consth  v0, SigEntry

        add     v0, v0, v1

        load    0, 0, v0, v0            ; determine if handler registered

        cpeq    v1, v0, 0

        jmpt    v1, NoHandler

         nop

        calli   lr0, v0                 ; call C-level signal handler

         nop

;

; -------------------------------------------------------- default return

NoHandler:

        jmp     __sigdfl

         nop

; -------------------------------------------------------- support bits

lower:  sll     gr1, rfb, 0

        jmp     sig1

         nop

raise:  sll     gr1, rab, 0

        jmp     sig1

         nop

/*

; -------------------------------------------------------- repair_regs

        mtsrim  cr, 4-1

        loadm   0, 0, gr96, msp

        mtsr    ipc, gr96

        mtsr    ipa, gr97

        mtsr    ipb, gr98

        mtsr    Q, gr99

;                                        "pop" registers stack support

        mtsrim  cr, 2-1

        add     gr99, msp, 2*4

        loadm   0, 0, gr96, gr99

        add     lr1, gr96, 0

        add     rfb, gr97, 0

;                                         "pop" remaining global registers

        mtsrim  cr, 25-1                ; gr100-gr124

        add     gr96, msp, (4+2)*4

        loadm   0, 0, gr100, gr96

        add     msp, msp, (4+2+25)*4    ; repair msp to save_regs entry value

; -------------------------------------------------------- end repair

*/

; ======================================================== _sigret()

        .global __sigret

__sigret:

;       repair_regs

; -------------------------------------------------------- repair_regs

        mtsrim  cr, 4-1

        loadm   0, 0, gr96, msp

        mtsr    ipc, gr96

        mtsr    ipa, gr97

        mtsr    ipb, gr98

        mtsr    q, gr99

;                                        "pop" registers stack support

        mtsrim  cr, 2-1

        add     gr99, msp, 2*4

        loadm   0, 0, gr96, gr99

        add     lr1, gr96, 0

        add     rfb, gr97, 0

;                                         "pop" remaining global registers

        mtsrim  cr, 25-1                ; gr100-gr124

        add     gr96, msp, (4+2)*4

        loadm   0, 0, gr100, gr96

        add     msp, msp, (4+2+25)*4    ; repair msp to save_regs entry value

; -------------------------------------------------------- end repair

        const   tav, 323                ; HIF _sigret

        asneq   69, gr1,gr1

        halt                            ; commit suicide if returns

; ======================================================== _sigdfl()

        .global __sigdfl

__sigdfl:

;       repair_regs

; -------------------------------------------------------- repair_regs

        mtsrim  cr, 4-1

        loadm   0, 0, gr96, msp

        mtsr    ipc, gr96

        mtsr    ipa, gr97

        mtsr    ipb, gr98

        mtsr    q, gr99

;                                        "pop" registers stack support

        mtsrim  cr, 2-1

        add     gr99, msp, 2*4

        loadm   0, 0, gr96, gr99

        add     lr1, gr96, 0

        add     rfb, gr97, 0

;                                         "pop" remaining global registers

        mtsrim  cr, 25-1                ; gr100-gr124

        add     gr96, msp, (4+2)*4

        loadm   0, 0, gr100, gr96

        add     msp, msp, (4+2+25)*4    ; repair msp to save_regs entry value

; -------------------------------------------------------- end repair

        const   tav, 322                ; HIF _sigdfl

        asneq   69, gr1,gr1

        halt                            ; commit suicide if returns

; ======================================================== _sigrep()

__sigrep:

        .global __sigrep

;       repair_regs

; -------------------------------------------------------- repair_regs

        mtsrim  cr, 4-1

        loadm   0, 0, gr96, msp

        mtsr    ipc, gr96

        mtsr    ipa, gr97

        mtsr    ipb, gr98

        mtsr    q, gr99

;                                        "pop" registers stack support

        mtsrim  cr, 2-1

        add     gr99, msp, 2*4

        loadm   0, 0, gr96, gr99

        add     lr1, gr96, 0

        add     rfb, gr97, 0

;                                         "pop" remaining global registers

        mtsrim  cr, 25-1                ; gr100-gr124

        add     gr96, msp, (4+2)*4

        loadm   0, 0, gr100, gr96

        add     msp, msp, (4+2+25)*4    ; repair msp to save_regs entry value

; -------------------------------------------------------- end repair

        const   tav, 324                ; HIF _sigrep

        asneq   69, gr1,gr1

        halt                            ; commit suicide if returns

; ======================================================== _sigskp()

        .global __sigskp

__sigskp:

;       repair_regs

; -------------------------------------------------------- repair_regs

        mtsrim  cr, 4-1

        loadm   0, 0, gr96, msp

        mtsr    ipc, gr96

        mtsr    ipa, gr97

        mtsr    ipb, gr98

        mtsr    q, gr99

;                                        "pop" registers stack support

        mtsrim  cr, 2-1

        add     gr99, msp, 2*4

        loadm   0, 0, gr96, gr99

        add     lr1, gr96, 0

        add     rfb, gr97, 0

;                                         "pop" remaining global registers

        mtsrim  cr, 25-1                ; gr100-gr124

        add     gr96, msp, (4+2)*4

        loadm   0, 0, gr100, gr96

        add     msp, msp, (4+2+25)*4    ; repair msp to save_regs entry value

; -------------------------------------------------------- end repair

        const   tav, 325                ; HIF _sigskp

        asneq   69, gr1,gr1

        halt                            ; commit suicide if returns

; ======================================================== _sendsig()

; lr2 = signal number

        .global _raise

        .global __sendsig

_raise:

__sendsig:

        const   tav, 326                ; HIF sendsig

        asneq   69, gr1,gr1

        jmpi    lr0

         nop

;

; ======================================================== signal()

;       lr2 = signal number

;       lr3 = handler address

        .global _signal

_signal:

; the memory variable WindowSize must be initalised at the

; start when rfb and rab are a window size apart.

        const   v0, WindowSize          ; get register cache size

        consth  v0, WindowSize

        load    0, 0, v1, v0

        cpeq    v1, v1, 0

        jmpf    v1, WindowSizeOK

         sub    v1, rfb, rab            ; rfb-rab = WINDOW_SIZE

        store   0, 0, v1, v0

WindowSizeOK:

        const   v1, SigEntry

        consth  v1, SigEntry

        sub     v3, lr2, 1              ; get handler index

        sll     v3, v3, 2               ; pointer to addresses

        add     v1, v1, v3

        store   0,0, lr3, v1            ; save new handler

        const   lr2, sigcode

        consth  lr2, sigcode

        ;Fall through to __signal

; ======================================================== _signal()

        .global __signal

__signal:

        const   tav, 321                ; HIF signal

        asneq   69, gr1,gr1

        jmpi    lr0

         nop