Subversion Repositories openrisc_me

/*
 * Copyright (c) 1995, 1996, 1998 Cygnus Support
 *
 * The authors hereby grant permission to use, copy, modify, distribute,
 * and license this software and its documentation for any purpose, provided
 * that existing copyright notices are retained in all copies and that this
 * notice is included verbatim in any distributions. No written agreement,
 * license, or royalty fee is required for any of the authorized uses.
 * Modifications to this software may be copyrighted by their authors
 * and need not follow the licensing terms described here, provided that
 * the new terms are clearly indicated on the first page of each file where
 * they apply.
 */

#include "asm.h"
#include "slite.h"

        .text
        .align 4

/* 
 *  The trap table has to be the first code in a boot PROM.  But because
 *  the Memory Configuration comes up thinking we only have 4K of PROM, we
 *  cannot have a full trap table and still have room left over to 
 *  reprogram the Memory Configuration register correctly.  This file
 *  uses an abbreviated trap which has every entry which might be used
 *  before RTEMS installs its own trap table.
 */
        .globl  _trap_table
_trap_table:
  TRAP(SYM(ercinit));                           ! 00 reset trap 
  BAD_TRAP;                                     ! 01 instruction access exception
  TRAP(SYM(no_fpu));                            ! 02 illegal instruction
  BAD_TRAP;                                     ! 03 privileged instruction
  BAD_TRAP;                                     ! 04 fp disabled
  TRAP(SYM(win_overflow));                      ! 05 window overflow
  TRAP(SYM(win_underflow));                     ! 06 window underflow
  BAD_TRAP;                                     ! 07 memory address not aligned
  BAD_TRAP;                                     ! 08 fp exception
  BAD_TRAP;                                     ! 09 data access exception
  BAD_TRAP;                                     ! 0A tag overflow

  /* Trap levels from 0B to 0x10 are not defined (used for MEC init) */

SYM(ercinit):
  sethi         %hi(_ERC32_MEC), %g1            ! 0B
  sethi         %hi(0x001C1000), %g2
  or            %g1,%lo(0x001C1000),%g1
  st            %g2, [%g1 + 0x10]
  st            %g0, [%g1 + 0x18]                       ! 0C
  nop
  nop
  nop

  TRAP(SYM(hard_reset));                        ! 0D undefined
  BAD_TRAP;                                     ! 0E undefined
  BAD_TRAP;                                     ! 0F undefined
  BAD_TRAP;                                     ! 10 undefined

  /* 
   *  ERC32 defined traps
   */

  BAD_TRAP;                                     ! 11 masked errors
  BAD_TRAP;                                     ! 12 external 1
  BAD_TRAP;                                     ! 13 external 2
  BAD_TRAP;                                     ! 14 UART A RX/TX
  BAD_TRAP;                                     ! 15 UART B RX/TX
  BAD_TRAP;                                     ! 16 correctable memory error
  BAD_TRAP;                                     ! 17 UART error
  BAD_TRAP;                                     ! 18 DMA access error
  BAD_TRAP;                                     ! 19 DMA timeout
  BAD_TRAP;                                     ! 1A external 3
  BAD_TRAP;                                     ! 1B external 4
  BAD_TRAP;                                     ! 1C general purpose timer
  BAD_TRAP;                                     ! 1D real time clock
  BAD_TRAP;                                     ! 1E external 5
  BAD_TRAP;                                     ! 1F watchdog timeout


  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 20 - 23 undefined
  BAD_TRAP;                                     ! 24 cp_disabled
            BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 25 - 27 undefined
  BAD_TRAP;                                     ! 28 cp_exception
            BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 29 - 2B undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 2C - 2F undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 30 - 33 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 34 - 37 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 38 - 3B undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 3C - 3F undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 40 - 43 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 44 - 47 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 48 - 4B undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 4C - 4F undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 50 - 53 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 54 - 57 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 58 - 5B undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 5C - 5F undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 60 - 63 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 64 - 67 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 68 - 6B undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 6C - 6F undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 70 - 73 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 74 - 77 undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 78 - 7B undefined
  BAD_TRAP; BAD_TRAP; BAD_TRAP; BAD_TRAP;       ! 7C - 7F undefined

  /* 
   *  Software traps
   *
   *  NOTE: At the risk of being redundant... this is not a full
   *        table.  The setjmp on the SPARC requires a window flush trap
   *        handler and RTEMS will preserve the entries that were
   *        installed before.
   */

  SOFT_TRAP;                                    ! 80
#if 0
  SOFT_TRAP;                                    ! 81
#else
  TRAP(SYM(trap_low))                           ! 81
#endif
  SOFT_TRAP;                                    ! 82
  TRAP(SYM(win_flush));                         ! 83 flush windows SW trap
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 84 - 87
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 88 - 8B
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 8C - 8F
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 90 - 93
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 94 - 97
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 98 - 9B
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! 9C - 9F
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! A0 - A3
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! A4 - A7
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! A8 - AB
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! AC - AF
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! B0 - B3
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! B4 - B7
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! B8 - BB
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! BC - BF
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! C0 - C3
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! C4 - C7
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! C8 - CB
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! CC - CF
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! D0 - D3
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! D4 - D7
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! D8 - DB
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! DC - DF
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! E0 - E3
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! E4 - E7
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! E8 - EB
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! EC - EF
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! F0 - F3
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! F4 - F7
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! F8 - FB 
  SOFT_TRAP; SOFT_TRAP; SOFT_TRAP; SOFT_TRAP;   ! FC - FF

/*
 * Startup code for standalone system. Wash IU and FPU (if present)
 * registers. The registers have to be written to initiate the parity
 * bits.
 */
        .globl  SYM(hard_reset)
SYM(hard_reset):

        sethi   %hi(0x01FE0),%o0
        or      %o0,%lo(0x01FE0),%o0
        mov     %o0, %psr               ! Set valid PSR
        nop

        mov     %g0, %wim               ! Set window invalid mask register
        mov     %g0, %y                 ! Init Y-register
        nop
        sethi   %hi(SYM(hard_reset)), %g1

        mov     %g1, %tbr               ! Set TBR
        sethi   %hi(SP_INIT),%sp
        or      %g0, 1, %o0
        ld      [%g0], %f0              ! Check if FPU is present

        tst     %o0
        bz      fixiu
        nop
        ba      fixfpu

! FPU disabled trap address

        clr     %i0
        jmpl    %l2, %g0
        rett    %l2 + 4
        nop
        

! Wash register files (fix for 90C601E & 90C602E)

fixfpu:

        ld      [%g0], %f0
        ld      [%g0], %f1
        ld      [%g0], %f2
        ld      [%g0], %f3
        ld      [%g0], %f4
        ld      [%g0], %f5
        ld      [%g0], %f6
        ld      [%g0], %f7
        ld      [%g0], %f8
        ld      [%g0], %f9
        ld      [%g0], %f10
        ld      [%g0], %f11
        ld      [%g0], %f12
        ld      [%g0], %f13
        ld      [%g0], %f14
        ld      [%g0], %f15
        ld      [%g0], %f16
        ld      [%g0], %f17
        ld      [%g0], %f18
        ld      [%g0], %f19
        ld      [%g0], %f20
        ld      [%g0], %f21
        ld      [%g0], %f22
        ld      [%g0], %f23
        ld      [%g0], %f24
        ld      [%g0], %f25
        ld      [%g0], %f26
        ld      [%g0], %f27
        ld      [%g0], %f28
        ld      [%g0], %f29
        ld      [%g0], %f30
        ld      [%g0], %f31

fixiu:
        clr     %g1
        clr     %g2
        clr     %g3
        clr     %g4
        clr     %g5
        clr     %g6
        clr     %g7
        set     8,%g1
wl0:
        clr     %i0
        clr     %i1
        clr     %i2
        clr     %i3
        clr     %i4
        clr     %i5
        clr     %i6
        clr     %i7
        clr     %l0
        clr     %l1
        clr     %l2
        clr     %l3
        clr     %l4
        clr     %l5
        clr     %l6
        clr     %l7
        save
        subcc   %g1, 1, %g1
        bne     wl0
        nop

!
! Start the real-time clock with a tick of 150 clocks
!

rtc:

        set     0x1f80000, %l0          ! MEC register base
        set     149, %l1
        st      %l1, [%l0 + 0x84]       ! RTC scaler = 149
        set     0x0d00, %l1
        st      %l1, [%l0 + 0x98]       ! Start RTC

        st      %g0, [%l0 + 0x64]       ! Disable watchdog for now
        ld      [%l0], %g1
        or      %g1, 1, %g1
        st      %g1, [%l0]              ! Enable power-down mode

_init:
        set     PSR_INIT, %g1           ! Initialize psr
        mov     %g1, %psr
        set     WIM_INIT, %g1           ! Initialize WIM
        mov     %g1, %wim               
        set     _trap_table, %g1        ! Initialize TBR
        mov     %g1, %tbr
        nop;nop;nop                     

        set     PSR_INIT, %g1
        wr      %g1, 0x20, %psr         ! enable traps
        nop; nop; nop;

        call    SYM(start)
        nop
        
/*
 * Register window overflow handler.  Come here when save would move us
 * into the invalid window.  This routine runs with traps disabled, and
 * must be careful not to touch the condition codes, as PSR is never
 * restored.
 *
 * We are called with %l0 = wim, %l1 = pc, %l2 = npc
 */
        .globl SYM(win_overflow)
SYM(win_overflow):
        mov     %g1, %l3                ! Save g1, we use it to hold the wim
        srl     %l0, 1, %g1             ! Rotate wim right
        sll     %l0, NUMBER_OF_REGISTER_WINDOWS - 1, %l0
        or      %l0, %g1, %g1

        save    %g0, %g0, %g0           ! Slip into next window
        mov     %g1, %wim               ! Install the new wim
        nop
        nop
        nop

        std     %l0, [%sp + 0 * 4]      ! save L & I registers
        std     %l2, [%sp + 2 * 4]
        std     %l4, [%sp + 4 * 4]
        std     %l6, [%sp + 6 * 4]

        std     %i0, [%sp + 8 * 4]
        std     %i2, [%sp + 10 * 4]
        std     %i4, [%sp + 12 * 4]
        std     %i6, [%sp + 14 * 4]

        restore                         ! Go back to trap window.
        mov     %l3, %g1                ! Restore %g1

        jmpl    %l1, %g0
        rett    %l2

/*
 * Register window underflow handler.  Come here when restore would move us
 * into the invalid window.  This routine runs with traps disabled, and
 * must be careful not to touch the condition codes, as PSR is never
 * restored.
 *
 * We are called with %l0 = wim, %l1 = pc, %l2 = npc
 */
        .globl SYM(win_underflow)
SYM(win_underflow):
        sll     %l0, 1, %l3             ! Rotate wim left
        srl     %l0, NUMBER_OF_REGISTER_WINDOWS - 1, %l0
        or      %l0, %l3, %l0

        mov     %l0, %wim               ! Install the new wim

        restore                         ! Users window
        restore                         ! His callers window

        ldd     [%sp + 0 * 4], %l0      ! restore L & I registers
        ldd     [%sp + 2 * 4], %l2
        ldd     [%sp + 4 * 4], %l4
        ldd     [%sp + 6 * 4], %l6

        ldd     [%sp + 8 * 4], %i0
        ldd     [%sp + 10 * 4], %i2
        ldd     [%sp + 12 * 4], %i4
        ldd     [%sp + 14 * 4], %i6

        save    %g0, %g0, %g0           ! Back to trap window
        save    %g0, %g0, %g0

        jmpl    %l1, %g0
        rett    %l2

/*
 * Register window flush handler, triggered by a "ta 3" instruction.
 * We are called with %l0 = wim, %l1 = pc, %l2 = npc
 */
        .globl  SYM(win_flush)
SYM(win_flush):
        mov     %psr, %l0
        or      %l0,0xf00,%l3           ! Disable interrupts
        mov     %l3,%psr
        nop
        nop
        nop
        mov     %wim, %l3

        srl     %l3, %l0, %l4           ! wim >> cwp
        cmp     %l4, 1
        bne     flush_window_fine       ! Branch if not in the invalid window
        nop

/* Handle window overflow. We can't trap here. */

        mov     %g1, %l4                ! Save g1, we use it to hold the wim
        srl     %l3, 1, %g1             ! Rotate wim right
        sll     %l3, NUMBER_OF_REGISTER_WINDOWS - 1, %l3
        or      %l3, %g1, %g1
        mov     %g0, %wim               ! Clear wim so that subsequent save
        nop                             !  wont trap
        nop
        nop
        save    %g0, %g0, %g0           ! Slip into next window
        mov     %g1, %wim               ! Install the new wim

        std     %l0, [%sp + 0 * 4]      ! save L & I registers
        std     %l2, [%sp + 2 * 4]
        std     %l4, [%sp + 4 * 4]
        std     %l6, [%sp + 6 * 4]

        std     %i0, [%sp + 8 * 4]
        std     %i2, [%sp + 10 * 4]
        std     %i4, [%sp + 12 * 4]
        std     %i6, [%sp + 14 * 4]

        restore                         ! Go back to trap window.
        mov     %l4, %g1                ! Restore %g1

flush_window_fine:
        mov     %psr,%l5                ! enable traps
        or      %l5,0x20,%l5
        mov     %l5, %psr
        nop
        nop
        nop

        set     save_buf,%l5
        st      %l2,[%l5]

        ! The stack pointer currently contains a bogus value [when a trap
        ! occurs CWP is decremented and points to an unused window].
        ! Give it something useful before we flush every window.
        ! This does what a "save %sp,-64,$sp" would, except that CWP has
        ! already been decremented.
        add     %fp, -64, %sp

        save %sp, -64, %sp              ! Flush user register window to stack
        save %sp, -64, %sp
        save %sp, -64, %sp
        save %sp, -64, %sp
        save %sp, -64, %sp
        save %sp, -64, %sp
        save %sp, -64, %sp
        save %sp, -64, %sp
        restore
        restore
        restore
        restore
        restore
        restore
        restore
        restore

        restore                         ! Make sure we have a valid window
        save %g0, %g0, %g0

        set     save_buf, %l2           ! Get our return address back
        ld      [%l2],%l2

        mov     %psr,%l5                ! disable traps for rett
        andn    %l5,0x20,%l5
        mov     %l5,%psr
        nop
        nop
        nop

        jmpl    %l2, %g0
        rett    %l2+4

/*
 * Read the TBR.
 */
       .globl SYM(rdtbr)
SYM(rdtbr):
        mov     %tbr, %o0
        nop
        retl
        nop

/*
 * Read the psr
 */
        .globl  SYM(read_psr)
SYM(read_psr):
        mov     %psr, %o0
        nop
        retl
        nop

/*
 * Write the PSR.
 */

        .globl  SYM(write_psr)
SYM(write_psr):
        mov %i0, %psr
        nop
        nop
        nop
        retl
        nop
/*
 * Come here when no fpu exists.  This just skips the offending
 * instruction.
 */
        .globl  SYM(no_fpu)
SYM(no_fpu):
        jmpl %l2, %g0
        rett %l2+4

        .globl SYM(fltr_proto)
        .align 4
SYM(fltr_proto):                    ! First level trap routine prototype
        sethi 0, %l0
        jmpl 0+%l0, %g0
        nop
        nop

/*
 * Trap handler for memory errors.  This just sets mem_err to be
 * non-zero.  It assumes that l1 is non-zero.  This should be safe,
 * as it is doubtful that 0 would ever contain code that could mem
 * fault.  This routine will skip past the faulting instruction after
 * setting mem_err.
 */
        .globl  SYM(fltr_set_mem_err)
SYM(fltr_set_mem_err):
        sethi   %hi(SYM(mem_err)), %l0
        st      %l1, [%l0 + %lo(SYM(mem_err))]
        jmpl    %l2, %g0
        rett    %l2+4

        .data
        .align  4
        .ascii  "DaTa"
        .long   SYM(sdata)
in_trap_handler:
        .word   0
save_buf:       
        .word   0        /* place to save %g1 */
        .word   0        /* place to save %g2 */

        .text
        .align 4

/*
 * This function is called when any SPARC trap (except window overflow
 * or underflow) occurs.  It makes sure that the invalid register
 * window is still available before jumping into C code.  It will also
 * restore the world if you return from handle_exception.
 */
        .globl SYM(trap_low)
SYM(trap_low):
        mov     %psr, %l0
        mov     %wim, %l3

        srl     %l3, %l0, %l4           ! wim >> cwp
        cmp     %l4, 1
        bne     window_fine             ! Branch if not in the invalid window
        nop

        mov     %g1, %l4                ! Save g1, we use it to hold the wim
        srl     %l3, 1, %g1             ! Rotate wim right
        sll     %l3, 8-1, %l5
        or      %l5, %g1, %g1
                
        save    %g0, %g0, %g0           ! Slip into next window
        mov     %g1, %wim               ! Install the new wim

        std     %l0, [%sp + 0 * 4]      ! save L & I registers
        std     %l2, [%sp + 2 * 4]
        std     %l4, [%sp + 4 * 4]
        std     %l6, [%sp + 6 * 4]

        std     %i0, [%sp + 8 * 4]
        std     %i2, [%sp + 10 * 4]
        std     %i4, [%sp + 12 * 4]
        std     %i6, [%sp + 14 * 4]

        restore                         ! Go back to trap window.
        mov     %l4, %g1                ! Restore g1

window_fine:
        sethi   %hi(in_trap_handler), %l4
        ld      [%lo(in_trap_handler) + %l4], %l5
        tst     %l5
        bg      recursive_trap
        inc     %l5

        /* use the stack we set in the linker script */
        sethi   %hi(__trap_stack), %l6
        or      %l6,%lo(__trap_stack),%l6
        mov     %l6, %sp                ! set the stack pointer

recursive_trap:
        st      %l5, [%lo(in_trap_handler) + %l4]

        sub     %sp,(16+1+6+1+72)*4,%sp ! Make room for input & locals
                                        ! + hidden arg + arg spill
                                        ! + doubleword alignment
                                        ! + registers[72] local var

        std     %g0, [%sp + (24 + 0) * 4] ! registers[Gx]
        std     %g2, [%sp + (24 + 2) * 4]
        std     %g4, [%sp + (24 + 4) * 4]
        std     %g6, [%sp + (24 + 6) * 4]

        std     %i0, [%sp + (24 + 8) * 4] ! registers[Ox]
        std     %i2, [%sp + (24 + 10) * 4]
        std     %i4, [%sp + (24 + 12) * 4]
        std     %i6, [%sp + (24 + 14) * 4]
                                         ! F0->F31 not implemented
        mov     %y, %l4
        mov     %tbr, %l5
        st      %l4, [%sp + (24 + 64) * 4] ! Y
        st      %l0, [%sp + (24 + 65) * 4] ! PSR
        st      %l3, [%sp + (24 + 66) * 4] ! WIM
        st      %l5, [%sp + (24 + 67) * 4] ! TBR
        st      %l1, [%sp + (24 + 68) * 4] ! PC
        st      %l2, [%sp + (24 + 69) * 4] ! NPC
                                         ! CPSR and FPSR not implemented

        or      %l0, 0xf20, %l4
        mov     %l4, %psr               ! Turn on traps, disable interrupts

        call    SYM(handle_exception)
        add     %sp, 24 * 4, %o0        ! Pass address of registers

/* Reload all of the registers that aren't on the stack */

        ld      [%sp + (24 + 1) * 4], %g1  ! registers[Gx]
        ldd     [%sp + (24 + 2) * 4], %g2
        ldd     [%sp + (24 + 4) * 4], %g4
        ldd     [%sp + (24 + 6) * 4], %g6

        ldd     [%sp + (24 + 8) * 4], %i0  ! registers[Ox]
        ldd     [%sp + (24 + 10) * 4], %i2
        ldd     [%sp + (24 + 12) * 4], %i4
        ldd     [%sp + (24 + 14) * 4], %i6

        ldd     [%sp + (24 + 64) * 4], %l0 ! Y & PSR
        ldd     [%sp + (24 + 68) * 4], %l2 ! PC & NPC

        restore                         ! Ensure that previous window is valid
        save    %g0, %g0, %g0           !  by causing a window_underflow trap

        mov     %l0, %y
        mov     %l1, %psr               ! Make sure that traps are disabled
                                        ! for rett

        sethi   %hi(in_trap_handler), %l4
        ld      [%lo(in_trap_handler) + %l4], %l5
        dec     %l5
        st      %l5, [%lo(in_trap_handler) + %l4]

        jmpl    %l2, %g0                ! Restore old PC
        rett    %l3                     ! Restore old nPC