path: root/newlib/libc/sys/a29khif/signal.s

;@(#)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