/****************************************************************************
* arch/xtensa/src/common/xtensa_window_vector.S
*
* Adapted from use in NuttX by:
*
* Copyright (C) 2016 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Derives from logic originally provided by Cadence Design Systems Inc.
*
* Copyright (c) 2006-2015 Cadence Design Systems 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.
*
****************************************************************************/
.file "xtensa_window_vector.S"
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <arch/xtensa/xtensa_specregs.h>
#include <arch/xtensa/core.h>
#include <arch/chip/core-isa.h>
/****************************************************************************
* Window Vectors
****************************************************************************/
/* WINDOW OVERFLOW AND UNDERFLOW EXCEPTION VECTORS AND ALLOCA EXCEPTION HANDLER
*
* Here is the code for each window overflow/underflow exception vector and
* (interspersed) efficient code for handling the alloca exception cause.
* Window exceptions are handled entirely in the vector area and are very
* tight for performance. The alloca exception is also handled entirely in
* the window vector area so comes at essentially no cost in code size.
* Users should never need to modify them and Cadence Design Systems recommends
* they do not.
*
* Window handlers go at predetermined vector locations according to the
* Xtensa hardware configuration, which is ensured by their placement in a
* special section known to the Xtensa linker support package (LSP). Since
* their offsets in that section are always the same, the LSPs do not define
* a section per vector.
*
* These things are coded for XEA2 only (XEA1 is not supported).
*
* Note on Underflow Handlers:
* The underflow handler for returning from call[i+1] to call[i]
* must preserve all the registers from call[i+1]'s window.
* In particular, 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.
*/
#if XCHAL_HAVE_WINDOWED
.section .window_vectors.text, "ax"
/* Window Overflow Exception for Call4.
*
* Invoked if a call[i] referenced a register (a4-a15) that contains data from
* ancestor call[j]; call[j] had done a call4 to call[j+1].
*
* On entry here:
* window rotated to call[j] start point;
* a0-a3 are registers to be saved;
* a4-a15 must be preserved;
* a5 is call[j+1]'s stack pointer.
*/
.org 0x0
.global _window_overflow4
_window_overflow4:
s32e a0, a5, -16 /* Save a0 to call[j+1]'s stack frame */
s32e a1, a5, -12 /* Save a1 to call[j+1]'s stack frame */
s32e a2, a5, -8 /* Save a2 to call[j+1]'s stack frame */
s32e a3, a5, -4 /* Save a3 to call[j+1]'s stack frame */
#ifdef CONFIG_XTENSA_HAVE_WINDOW_EXCEPTION_HOOKS
j _overflow4_exit_hook
#else
rfwo /* Rotates back to call[i] position */
#endif
/* Window Underflow Exception for Call4
*
* Invoked by RETW returning from call[i+1] to call[i] where call[i]'s
* registers must be reloaded (not live in ARs); where call[i] had done a
* call4 to call[i+1].
*
* On entry here:
* window rotated to call[i] start point;
* a0-a3 are undefined, must be reloaded with call[i].reg[0..3];
* a4-a15 must be preserved (they are call[i+1].reg[0..11]);
* a5 is call[i+1]'s stack pointer.
*/
.org 0x40
.global _window_underflow4
_window_underflow4:
l32e a0, a5, -16 /* Restore a0 from call[i+1]'s stack frame */
l32e a1, a5, -12 /* Restore a1 from call[i+1]'s stack frame */
l32e a2, a5, -8 /* Restore a2 from call[i+1]'s stack frame */
l32e a3, a5, -4 /* Restore a3 from call[i+1]'s stack frame */
#ifdef CONFIG_XTENSA_HAVE_WINDOW_EXCEPTION_HOOKS
j _underflow4_exit_hook
#else
rfwu
#endif
/* Handle alloca exception generated by interruptee executing 'movsp'.
* This uses space between the window vectors, so is essentially "free".
* All interruptee's regs are intact except a0 which is saved in EXCSAVE_1,
* and PS.EXCM has been set by the exception hardware (can't be interrupted).
* The fact the alloca exception was taken means the registers associated with
* the base-save area have been spilled and will be restored by the underflow
* handler, so those 4 registers are available for scratch.
* The code is optimized to avoid unaligned branches and minimize cache misses.
*/
.align 4
.global _xtensa_alloca_handler
_xtensa_alloca_handler:
rsr a0, WINDOWBASE /* Grab WINDOWBASE before rotw changes it */
rotw -1 /* WINDOWBASE goes to a4, new a0-a3 are scratch */
rsr a2, PS
extui a3, a2, XCHAL_PS_OWB_SHIFT, XCHAL_PS_OWB_BITS
xor a3, a3, a4 /* Bits changed from old to current windowbase */
rsr a4, EXCSAVE_1 /* Restore original a0 (now in a4) */
slli a3, a3, XCHAL_PS_OWB_SHIFT
xor a2, a2, a3 /* Flip changed bits in old window base */
wsr a2, PS /* Update PS.OWB to new window base */
rsync
_bbci.l a4, 31, _window_underflow4
rotw -1 /* Original a0 goes to a8 */
_bbci.l a8, 30, _window_underflow8
rotw -1
j _window_underflow12
/* Window Overflow Exception for Call8
*
* Invoked if a call[i] referenced a register (a4-a15) that contains data from
* ancestor call[j]; call[j] had done a call8 to call[j+1].
*
* On entry here:
* window rotated to call[j] start point;
* a0-a7 are registers to be saved;
* a8-a15 must be preserved;
* a9 is call[j+1]'s stack pointer.
*/
.org 0x80
.global _window_overflow8
_window_overflow8:
s32e a0, a9, -16 /* Save a0 to call[j+1]'s stack frame */
l32e a0, a1, -12 /* a0 <- call[j-1]'s sp
* (used to find end of call[j]'s frame) */
s32e a1, a9, -12 /* Save a1 to call[j+1]'s stack frame */
s32e a2, a9, -8 /* Save a2 to call[j+1]'s stack frame */
s32e a3, a9, -4 /* Save a3 to call[j+1]'s stack frame */
s32e a4, a0, -32 /* Save a4 to call[j]'s stack frame */
s32e a5, a0, -28 /* Save a5 to call[j]'s stack frame */
s32e a6, a0, -24 /* Save a6 to call[j]'s stack frame */
s32e a7, a0, -20 /* Save a7 to call[j]'s stack frame */
#ifdef CONFIG_XTENSA_HAVE_WINDOW_EXCEPTION_HOOKS
j _overflow8_exit_hook
#else
rfwo /* Rotates back to call[i] position */
#endif
/* Window Underflow Exception for Call8
*
* Invoked by RETW returning from call[i+1] to call[i] where call[i]'s
* registers must be reloaded (not live in ARs); where call[i] had done a
* call8 to call[i+1].
*
* On entry here:
* window rotated to call[i] start point;
* a0-a7 are undefined, must be reloaded with call[i].reg[0..7];
* a8-a15 must be preserved (they are call[i+1].reg[0..7]);
* a9 is call[i+1]'s stack pointer.
*/
.org 0xc0
.global _window_underflow8
_window_underflow8:
l32e a0, a9, -16 /* Restore a0 from call[i+1]'s stack frame */
l32e a1, a9, -12 /* Restore a1 from call[i+1]'s stack frame */
l32e a2, a9, -8 /* Restore a2 from call[i+1]'s stack frame */
l32e a7, a1, -12 /* a7 <- call[i-1]'s sp
* (used to find end of call[i]'s frame) */
l32e a3, a9, -4 /* Restore a3 from call[i+1]'s stack frame */
l32e a4, a7, -32 /* Restore a4 from call[i]'s stack frame */
l32e a5, a7, -28 /* Restore a5 from call[i]'s stack frame */
l32e a6, a7, -24 /* Restore a6 from call[i]'s stack frame */
l32e a7, a7, -20 /* Restore a7 from call[i]'s stack frame */
#ifdef CONFIG_XTENSA_HAVE_WINDOW_EXCEPTION_HOOKS
j _underflow8_exit_hook
#else
rfwu
#endif
/* Window Overflow Exception for Call12
*
* Invoked if a call[i] referenced a register (a4-a15) that contains data
* from ancestor call[j]; call[j] had done a call12 to call[j+1].
*
* On entry here:
* window rotated to call[j] start point;
* a0-a11 are registers to be saved;
* a12-a15 must be preserved;
* a13 is call[j+1]'s stack pointer.
*/
.org 0x100
.global _window_overflow12
_window_overflow12:
s32e a0, a13, -16 /* Save a0 to call[j+1]'s stack frame */
l32e a0, a1, -12 /* a0 <- call[j-1]'s sp
* (used to find end of call[j]'s frame) */
s32e a1, a13, -12 /* Save a1 to call[j+1]'s stack frame */
s32e a2, a13, -8 /* Save a2 to call[j+1]'s stack frame */
s32e a3, a13, -4 /* Save a3 to call[j+1]'s stack frame */
s32e a4, a0, -48 /* Save a4 to end of call[j]'s stack frame */
s32e a5, a0, -44 /* Save a5 to end of call[j]'s stack frame */
s32e a6, a0, -40 /* Save a6 to end of call[j]'s stack frame */
s32e a7, a0, -36 /* Save a7 to end of call[j]'s stack frame */
s32e a8, a0, -32 /* Save a8 to end of call[j]'s stack frame */
s32e a9, a0, -28 /* Save a9 to end of call[j]'s stack frame */
s32e a10, a0, -24 /* Save a10 to end of call[j]'s stack frame */
s32e a11, a0, -20 /* Save a11 to end of call[j]'s stack frame */
rfwo /* Rotates back to call[i] position */
/* Window Underflow Exception for Call12
*
* Invoked by RETW returning from call[i+1] to call[i] where call[i]'s
* registers must be reloaded (not live in ARs); where call[i] had done a
* call12 to call[i+1].
*
* On entry here:
* window rotated to call[i] start point;
* a0-a11 are undefined, must be reloaded with call[i].reg[0..11];
* a12-a15 must be preserved (they are call[i+1].reg[0..3]);
* a13 is call[i+1]'s stack pointer.
*/
.org 0x140
.global _window_underflow12
_window_underflow12:
l32e a0, a13, -16 /* Restore a0 from call[i+1]'s stack frame */
l32e a1, a13, -12 /* Restore a1 from call[i+1]'s stack frame */
l32e a2, a13, -8 /* Restore a2 from call[i+1]'s stack frame */
l32e a11, a1, -12 /* a11 <- call[i-1]'s sp
* (used to find end of call[i]'s frame) */
l32e a3, a13, -4 /* Restore a3 from call[i+1]'s stack frame */
l32e a4, a11, -48 /* Restore a4 from end of call[i]'s stack frame */
l32e a5, a11, -44 /* Restore a5 from end of call[i]'s stack frame */
l32e a6, a11, -40 /* Restore a6 from end of call[i]'s stack frame */
l32e a7, a11, -36 /* Restore a7 from end of call[i]'s stack frame */
l32e a8, a11, -32 /* Restore a8 from end of call[i]'s stack frame */
l32e a9, a11, -28 /* Restore a9 from end of call[i]'s stack frame */
l32e a10, a11, -24 /* Restore a10 from end of call[i]'s stack frame */
l32e a11, a11, -20 /* Restore a11 from end of call[i]'s stack frame */
rfwu
#endif /* XCHAL_HAVE_WINDOWED */