mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
580 lines
14 KiB
ArmAsm
580 lines
14 KiB
ArmAsm
/* Overlay manager for SPU.
|
|
|
|
Copyright 2006, 2007 Free Software Foundation, Inc.
|
|
|
|
This file is part of the GNU Binutils.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
MA 02110-1301, USA. */
|
|
|
|
/**
|
|
* MFC DMA defn's.
|
|
*/
|
|
#define MFC_GET_CMD 0x40
|
|
#define MFC_MAX_DMA_SIZE 0x4000
|
|
#define MFC_TAG_UPDATE_ALL 2
|
|
#define MFC_TAG_ID 0
|
|
|
|
|
|
/**
|
|
* Temporary register allocations.
|
|
* These are saved/restored here.
|
|
*/
|
|
#define tab $75
|
|
#define cgbits $75
|
|
#define add64 $75
|
|
#define ealo $75
|
|
#define newmask $75
|
|
#define tagstat $75
|
|
#define bchn $75
|
|
#define rv1 $75
|
|
|
|
#define off $76
|
|
#define off64 $76
|
|
#define maxsize $76
|
|
#define oldmask $76
|
|
#define sz $76
|
|
#define lnkr $76
|
|
#define rv2 $76
|
|
|
|
#define cur $77
|
|
#define cmp $77
|
|
#define buf $77
|
|
#define genwi $77
|
|
#define tagid $77
|
|
#define cmd $77
|
|
#define rv3 $77
|
|
|
|
#define cgshuf $78
|
|
|
|
#define vma $6
|
|
|
|
#define map $7
|
|
#define osize $7
|
|
#define cmp2 $7
|
|
|
|
#define ea64 $8
|
|
#define retval $8
|
|
|
|
#ifdef OVLY_IRQ_SAVE
|
|
#define irqtmp $8
|
|
#define irq_stat $9
|
|
#endif
|
|
|
|
# Stack quadword minux N
|
|
#define SQWM1 -16*1
|
|
#define SQWM2 -16*2
|
|
#define SQWM3 -16*3
|
|
#define SQWM4 -16*4
|
|
#define SQWM5 -16*5
|
|
#define SQWM6 -16*6
|
|
#define SQWM7 -16*7
|
|
#define SQWM8 -16*8
|
|
#define SQWM9 -16*9
|
|
#define SQWM10 -16*10
|
|
#define SQWM11 -16*11
|
|
#define SQWM12 -16*12
|
|
#define SQWM13 -16*13
|
|
#define SQWM14 -16*14
|
|
#define SQWM15 -16*15
|
|
#define SQWM16 -16*16
|
|
|
|
.extern _ovly_table
|
|
.extern _ovly_buf_table
|
|
|
|
#ifdef OVLY_PRINTFS
|
|
#define SPE_C99_VPRINTF 37
|
|
__entry_event_format:
|
|
.string "In entry_event_hook segment=0x%08x entry-address=0x%08x\n"
|
|
__debug_event_format:
|
|
.string "In debug_event_hook link-register=0x%08x %08x %08x %08x\n"
|
|
__dma_event_format:
|
|
.string "In dma_event_hook vma=0x%08x ea=%08x%08x sz=%08x\n"
|
|
__ovly_buf_table_format:
|
|
.string "_ovly_buf_table[%08x]=%08x\n"
|
|
#endif
|
|
|
|
.text
|
|
.align 4
|
|
.type __rv_pattern, @object
|
|
.size __rv_pattern, 16
|
|
__rv_pattern:
|
|
.word 0x00010203, 0x1c1d1e1f, 0x00010203, 0x10111213
|
|
.type __cg_pattern, @object
|
|
.size __cg_pattern, 16
|
|
__cg_pattern:
|
|
.word 0x04050607, 0x80808080, 0x80808080, 0x80808080
|
|
|
|
/**
|
|
* __ovly_return - stub for returning from overlay functions.
|
|
*
|
|
* inputs:
|
|
* $lr link register
|
|
*
|
|
* outputs:
|
|
* $78 old partition number, to be reloaded
|
|
* $79 return address in old partion number
|
|
*/
|
|
.global __ovly_return
|
|
.type __ovly_return, @function
|
|
|
|
.word 0
|
|
__ovly_return:
|
|
shlqbyi $78, $lr, 4
|
|
shlqbyi $79, $lr, 8
|
|
biz $78, $79
|
|
.size __ovly_return, . - __ovly_return
|
|
|
|
/**
|
|
* __ovly_load - copy an overlay partion to local store.
|
|
*
|
|
* inputs:
|
|
* $78 partition number to be loaded.
|
|
* $79 branch target in new partition.
|
|
* $lr link register, containing return addr.
|
|
*
|
|
* outputs:
|
|
* $lr new link register, returning through __ovly_return.
|
|
*
|
|
* Copy a new overlay partition into local store, or return
|
|
* immediately if the partition is already resident.
|
|
*/
|
|
.global __ovly_load
|
|
.type __ovly_load, @function
|
|
|
|
__ovly_load:
|
|
/* Save temporary registers to stack. */
|
|
stqd $6, -16($sp)
|
|
stqd $7, -32($sp)
|
|
stqd $8, -48($sp)
|
|
|
|
#ifdef OVLY_IRQ_SAVE
|
|
/* Save irq state, then disable interrupts. */
|
|
stqd $9, -64($sp)
|
|
ila irqtmp, __ovly_irq_save
|
|
rdch irq_stat, $SPU_RdMachStat
|
|
bid irqtmp
|
|
__ovly_irq_save:
|
|
#endif
|
|
|
|
#ifdef OVLY_PRINTFS
|
|
//==============================================
|
|
// In entry_event_hook segment=0x%08x entry-address=0x%08x
|
|
//==============================================
|
|
# save registers
|
|
stqd $10, SQWM5($sp)
|
|
stqd $11, SQWM6($sp)
|
|
stqd $12, SQWM7($sp)
|
|
# Place input parameters onto the stack to form the
|
|
# local storage memory image.
|
|
ila $10, __entry_event_format
|
|
stqd $10, SQWM12($sp)
|
|
ai $10, $sp, SQWM9
|
|
stqd $10, SQWM11($sp)
|
|
stqd $sp, SQWM10($sp)
|
|
stqd $78, SQWM9($sp)
|
|
stqd $79, SQWM8($sp)
|
|
# Construct a message consisting of the 8-bit opcode
|
|
# and 24-bit local store pointer to the input
|
|
# parameters and place it forllowing the stop and signal
|
|
ila $10, 0x3ffff # address mask
|
|
ilhu $11, SPE_C99_VPRINTF << 8
|
|
ai $12, $sp, SQWM12 # parameter pointer
|
|
selb $11, $11, $12, $10 # combine command & address ptr
|
|
brsl $10, next1a
|
|
next1a:
|
|
.type next1a, @function
|
|
lqr $12, message1a
|
|
cwd $10, message1a-next1a($10)
|
|
shufb $11, $11, $12, $10 # insert msg into inst word
|
|
stqr $11, message1a # store cmd/ptr into msg word
|
|
dsync
|
|
# Notify the PPE to perform the assisted call request
|
|
# by issing a stop and signal with a signal code
|
|
# of 0x2100 (C99 class)
|
|
stop 0x2100
|
|
message1a:
|
|
.word 0
|
|
|
|
# save registers
|
|
stqd $13, SQWM8($sp)
|
|
stqd $14, SQWM9($sp)
|
|
stqd $15, SQWM10($sp)
|
|
stqd $16, SQWM11($sp)
|
|
|
|
# initialize loop
|
|
il $13, 1
|
|
ila $14, _ovly_buf_table
|
|
ila $15, _ovly_buf_table_end
|
|
|
|
loop_start1:
|
|
# Place input parameters onto the stack to form the
|
|
# local storage memory image.
|
|
ila $10, __ovly_buf_table_format
|
|
stqd $10, SQWM16($sp)
|
|
ai $10, $sp, SQWM13
|
|
stqd $10, SQWM15($sp)
|
|
stqd $sp, SQWM14($sp)
|
|
stqd $13, SQWM13($sp)
|
|
lqd $16, 0($14)
|
|
rotqby $16, $16, $14
|
|
stqd $16, SQWM12($sp)
|
|
# Construct a message consisting of the 8-bit opcode
|
|
# and 24-bit local store pointer to the input
|
|
# parameters and place it forllowing the stop and signal
|
|
ila $10, 0x3ffff # address mask
|
|
ilhu $11, SPE_C99_VPRINTF << 8
|
|
ai $12, $sp, SQWM16 # parameter pointer
|
|
selb $11, $11, $12, $10 # combine command & address ptr
|
|
brsl $10, next1b
|
|
next1b:
|
|
.type next1b, @function
|
|
lqr $12, message1b
|
|
cwd $10, message1b-next1b($10)
|
|
shufb $11, $11, $12, $10 # insert msg into inst word
|
|
stqr $11, message1b # store cmd/ptr into msg word
|
|
dsync
|
|
# Notify the PPE to perform the assisted call request
|
|
# by issing a stop and signal with a signal code
|
|
# of 0x2100 (C99 class)
|
|
stop 0x2100
|
|
message1b:
|
|
.word 0
|
|
|
|
# move to next entry
|
|
ai $13, $13, 1
|
|
ai $14, $14, 4
|
|
clgt $16, $15, $14
|
|
brnz $16, loop_start1
|
|
|
|
# restore registers
|
|
lqd $16, SQWM11($sp)
|
|
lqd $15, SQWM10($sp)
|
|
lqd $14, SQWM9($sp)
|
|
lqd $13, SQWM8($sp)
|
|
lqd $12, SQWM7($sp)
|
|
lqd $11, SQWM6($sp)
|
|
lqd $10, SQWM5($sp)
|
|
//==============================================
|
|
#endif
|
|
|
|
/* Set branch hint to overlay target. */
|
|
hbr __ovly_load_ret, $79
|
|
|
|
/* Get caller's overlay index by back chaining through stack frames.
|
|
* Loop until end of stack (back chain all-zeros) or
|
|
* encountered a link register we set here. */
|
|
lqd bchn, 0($sp)
|
|
ila retval, __ovly_return
|
|
|
|
__ovly_backchain_loop:
|
|
lqd lnkr, 16(bchn)
|
|
lqd bchn, 0(bchn)
|
|
ceq cmp, lnkr, retval
|
|
ceqi cmp2, bchn, 0
|
|
or cmp, cmp, cmp2
|
|
brz cmp, __ovly_backchain_loop
|
|
|
|
/* If we reached the zero back-chain, then lnkr is bogus. Clear the
|
|
* part of lnkr that we use later (slot 3). */
|
|
rotqbyi cmp2, cmp2, 4
|
|
andc lnkr, lnkr, cmp2
|
|
|
|
/* Set lr = {__ovly_return, prev ovl ndx, caller return adr, callee ovl ndx}. */
|
|
lqd rv1, (__rv_pattern-__ovly_return+4)(retval)
|
|
shufb rv2, retval, lnkr, rv1
|
|
shufb rv3, $lr, $78, rv1
|
|
fsmbi rv1, 0xff
|
|
selb rv2, rv2, rv3, rv1
|
|
/* If we have a tail call from one overlay function to another overlay,
|
|
then lr is already set up. Don't change it. */
|
|
ceq rv1, $lr, retval
|
|
fsmb rv1, rv1
|
|
selb $lr, rv2, $lr, rv1
|
|
|
|
/* Branch to $79 if non-overlay */
|
|
brz $78, __ovly_load_restore
|
|
|
|
/* Load values from _ovly_table[$78].
|
|
* extern struct {
|
|
* u32 vma;
|
|
* u32 size;
|
|
* u32 file_offset;
|
|
* u32 buf;
|
|
* } _ovly_table[];
|
|
*/
|
|
shli off, $78, 4
|
|
ila tab, _ovly_table - 16
|
|
lqx vma, tab, off
|
|
rotqbyi buf, vma, 12
|
|
|
|
/* Load values from _ovly_buf_table[buf].
|
|
* extern struct {
|
|
* u32 mapped;
|
|
* } _ovly_buf_table[];
|
|
*/
|
|
ila tab, _ovly_buf_table
|
|
ai off, buf, -1
|
|
shli off, off, 2
|
|
lqx map, tab, off
|
|
rotqby cur, map, off
|
|
|
|
/* Branch to $79 now if overlay is already mapped. */
|
|
ceq cmp, $78, cur
|
|
brnz cmp, __ovly_load_restore
|
|
|
|
/* Marker for profiling code. If we get here, we are about to load
|
|
* a new overlay.
|
|
*/
|
|
.global __ovly_load_event
|
|
.type __ovly_load_event, @function
|
|
__ovly_load_event:
|
|
|
|
/* Set _ovly_buf_table[buf].mapped = $78. */
|
|
cwx genwi, tab, off
|
|
shufb map, $78, map, genwi
|
|
stqx map, tab, off
|
|
|
|
/* A new partition needs to be loaded. Prepare for DMA loop.
|
|
* _EAR_ is the 64b base EA, filled in at run time by the
|
|
* loader, and indicating the value for SPU executable image start.
|
|
*/
|
|
lqd cgshuf, (__cg_pattern-__ovly_return+4)(retval)
|
|
rotqbyi osize, vma, 4
|
|
rotqbyi sz, vma, 8
|
|
lqa ea64, _EAR_
|
|
|
|
__ovly_xfer_loop:
|
|
/* 64b add to compute next ea64. */
|
|
rotqmbyi off64, sz, -4
|
|
cg cgbits, ea64, off64
|
|
shufb add64, cgbits, cgbits, cgshuf
|
|
addx add64, ea64, off64
|
|
ori ea64, add64, 0
|
|
|
|
/* Setup DMA parameters, then issue DMA request. */
|
|
rotqbyi ealo, add64, 4
|
|
ila maxsize, MFC_MAX_DMA_SIZE
|
|
cgt cmp, osize, maxsize
|
|
selb sz, osize, maxsize, cmp
|
|
ila tagid, MFC_TAG_ID
|
|
wrch $MFC_LSA, vma
|
|
wrch $MFC_EAH, ea64
|
|
wrch $MFC_EAL, ealo
|
|
wrch $MFC_Size, sz
|
|
wrch $MFC_TagId, tagid
|
|
ila cmd, MFC_GET_CMD
|
|
wrch $MFC_Cmd, cmd
|
|
|
|
#ifdef OVLY_PRINTFS
|
|
//==============================================
|
|
// In dma_event_hook vma=0x%08x ea=%08x%08x sz=%08x
|
|
//==============================================
|
|
# save registers
|
|
stqd $10, SQWM5($sp)
|
|
stqd $11, SQWM6($sp)
|
|
stqd $12, SQWM7($sp)
|
|
# Place input parameters onto the stack to form the
|
|
# local storage memory image.
|
|
ila $10, __dma_event_format
|
|
stqd $10, SQWM14($sp)
|
|
ai $10, $sp, SQWM11
|
|
stqd $10, SQWM13($sp)
|
|
stqd $sp, SQWM12($sp)
|
|
stqd vma, SQWM11($sp)
|
|
stqd ea64, SQWM10($sp)
|
|
stqd ealo, SQWM9($sp)
|
|
stqd sz, SQWM8($sp)
|
|
# Construct a message consisting of the 8-bit opcode
|
|
# and 24-bit local store pointer to the input
|
|
# parameters and place it forllowing the stop and signal
|
|
ila $10, 0x3ffff # address mask
|
|
ilhu $11, SPE_C99_VPRINTF << 8
|
|
ai $12, $sp, SQWM14 # parameter pointer
|
|
selb $11, $11, $12, $10 # combine command & address ptr
|
|
brsl $10, next3a
|
|
next3a:
|
|
.type next3a, @function
|
|
lqr $12, message3a
|
|
cwd $10, message3a-next3a($10)
|
|
shufb $11, $11, $12, $10 # insert msg into inst word
|
|
stqr $11, message3a # store cmd/ptr into msg word
|
|
dsync
|
|
# Notify the PPE to perform the assisted call request
|
|
# by issing a stop and signal with a signal code
|
|
# of 0x2100 (C99 class)
|
|
stop 0x2100
|
|
message3a:
|
|
.word 0
|
|
|
|
# restore registers
|
|
lqd $12, SQWM7($sp)
|
|
lqd $11, SQWM6($sp)
|
|
lqd $10, SQWM5($sp)
|
|
//==============================================
|
|
#endif
|
|
|
|
/* Increment vma, decrement size, branch back as needed. */
|
|
a vma, vma, sz
|
|
sf osize, sz, osize
|
|
brnz osize, __ovly_xfer_loop
|
|
|
|
/* Save app's tagmask, wait for DMA complete, restore mask. */
|
|
rdch oldmask, $MFC_RdTagMask
|
|
#if MFC_TAG_ID < 16
|
|
ilh newmask, 1 << MFC_TAG_ID
|
|
#else
|
|
ilhu newmask, 1 << (MFC_TAG_ID - 16)
|
|
#endif
|
|
wrch $MFC_WrTagMask, newmask
|
|
ila tagstat, MFC_TAG_UPDATE_ALL
|
|
wrch $MFC_WrTagUpdate, tagstat
|
|
rdch tagstat, $MFC_RdTagStat
|
|
sync
|
|
wrch $MFC_WrTagMask, oldmask
|
|
|
|
#ifdef OVLY_PRINTFS
|
|
//==============================================
|
|
// In debug_event_hook link-register=0x%08x %08x %08x %08x
|
|
//==============================================
|
|
# save registers
|
|
stqd $10, SQWM5($sp)
|
|
stqd $11, SQWM6($sp)
|
|
stqd $12, SQWM7($sp)
|
|
# Place input parameters onto the stack to form the
|
|
# local storage memory image.
|
|
ila $10, __debug_event_format
|
|
stqd $10, SQWM14($sp)
|
|
ai $10, $sp, SQWM11
|
|
stqd $10, SQWM13($sp)
|
|
stqd $sp, SQWM12($sp)
|
|
stqd $lr, SQWM11($sp)
|
|
rotqbyi $10, $lr, 4
|
|
stqd $10, SQWM10($sp)
|
|
rotqbyi $10, $10, 4
|
|
stqd $10, SQWM9($sp)
|
|
rotqbyi $10, $10, 4
|
|
stqd $10, SQWM8($sp)
|
|
# Construct a message consisting of the 8-bit opcode
|
|
# and 24-bit local store pointer to the input
|
|
# parameters and place it forllowing the stop and signal
|
|
ila $10, 0x3ffff # address mask
|
|
ilhu $11, SPE_C99_VPRINTF << 8
|
|
ai $12, $sp, SQWM14 # parameter pointer
|
|
selb $11, $11, $12, $10 # combine command & address ptr
|
|
brsl $10, next2a
|
|
next2a:
|
|
.type next2a, @function
|
|
lqr $12, message2a
|
|
cwd $10, message2a-next2a($10)
|
|
shufb $11, $11, $12, $10 # insert msg into inst word
|
|
stqr $11, message2a # store cmd/ptr into msg word
|
|
dsync
|
|
# Notify the PPE to perform the assisted call request
|
|
# by issing a stop and signal with a signal code
|
|
# of 0x2100 (C99 class)
|
|
stop 0x2100
|
|
message2a:
|
|
.word 0
|
|
|
|
# save registers
|
|
stqd $13, SQWM8($sp)
|
|
stqd $14, SQWM9($sp)
|
|
stqd $15, SQWM10($sp)
|
|
stqd $16, SQWM11($sp)
|
|
|
|
# initialize loop
|
|
il $13, 1
|
|
ila $14, _ovly_buf_table
|
|
ila $15, _ovly_buf_table_end
|
|
|
|
loop_start2:
|
|
# Place input parameters onto the stack to form the
|
|
# local storage memory image.
|
|
ila $10, __ovly_buf_table_format
|
|
stqd $10, SQWM16($sp)
|
|
ai $10, $sp, SQWM13
|
|
stqd $10, SQWM15($sp)
|
|
stqd $sp, SQWM14($sp)
|
|
stqd $13, SQWM13($sp)
|
|
lqd $16, 0($14)
|
|
rotqby $16, $16, $14
|
|
stqd $16, SQWM12($sp)
|
|
# Construct a message consisting of the 8-bit opcode
|
|
# and 24-bit local store pointer to the input
|
|
# parameters and place it forllowing the stop and signal
|
|
ila $10, 0x3ffff # address mask
|
|
ilhu $11, SPE_C99_VPRINTF << 8
|
|
ai $12, $sp, SQWM16 # parameter pointer
|
|
selb $11, $11, $12, $10 # combine command & address ptr
|
|
brsl $10, next2b
|
|
next2b:
|
|
.type next2b, @function
|
|
lqr $12, message2b
|
|
cwd $10, message2b-next2b($10)
|
|
shufb $11, $11, $12, $10 # insert msg into inst word
|
|
stqr $11, message2b # store cmd/ptr into msg word
|
|
dsync
|
|
# Notify the PPE to perform the assisted call request
|
|
# by issing a stop and signal with a signal code
|
|
# of 0x2100 (C99 class)
|
|
stop 0x2100
|
|
message2b:
|
|
.word 0
|
|
|
|
# move to next entry
|
|
ai $13, $13, 1
|
|
ai $14, $14, 4
|
|
clgt $16, $15, $14
|
|
brnz $16, loop_start2
|
|
|
|
# restore registers
|
|
lqd $16, SQWM11($sp)
|
|
lqd $15, SQWM10($sp)
|
|
lqd $14, SQWM9($sp)
|
|
lqd $13, SQWM8($sp)
|
|
lqd $12, SQWM7($sp)
|
|
lqd $11, SQWM6($sp)
|
|
lqd $10, SQWM5($sp)
|
|
//==============================================
|
|
#endif
|
|
|
|
.global _ovly_debug_event
|
|
.type _ovly_debug_event, @function
|
|
_ovly_debug_event:
|
|
/* GDB inserts debugger trap here. */
|
|
nop
|
|
|
|
__ovly_load_restore:
|
|
#ifdef OVLY_IRQ_SAVE
|
|
/* Conditionally re-enable interrupts. */
|
|
andi irq_stat, irq_stat, 1
|
|
ila irqtmp, __ovly_irq_restore
|
|
binze irq_stat, irqtmp
|
|
__ovly_irq_restore:
|
|
lqd $9, -64($sp)
|
|
#endif
|
|
|
|
/* Restore saved registers. */
|
|
lqd $8, -48($sp)
|
|
lqd $7, -32($sp)
|
|
lqd $6, -16($sp)
|
|
|
|
__ovly_load_ret:
|
|
/* Branch to target address. */
|
|
bi $79
|
|
|
|
.size __ovly_load, . - __ovly_load
|