windv.s

uCOS-II ports on Tensilica HiFi330 core.

/* windv.S -- Register Window Overflow/Underflow Handlers
 *
 * This code is taken from example code in the Xtensa Microprocessor
 * Programmer's Guide.
 *
 * WARNING:  It is highly unlikely that this code works as is on your
 *	particular Xtensa processor configuration.  It is hardcoded
 *	for the specific processor configuration used for the
 *	examples in the Xtensa Microprocessor Programmer's Guide.
 *	(The example code did not use the Xtensa HAL to address this
 *	portability issue, for clarity's sake.)  Getting it to work
 *	on another processor configuration requires some modifications.
 */

/*
 * Copyright (c) 2003-2005 by Tensilica Inc.  ALL RIGHTS RESERVED.
 * These coded instructions, statements, and computer programs are the
 * copyrighted works and confidential proprietary information of Tensilica Inc.
 * They may not be modified, copied, reproduced, distributed, or disclosed to
 * third parties in any manner, medium, or form, in whole or in part, without
 * the prior written consent of Tensilica Inc.
 */

	.section .WindowVectors.text, "ax"
	.begin  literal_prefix .WindowVectors
	.align  4


// Exports
.global _WindowOverflow4
.global _WindowUnderflow4
.global _WindowOverflow8
.global _WindowUnderflow8
.global _WindowOverflow12
.global _WindowUnderflow12

// Imports
//   None

// NOTE: The underflow handler for returning from call[i+1] to call[i] must
// preserve all the registers from call[i+1]'s window.  a0 and a1 must be
// preserved because the retw instruction will be reexecuted (and may even
// underflow if an intervening exception has flushed call[i]'s registers).
// Registers a2 and up may contain return values.

// inside call[i] referencing a register that
// contains data from call[j]
// On entry here: window rotated to call[j] start point; the
// registers to be saved are a0-a3; a4-a15 must be preserved
// a5 is call[j+1]'s stack pointer

	.align 64
_WindowOverflow4:
	addi    a5, a5, -16 // to make store offsets positive
	s32i    a0, a5,   0 // save a0 to call[j+1]'s stack frame
	s32i    a1, a5,   4 // save a1 to call[j+1]'s stack frame
	s32i    a2, a5,   8 // save a2 to call[j+1]'s stack frame
	s32i    a3, a5,  12 // save a3 to call[j+1]'s stack frame
	addi    a5, a5,  16 // restore a5
	rfwo                // rotates back to call[i] position

// returning from call[i+1] to call[i] where
// call[i]'s registers must be reloaded
// On entry here: a0-a3 will be reloaded with
// call[i].reg[0..3] but initially contain garbage.
// a4-a15 are call[i+1].reg[0..11],
// (in particular, a5 is call[i+1]'s stack pointer)
// and must be preserved

	.align 64
_WindowUnderflow4:
	addi    a3, a5, -16 // to make load offsets positive
	l32i    a0, a3,   0 // restore a0 from call[i+1]'s stack frame
	l32i    a1, a3,   4 // restore a1 from call[i+1]'s stack frame
	l32i    a2, a3,   8 // restore a2 from call[i+1]'s stack frame
	l32i    a3, a3,  12 // restore a3 from call[i+1]'s stack frame
	rfwu

// On entry here: window rotated to call[j]; the registers to be
// saved are a0-a7; a8-a15 must be preserved
// a9 is call[j+1]'s stack pointer

	.align 64
_WindowOverflow8:
	addi    a9, a9, -16 // to make store offsets positive
	s32i    a0, a9,   0 // save a0 to call[j+1]'s stack frame
	s32i    a1, a9,   4 // save a1 to call[j+1]'s stack frame
	s32i    a2, a9,   8 // save a2 to call[j+1]'s stack frame
	s32i    a3, a9,  12 // save a3 to call[j+1]'s stack frame
	addi    a9, a9,  16 // restore a9
	addi    a0, a1, -16 // a0 <- call[j-1]'s sp
	l32i    a0, a0,   4 // (used to find end of call[j]'s frame)
	addi    a0, a0, -32 // to make load offsets positive
	s32i    a4, a0,   0 // save a4 to call[j]'s stack frame
	s32i    a5, a0,   4 // save a5 to call[j]'s stack frame
	s32i    a6, a0,   8 // save a6 to call[j]'s stack frame
	s32i    a7, a0,  12 // save a7 to call[j]'s stack frame
	rfwo                // rotates back to call[i] position

// On entry here: a0-a7 are call[i].reg[0..7] and initially
// contain garbage, a8-a15 are call[i+1].reg[0..7],
// (in particular, a9 is call[i+1]'s stack pointer)
// and must be preserved

	.align 64
_WindowUnderflow8:
	addi    a9, a9, -16 // to make load offsets positive
	l32i    a0, a9,   0 // restore a0 from call[i+1]'s stack frame
	l32i    a1, a9,   4 // restore a1 from call[i+1]'s stack frame
	l32i    a2, a9,   8 // restore a2 from call[i+1]'s stack frame
	// don't restore a3 yet because we need it as a temporary
	addi    a3, a1, -16 // a3 <- call[i-1]'s sp
	l32i    a3, a3,   4 // (used to find end of call[i]'s frame)
	addi    a3, a3, -32 // to make load offsets positive
	l32i    a4, a3,   0 // restore a4 from call[i]'s stack frame
	l32i    a5, a3,   4 // restore a5 from call[i]'s stack frame
	l32i    a6, a3,   8 // restore a6 from call[i]'s stack frame
	l32i    a7, a3,  12 // restore a7 from call[i]'s stack frame
	// we're done with a3 and can restore it now
	l32i    a3, a9,  12 // restore a3 from call[i+1]'s stack frame
	addi    a9, a9,  16 // restore a9
	rfwu

// On entry here: window rotated to call[j]; the registers to be
// saved are a0-a11 ; a12-a15 must be preserved
// a13 is call[j+1]'s stack pointer

	.align 64
_WindowOverflow12:
	addi    a13, a13, -16 // to make store offsets positive
	s32i    a0,  a13,   0 // save a0 to call[j+1]'s stack frame
	s32i    a1,  a13,   4 // save a1 to call[j+1]'s stack frame
	s32i    a2,  a13,   8 // save a2 to call[j+1]'s stack frame
	s32i    a3,  a13,  12 // save a3 to call[j+1]'s stack frame
	addi    a13, a13,  16 // restore a13
	addi    a0,  a1,  -16 // a0 <- call[j-1]'s sp
	l32i    a0,  a0,    4 // (used to find end of call[j]'s frame)
	addi    a0,  a0,  -48 // to make load offsets positive
	s32i    a4,  a0,    0 // save a4 to end of call[j]'s stack frame
	s32i    a5,  a0,    4 // save a5 to end of call[j]'s stack frame
	s32i    a6,  a0,    8 // save a6 to end of call[j]'s stack frame
	s32i    a7,  a0,   12 // save a7 to end of call[j]'s stack frame
	s32i    a8,  a0,   16 // save a8 to end of call[j]'s stack frame
	s32i    a9,  a0,   20 // save a9 to end of call[j]'s stack frame
	s32i    a10, a0,   24 // save a10 to end of call[j]'s stack frame
	s32i    a11, a0,   28 // save a11 to end of call[j]'s stack frame
	rfwo                  // rotates back to call[i] position

// On entry here:
// a0-a11 are call[i].reg[0..11] and initially contain garbage
// a12-a15 are call[i+1].reg[0..3], (in particular, a13 is call[i+1]'s stack pointer)
// and must be preserved

	.align 64
_WindowUnderflow12:
	addi    a13, a13, -16 // to make load offsets positive
	l32i    a0,  a13,   0 // restore a0 from call[i+1]'s stack frame
	l32i    a1,  a13,   4 // restore a1 from call[i+1]'s stack frame
	l32i    a2,  a13,   8 // restore a2 from call[i+1]'s stack frame
	// don't restore a3 yet because we need it as a temporary
	addi    a3,  a1,  -16 // a3 <- call[i-1]'s sp
	l32i    a3,  a3,    4 // (used to find end of call[i]'s frame)
	addi    a3,  a3,  -48 // to make load offsets positive
	l32i    a4,  a3,    0 // restore a4 from end of call[i]'s stack frame
	l32i    a5,  a3,    4 // restore a5 from end of call[i]'s stack frame
	l32i    a6,  a3,    8 // restore a6 from end of call[i]'s stack frame
	l32i    a7,  a3,   12 // restore a7 from end of call[i]'s stack frame
	l32i    a8,  a3,   16 // restore a8 from end of call[i]'s stack frame
	l32i    a9,  a3,   20 // restore a9 from end of call[i]'s stack frame
	l32i    a10, a3,   24 // restore a10 from end of call[i]'s stack frame
	l32i    a11, a3,   28 // restore a11 from end of call[i]'s stack frame
	// we're done with a3 and can restore it now
	l32i    a3,  a13,  12 // restore a3 from call[i+1]'s stack frame
	addi    a13, a13,  16 // restore a13
	rfwu

//	.align 64

	.end literal_prefix