//
// windowspill.S  --  register window spill routine
//
// $Id: //depot/rel/Foxhill/dot.8/Xtensa/OS/hal/windowspill_asm.S#1 $

// Copyright (c) 1999-2010 Tensilica Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#include <xtensa/coreasm.h>


//  xthal_window_spill_nw
//
//  Spill live register windows to the stack.
//
//  Required entry conditions:
//	PS.WOE = 0
//	PS.INTLEVEL >= XCHAL_EXCM_LEVEL
//	a1 = valid stack pointer (note: some regs may be spilled at a1-16)
//	a0 = return PC (usually set by call0 or callx0 when calling this function)
//	a2,a3 undefined
//	a4 thru a15 valid, if they are part of window(s) to be spilled
//     (Current window a0..a15 saved if necessary.)
//	WINDOWSTART[WINDOWBASE] = 1
//
//  Exit conditions:
//	PS.WOE, PS.INTLEVEL = same as on entry
//	WINDOWBASE = same as on entry
//	WINDOWSTART updated to reflect spilled windows
//		(equals 1<<WINDOWBASE if successful return)
//	a0 = return PC
//	a1 = same as on entry
//	a2 = error code:
//		0 --> successful
//			(WINDOWSTART = 1<<WINDOWBASE)
//		1 --> invalid WINDOWSTART (WINDOWBASE bit not set)
//			(WINDOWSTART unchanged)
//		2 --> invalid window size (not 4, 8 or 12 regs)
//			(WINDOWSTART bits of successfully spilled
//			 windows are cleared, others left intact)
//	a3 clobbered
//	a4,a5,a8,a9,a12,a13 = same as on entry
//	a6,a7,a10,a11,a14,a15 clobbered if they were part of window(s)
//		to be spilled, otherwise they are the same as on entry
//	loop registers (LCOUNT,LBEG,LEND) are NOT affected (they were in earlier versions)
//	SAR clobbered
//
//  All non-spilled register windows will be spilled.
//  Beware that this may include a4..a15 of the current window,
//  so generally these should not have been clobbered by the
//  caller if it is at all possible that these registers
//  are part of an unspilled window (it often is possible)
//  (otherwise the spilled stack would be invalid).
//
//  THIS MEANS: the caller is responsible for saving a0-a15 but
//  the caller must leave a4-a15 intact when control is transferred
//  here.
//
//  It may be reentrant (but stack pointer is invalid during
//  execution due to window rotations, so can't take interrupts
//  and exceptions in the usual manner, so ... what does
//  reentrancy really mean here?).


	//  The xthal_spill_registers_into_stack_nw entry point
	//  is kept here only for backwards compatibility.
	//  It will be removed in the very near future.
	.global	xthal_spill_registers_into_stack_nw

	.text
	.align 4
	.global	xthal_window_spill_nw
xthal_window_spill_nw:
xthal_spill_registers_into_stack_nw:	// BACKWARD COMPATIBILITY ONLY - see above

#if ! XCHAL_HAVE_WINDOWED
	//  Nothing to do -- window option was not selected.
	movi	a2, 0		// always report success
	ret
#else /* XCHAL_HAVE_WINDOWED */
#define WSBITS	(XCHAL_NUM_AREGS / 4)		/* width of WINDOWSTART register in bits */
#define WBBITS	(XCHAL_NUM_AREGS_LOG2 - 2)	/* width of WINDOWBASE register in bits */
	/*
	 * Rearrange (rotate) window start bits relative to the current
	 * window (WINDOWBASE).  WINDOWSTART currently looks like this:
	 *
	 *          a15-a0
	 * NAREG-1   |  |    0
	 *    |      vvvv    |
	 *    xxxxxxxxxx1yyyyy
	 *              ^
	 *              |
	 *              WINDOWBASE
	 *
	 * The start bit pointed to by WINDOWBASE must be set
	 * (we return an error if it isn't), as it corresponds
	 * to the start of the current window (shown as a0-a15).
	 *
	 * We want the window start bits rotated to look like this:
	 *              1yyyyyxxxxxxxxxx
	 *
	 * Note that there is one start bit for every four registers;
	 * and the total number of registers (NAREG) can be 32 or 64;
	 * so the number of start bits in WINDOWSTART is NAREG/4,
	 * and the size of WINDOWSTART can be 8 or 16.
	 */

	rsr.windowbase	a2
	addi	a2, a2, 1
	ssr	a2		// sar = WINDOWBASE + 1
	rsr.windowstart	a3
	srl	a2, a3		// a2 is 0... | 000000xxxxxxxxxx = WINDOWSTART >> sar
	sll	a3, a3		// a3 is 1yyyyy0000000000 | 0... = WINDOWSTART << (32 - sar)
	bgez	a3, .Linvalid_ws	// verify that msbit is indeed set

	srli	a3, a3, 32-WSBITS	// a3 is 0... | 1yyyyy0000000000 = a3 >> (32-NAREG/4)
	or	a2, a2, a3		// a2 is 0... | 1yyyyyxxxxxxxxxx

	/*
	 *	FIND THE FIRST ONE
	 *
	 *  Now we have (in a2) the window start bits rotated in order
	 *  from oldest (closest to lsbit) to current (msbit set).
	 *  Each start bit (that is set), other than the current one,
	 *  corresponds to a window frame to spill.
	 *
	 *  Now find the first start bit, ie. the first frame to spill,
	 *  by looking for the first bit set in a2 (from lsbit side).
	 */

#if XCHAL_HAVE_NSA
	neg     a3, a2		// keep only the least-significant bit set of a2 ...
	and     a3, a3, a2	// ... in a3
	nsau    a3, a3		// get index of that bit, numbered from msbit (32 if absent)
	ssl	a3		// set sar = 32 - a3 = bit index numbered from lsbit + 1
#else /* XCHAL_HAVE_NSA */
	wsr.windowstart	a2	// temporarily save rotated start bits
				// (we can use WINDOWSTART because WOE=0)

	//  NOTE:  this could be optimized a bit, by explicit coding rather than the macro.
	find_ls_one	a3, a2	// set a3 to index of lsmost bit set in a2 (a2 clobbered)

	addi	a2, a3, 1	// index+1
	ssr	a2		// set sar = index + 1
	rsr.windowstart	a2	// restore a2 (rotated start bits)
#endif /* XCHAL_HAVE_NSA */
	srl	a2, a2		// right-justify the rotated start bits (dropping lsbit set)
	wsr.windowstart	a2	// save rotated + justified window start bits,
				//  because a2 will disappear when modifying WINDOWBASE
				// again, we can use WINDOWSTART because WOE=0

	/*
	 *  Rotate WindowBase so that a0 of the next window to spill is in a4
	 *  (ie. leaving us with a2 and a3 to play with, because a0 and a1
	 *  may be those of the original window which we must preserve).
	 */
	rsr.windowbase	a2
#if XCHAL_HAVE_NSA
	addi	a2, a2, 31
	sub	a3, a2, a3	// a3 = WINDOWBASE + index = WINDOWBASE + (31 - msbit_index)
#else /* XCHAL_HAVE_NSA */
	add	a3, a2, a3	// a3 = WINDOWBASE + index
#endif /* XCHAL_HAVE_NSA */
	wsr.windowbase	a3	// effectively do:  rotw index
	rsync			// wait for write to WINDOWBASE to complete
	//  Now our registers have changed!

	rsr.windowstart	a2	// restore a2 (rotated + justified window start bits)

	/*
	 *  We are now ready to start the window spill loop.
	 *  Relative to the above, a2 and WINDOWBASE are now as follows:
	 *
	 *        1yyyyyxxxxxxxxxx = rotated start bits as shown above
	 *        1yyyyyxxxx100000 = actual rotated start bits (example)
	 *  0000001yyyyyxxxx ^     = a2 = rotated + justified start bits
	 *        ^      xxx1^     = window being spilled
	 *        ^          ^
	 *        |          |
	 *    original    current
	 *   WINDOWBASE  WINDOWBASE
	 *
	 *  The first window to spill (save) starts at what is now a4.
	 *  The spill loop maintains the adjusted start bits in a2,
	 *  shifting them right as each window is spilled.
	 */

.Lspill_loop:
	//  Top of save loop.
	//  Find the size of this call and branch to the appropriate save routine.

	beqz	a2, .Ldone		// if no start bit remaining, we're done
	bbsi.l	a2, 0, .Lspill4		// if next start bit is set, it's a call4
	bbsi.l	a2, 1, .Lspill8		// if 2nd next bit set, it's a call8
	bbsi.l	a2, 2, .Lspill12	// if 3rd next bit set, it's a call12
	j	.Linvalid_window	// else it's an invalid window!



	// SAVE A CALL4
.Lspill4:
	addi	a3, a9, -16	// a3 gets call[i+1]'s sp - 16
	s32i	a4, a3, 0	// store call[i]'s a0
	s32i	a5, a3, 4	// store call[i]'s a1
	s32i	a6, a3, 8	// store call[i]'s a2
	s32i	a7, a3, 12	// store call[i]'s a3

	srli	a6, a2, 1	// move and shift the start bits
	rotw	1		// rotate the window

	j	.Lspill_loop

	// SAVE A CALL8
.Lspill8:
	addi	a3, a13, -16	// a0 gets call[i+1]'s sp - 16
	s32i	a4, a3, 0	// store call[i]'s a0
	s32i	a5, a3, 4	// store call[i]'s a1
	s32i	a6, a3, 8	// store call[i]'s a2
	s32i	a7, a3, 12	// store call[i]'s a3

	addi	a3, a5, -12	// call[i-1]'s sp address
	l32i	a3, a3, 0	// a3 is call[i-1]'s sp
			// (load slot)
	addi	a3, a3, -32	// a3 points to our spill area

	s32i	a8, a3, 0	// store call[i]'s a4
	s32i	a9, a3, 4	// store call[i]'s a5
	s32i	a10, a3, 8	// store call[i]'s a6
	s32i	a11, a3, 12	// store call[i]'s a7

	srli	a10, a2, 2	// move and shift the start bits
	rotw	2		// rotate the window

	j	.Lspill_loop

	// SAVE A CALL12
.Lspill12:
	rotw	1		// rotate to see call[i+1]'s sp

	addi	a13, a13, -16	// set to the reg save area
	s32i	a0, a13, 0	// store call[i]'s a0
	s32i	a1, a13, 4	// store call[i]'s a1
	s32i	a2, a13, 8	// store call[i]'s a2
	s32i	a3, a13, 12	// store call[i]'s a3

	addi	a3, a1, -12	// call[i-1]'s sp address
	l32i	a3, a3, 0	// a3 has call[i-1]'s sp
	addi	a13, a13, 16	// restore call[i+1]'s sp (here to fill load slot)
	addi	a3, a3, -48	// a3 points to our save area

	s32i	a4, a3, 0	// store call[i]'s a4
	s32i	a5, a3, 4	// store call[i]'s a5
	s32i	a6, a3, 8	// store call[i]'s a6
	s32i	a7, a3, 12	// store call[i]'s a7
	s32i	a8, a3, 16	// store call[i]'s a4
	s32i	a9, a3, 20	// store call[i]'s a5
	s32i	a10, a3, 24	// store call[i]'s a6
	s32i	a11, a3, 28	// store call[i]'s a7

	rotw	-1		// rotate to see start bits (a2)
	srli	a14, a2, 3	// move and shift the start bits
	rotw	3		// rotate to next window

	j	.Lspill_loop



.Ldone:
	rotw	1		// back to the original window
	rsr.windowbase	a2	// get (original) window base
	ssl	a2		// setup for shift left by WINDOWBASE
	movi	a2, 1
	sll	a2, a2		// compute new WINDOWSTART = 1<<WINDOWBASE
	wsr.windowstart	a2	// and apply it
	rsync
	movi	a2, 0		// done!
	ret
	//jx	a0


	//  Invalid WINDOWSTART register.
	//
.Linvalid_ws:
	movi	a2, 1		// indicate invalid WINDOWSTART
	ret			// return from subroutine


	//  Invalid window size!
	//  The three bits following the start bit are all clear, so
	//  we have an invalid window state (can't determine a window size).
	//
	//  So we exit with an error, but to do that we must first restore
	//  the original WINDOWBASE.  We also compute a sensible
	//  WINDOWSTART that has the start bits of spilled windows
	//  cleared, but all other start bits intact, so someone debugging
	//  the failure can look at WINDOWSTART to see which window
	//  failed to spill.
	//
.Linvalid_window:
	slli	a2, a2, 1	// space for missing start bit
	addi	a2, a2, 1	// add missing start bit
	rsr.windowbase	a3	// get current WINDOWBASE
	bbsi.l	a2, WSBITS-1, 2f	// branch if current WINDOWBASE==original
1:	addi	a3, a3, -1	// decrement towards original WINDOWBASE
	slli	a2, a2, 1	// shift towards original WINDOWSTART alignment
	bbci.l	a2, WSBITS-1, 1b	// repeat until ms start bit set
	extui	a3, a3, 0, WBBITS	// mask out upper base bits, in case of carry-over
2:	//  Here, a3 = original WINDOWBASE;
	//  and msbit of start bits in a2 is set, and no other bits above it.
	//  Now rotate a2 to become the correct WINDOWSTART.
	ssl	a3		// set shift left ... (sar = 32 - orig WB)
	slli	a3, a2, 32-WSBITS	// left-justify start bits
	src	a2, a2, a3	// rotate left by original WINDOWBASE
	extui	a2, a2, 0, WSBITS	// keep only significant start bits
	wsr.windowstart	a2	// we've cleared only start bits of spilled windows
	rsr.sar	a3		// retrieve 32 - original WINDOWBASE
	movi	a2, 32
	sub	a3, a2, a3	// restore original WINDOWBASE
	wsr.windowbase	a3	// back to original WINDOWBASE
	rsync

	movi	a2, 2		// indicate invalid window size
	ret

#endif /* XCHAL_HAVE_WINDOWED */

	.size	xthal_window_spill_nw, . - xthal_window_spill_nw


//  void  xthal_window_spill (void);
//
//  Spill live register windows to the stack.
//
//  This will spill all register windows except this
//  function's window, and possibly that of its caller.
//  (Currently, the caller's window is spilled and reloaded
//   when this function returns.  This may change with
//   future optimisations.)
//
//  Another, simpler way to implement this might be
//  to use an appropriate sequence of call/entry/retw
//  instructions to force overflow of any live windows.
//
//  Assumes that PS.INTLEVEL=0 and PS.WOE=1 on entry/exit.
//
	.text
	.align 4
	.global	xthal_window_spill
	.type	xthal_window_spill,@function
xthal_window_spill:
	abi_entry
#if XCHAL_HAVE_WINDOWED
	movi	a6, ~(PS_WOE_MASK|PS_INTLEVEL_MASK)	// (using a6 ensures any window using this a4..a7 is spilled)
	rsr.ps	a5
	mov	a4, a0			 // save a0
	and	a2, a5, a6		 // clear WOE, INTLEVEL
	addi	a2, a2, XCHAL_EXCM_LEVEL // set INTLEVEL = XCHAL_EXCM_LEVEL
	wsr.ps	a2			 // apply to PS
	rsync
	call0	xthal_window_spill_nw
	mov	a0, a4		// restore a0
	wsr.ps	a5		// restore PS
	rsync
#endif /* XCHAL_HAVE_WINDOWED */
	abi_return

	.size	xthal_window_spill, . - xthal_window_spill