1271 lines
27 KiB
NASM
1271 lines
27 KiB
NASM
/* libgcc1 routines for NEC V850.
|
|
Copyright (C) 1996, 1997 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU CC.
|
|
|
|
GNU CC 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 2, or (at your option) any
|
|
later version.
|
|
|
|
In addition to the permissions in the GNU General Public License, the
|
|
Free Software Foundation gives you unlimited permission to link the
|
|
compiled version of this file with other programs, and to distribute
|
|
those programs without any restriction coming from the use of this
|
|
file. (The General Public License restrictions do apply in other
|
|
respects; for example, they cover modification of the file, and
|
|
distribution when not linked into another program.)
|
|
|
|
This file 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; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
/* As a special exception, if you link this library with files
|
|
compiled with GCC to produce an executable, this does not cause
|
|
the resulting executable to be covered by the GNU General Public License.
|
|
This exception does not however invalidate any other reasons why
|
|
the executable file might be covered by the GNU General Public License. */
|
|
|
|
#ifdef L_mulsi3
|
|
.text
|
|
.globl ___mulsi3
|
|
.type ___mulsi3,@function
|
|
|
|
/*
|
|
* In order to not deal with negative numbers (mulh is a signed multiply
|
|
* and we want an unsigned multiply, code the multiplication as a series
|
|
* of 7 bit multiplies).
|
|
*
|
|
* int __mulsi3 (unsigned a, unsigned b)
|
|
* {
|
|
* int i, j;
|
|
* int ret = 0;
|
|
*
|
|
* for (i = 0; i < 32; i += 7)
|
|
* {
|
|
* short a_part = a & 0x7f;
|
|
* unsigned b_tmp = b;
|
|
* a >>= 7;
|
|
*
|
|
* for (j = 0; (i+j) < 32; j += 7)
|
|
* {
|
|
* short b_part = b_tmp & 0x7f;
|
|
* ret += (((int)a_part) * ((int)b_part)) << (i+j);
|
|
* b_tmp >>= 7;
|
|
* }
|
|
* }
|
|
*
|
|
* return ret;
|
|
* }
|
|
*/
|
|
|
|
___mulsi3:
|
|
mov 0,r10 /* total */
|
|
mov 0,r14 /* i = 0, index for multiply a's part */
|
|
movea lo(31),r0,r16 /* upper bounds for loop */
|
|
.L5:
|
|
mov r7,r13 /* b_tmp = b */
|
|
andi 0x7f,r6,r15 /* a_part = (a & 127) */
|
|
shr 7,r6 /* a >>= 7 */
|
|
mov r14,r12 /* i+j = i */
|
|
.L9:
|
|
andi 0x7f,r13,r11 /* b_part = (b_tmp & 127) */
|
|
mulh r15,r11 /* ((int)a_part) * ((int)b_part) */
|
|
shr 7,r13 /* b_tmp >>= 7 */
|
|
shl r12,r11 /* (((int)a_part) * ((int)b_part)) << (i+j) */
|
|
add r11,r10 /* ret += (((int)a_part) * ((int)b_part)) << (i+j) */
|
|
add 7,r12 /* i+j += 7 */
|
|
cmp r16,r12 /* i+j < 32 */
|
|
ble .L9
|
|
|
|
add 7,r14 /* i += 7 */
|
|
cmp r16,r14 /* i < 32 */
|
|
ble .L5
|
|
|
|
jmp [r31] /* return */
|
|
.size ___mulsi3,.-___mulsi3
|
|
#endif
|
|
|
|
#ifdef L_udivsi3
|
|
.text
|
|
.global ___udivsi3
|
|
___udivsi3:
|
|
mov 1,r12
|
|
mov 0,r10
|
|
cmp r6,r7
|
|
bnl .L12
|
|
movhi hi(-2147483648),r0,r13
|
|
cmp r0,r7
|
|
blt .L12
|
|
.L4:
|
|
shl 1,r7
|
|
shl 1,r12
|
|
cmp r6,r7
|
|
bnl .L12
|
|
cmp r0,r12
|
|
be .L8
|
|
mov r7,r5
|
|
and r13,r5
|
|
be .L4
|
|
br .L12
|
|
.L9:
|
|
cmp r7,r6
|
|
bl .L10
|
|
sub r7,r6
|
|
or r12,r10
|
|
.L10:
|
|
shr 1,r12
|
|
shr 1,r7
|
|
.L12:
|
|
cmp r0,r12
|
|
bne .L9
|
|
.L8:
|
|
jmp [r31]
|
|
.size ___udivsi3,.-___udivsi3
|
|
#endif
|
|
|
|
#ifdef L_divsi3
|
|
.text
|
|
.globl ___divsi3
|
|
.type ___divsi3,@function
|
|
___divsi3:
|
|
add -8,sp
|
|
st.w r31,4[sp]
|
|
st.w r22,0[sp]
|
|
mov 1,r22
|
|
tst r7,r7
|
|
bp .L3
|
|
subr r0,r7
|
|
subr r0,r22
|
|
.L3:
|
|
tst r6,r6
|
|
bp .L4
|
|
subr r0,r6
|
|
subr r0,r22
|
|
.L4:
|
|
jarl ___udivsi3,r31
|
|
cmp r0,r22
|
|
bp .L7
|
|
subr r0,r10
|
|
.L7:
|
|
ld.w 0[sp],r22
|
|
ld.w 4[sp],r31
|
|
add 8,sp
|
|
jmp [r31]
|
|
.size ___divsi3,.-___divsi3
|
|
#endif
|
|
|
|
#ifdef L_umodsi3
|
|
.text
|
|
.globl ___umodsi3
|
|
.type ___umodsi3,@function
|
|
___umodsi3:
|
|
add -12,sp
|
|
st.w r31,8[sp]
|
|
st.w r7,4[sp]
|
|
st.w r6,0[sp]
|
|
jarl ___udivsi3,r31
|
|
ld.w 4[sp],r7
|
|
mov r10,r6
|
|
jarl ___mulsi3,r31
|
|
ld.w 0[sp],r6
|
|
subr r6,r10
|
|
ld.w 8[sp],r31
|
|
add 12,sp
|
|
jmp [r31]
|
|
.size ___umodsi3,.-___umodsi3
|
|
#endif /* L_umodsi3 */
|
|
|
|
#ifdef L_modsi3
|
|
.text
|
|
.globl ___modsi3
|
|
.type ___modsi3,@function
|
|
___modsi3:
|
|
add -12,sp
|
|
st.w r31,8[sp]
|
|
st.w r7,4[sp]
|
|
st.w r6,0[sp]
|
|
jarl ___divsi3,r31
|
|
ld.w 4[sp],r7
|
|
mov r10,r6
|
|
jarl ___mulsi3,r31
|
|
ld.w 0[sp],r6
|
|
subr r6,r10
|
|
ld.w 8[sp],r31
|
|
add 12,sp
|
|
jmp [r31]
|
|
.size ___modsi3,.-___modsi3
|
|
#endif /* L_modsi3 */
|
|
|
|
#ifdef L_save_2
|
|
.text
|
|
.align 2
|
|
.globl __save_r2_r29
|
|
.type __save_r2_r29,@function
|
|
/* Allocate space and save registers 2, 20 .. 29 on the stack */
|
|
/* Called via: jalr __save_r2_r29,r10 */
|
|
__save_r2_r29:
|
|
mov ep,r1
|
|
addi -44,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r24,20[ep]
|
|
sst.w r23,24[ep]
|
|
sst.w r22,28[ep]
|
|
sst.w r21,32[ep]
|
|
sst.w r20,36[ep]
|
|
sst.w r2,40[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r2_r29,.-__save_r2_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r2_r29 */
|
|
.align 2
|
|
.globl __return_r2_r29
|
|
.type __return_r2_r29,@function
|
|
__return_r2_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
sld.w 20[ep],r24
|
|
sld.w 24[ep],r23
|
|
sld.w 28[ep],r22
|
|
sld.w 32[ep],r21
|
|
sld.w 36[ep],r20
|
|
sld.w 40[ep],r2
|
|
addi 44,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r2_r29,.-__return_r2_r29
|
|
#endif /* L_save_2 */
|
|
|
|
#ifdef L_save_20
|
|
.text
|
|
.align 2
|
|
.globl __save_r20_r29
|
|
.type __save_r20_r29,@function
|
|
/* Allocate space and save registers 20 .. 29 on the stack */
|
|
/* Called via: jalr __save_r20_r29,r10 */
|
|
__save_r20_r29:
|
|
mov ep,r1
|
|
addi -40,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r24,20[ep]
|
|
sst.w r23,24[ep]
|
|
sst.w r22,28[ep]
|
|
sst.w r21,32[ep]
|
|
sst.w r20,36[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r20_r29,.-__save_r20_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r20_r29 */
|
|
.align 2
|
|
.globl __return_r20_r29
|
|
.type __return_r20_r29,@function
|
|
__return_r20_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
sld.w 20[ep],r24
|
|
sld.w 24[ep],r23
|
|
sld.w 28[ep],r22
|
|
sld.w 32[ep],r21
|
|
sld.w 36[ep],r20
|
|
addi 40,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r20_r29,.-__return_r20_r29
|
|
#endif /* L_save_20 */
|
|
|
|
#ifdef L_save_21
|
|
.text
|
|
.align 2
|
|
.globl __save_r21_r29
|
|
.type __save_r21_r29,@function
|
|
/* Allocate space and save registers 21 .. 29 on the stack */
|
|
/* Called via: jalr __save_r21_r29,r10 */
|
|
__save_r21_r29:
|
|
mov ep,r1
|
|
addi -36,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r24,20[ep]
|
|
sst.w r23,24[ep]
|
|
sst.w r22,28[ep]
|
|
sst.w r21,32[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r21_r29,.-__save_r21_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r21_r29 */
|
|
.align 2
|
|
.globl __return_r21_r29
|
|
.type __return_r21_r29,@function
|
|
__return_r21_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
sld.w 20[ep],r24
|
|
sld.w 24[ep],r23
|
|
sld.w 28[ep],r22
|
|
sld.w 32[ep],r21
|
|
addi 36,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r21_r29,.-__return_r21_r29
|
|
#endif /* L_save_21 */
|
|
|
|
#ifdef L_save_22
|
|
.text
|
|
.align 2
|
|
.globl __save_r22_r29
|
|
.type __save_r22_r29,@function
|
|
/* Allocate space and save registers 22 .. 29 on the stack */
|
|
/* Called via: jalr __save_r22_r29,r10 */
|
|
__save_r22_r29:
|
|
mov ep,r1
|
|
addi -32,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r24,20[ep]
|
|
sst.w r23,24[ep]
|
|
sst.w r22,28[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r22_r29,.-__save_r22_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r22_r29 */
|
|
.align 2
|
|
.globl __return_r22_r29
|
|
.type __return_r22_r29,@function
|
|
__return_r22_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
sld.w 20[ep],r24
|
|
sld.w 24[ep],r23
|
|
sld.w 28[ep],r22
|
|
addi 32,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r22_r29,.-__return_r22_r29
|
|
#endif /* L_save_22 */
|
|
|
|
#ifdef L_save_23
|
|
.text
|
|
.align 2
|
|
.globl __save_r23_r29
|
|
.type __save_r23_r29,@function
|
|
/* Allocate space and save registers 23 .. 29 on the stack */
|
|
/* Called via: jalr __save_r23_r29,r10 */
|
|
__save_r23_r29:
|
|
mov ep,r1
|
|
addi -28,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r24,20[ep]
|
|
sst.w r23,24[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r23_r29,.-__save_r23_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r23_r29 */
|
|
.align 2
|
|
.globl __return_r23_r29
|
|
.type __return_r23_r29,@function
|
|
__return_r23_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
sld.w 20[ep],r24
|
|
sld.w 24[ep],r23
|
|
addi 28,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r23_r29,.-__return_r23_r29
|
|
#endif /* L_save_23 */
|
|
|
|
#ifdef L_save_24
|
|
.text
|
|
.align 2
|
|
.globl __save_r24_r29
|
|
.type __save_r24_r29,@function
|
|
/* Allocate space and save registers 24 .. 29 on the stack */
|
|
/* Called via: jalr __save_r24_r29,r10 */
|
|
__save_r24_r29:
|
|
mov ep,r1
|
|
addi -24,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r24,20[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r24_r29,.-__save_r24_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r24_r29 */
|
|
.align 2
|
|
.globl __return_r24_r29
|
|
.type __return_r24_r29,@function
|
|
__return_r24_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
sld.w 20[ep],r24
|
|
addi 24,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r24_r29,.-__return_r24_r29
|
|
#endif /* L_save_24 */
|
|
|
|
#ifdef L_save_25
|
|
.text
|
|
.align 2
|
|
.globl __save_r25_r29
|
|
.type __save_r25_r29,@function
|
|
/* Allocate space and save registers 25 .. 29 on the stack */
|
|
/* Called via: jalr __save_r25_r29,r10 */
|
|
__save_r25_r29:
|
|
mov ep,r1
|
|
addi -20,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r25,16[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r25_r29,.-__save_r25_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r25_r29 */
|
|
.align 2
|
|
.globl __return_r25_r29
|
|
.type __return_r25_r29,@function
|
|
__return_r25_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
sld.w 16[ep],r25
|
|
addi 20,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r25_r29,.-__return_r25_r29
|
|
#endif /* L_save_25 */
|
|
|
|
#ifdef L_save_26
|
|
.text
|
|
.align 2
|
|
.globl __save_r26_r29
|
|
.type __save_r26_r29,@function
|
|
/* Allocate space and save registers 26 .. 29 on the stack */
|
|
/* Called via: jalr __save_r26_r29,r10 */
|
|
__save_r26_r29:
|
|
mov ep,r1
|
|
add -16,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r26,12[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r26_r29,.-__save_r26_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r26_r29 */
|
|
.align 2
|
|
.globl __return_r26_r29
|
|
.type __return_r26_r29,@function
|
|
__return_r26_r29:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 0[ep],r29
|
|
sld.w 4[ep],r28
|
|
sld.w 8[ep],r27
|
|
sld.w 12[ep],r26
|
|
addi 16,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r26_r29,.-__return_r26_r29
|
|
#endif /* L_save_26 */
|
|
|
|
#ifdef L_save_27
|
|
.text
|
|
.align 2
|
|
.globl __save_r27_r29
|
|
.type __save_r27_r29,@function
|
|
/* Allocate space and save registers 27 .. 29 on the stack */
|
|
/* Called via: jalr __save_r27_r29,r10 */
|
|
__save_r27_r29:
|
|
add -12,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
jmp [r10]
|
|
.size __save_r27_r29,.-__save_r27_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r27_r29 */
|
|
.align 2
|
|
.globl __return_r27_r29
|
|
.type __return_r27_r29,@function
|
|
__return_r27_r29:
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
add 12,sp
|
|
jmp [r31]
|
|
.size __return_r27_r29,.-__return_r27_r29
|
|
#endif /* L_save_27 */
|
|
|
|
#ifdef L_save_28
|
|
.text
|
|
.align 2
|
|
.globl __save_r28_r29
|
|
.type __save_r28_r29,@function
|
|
/* Allocate space and save registers 28,29 on the stack */
|
|
/* Called via: jalr __save_r28_r29,r10 */
|
|
__save_r28_r29:
|
|
add -8,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
jmp [r10]
|
|
.size __save_r28_r29,.-__save_r28_r29
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r28_r29 */
|
|
.align 2
|
|
.globl __return_r28_r29
|
|
.type __return_r28_r29,@function
|
|
__return_r28_r29:
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
add 8,sp
|
|
jmp [r31]
|
|
.size __return_r28_r29,.-__return_r28_r29
|
|
#endif /* L_save_28 */
|
|
|
|
#ifdef L_save_29
|
|
.text
|
|
.align 2
|
|
.globl __save_r29
|
|
.type __save_r29,@function
|
|
/* Allocate space and save register 29 on the stack */
|
|
/* Called via: jalr __save_r29,r10 */
|
|
__save_r29:
|
|
add -4,sp
|
|
st.w r29,0[sp]
|
|
jmp [r10]
|
|
.size __save_r29,.-__save_r29
|
|
|
|
/* Restore saved register 29, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r29 */
|
|
.align 2
|
|
.globl __return_r29
|
|
.type __return_r29,@function
|
|
__return_r29:
|
|
ld.w 0[sp],r29
|
|
add 4,sp
|
|
jmp [r31]
|
|
.size __return_r29,.-__return_r29
|
|
#endif /* L_save_28 */
|
|
|
|
#ifdef L_save_2c
|
|
.text
|
|
.align 2
|
|
.globl __save_r2_r31
|
|
.type __save_r2_r31,@function
|
|
/* Allocate space and save registers 20 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r2_r31,r10 */
|
|
__save_r2_r31:
|
|
mov ep,r1
|
|
addi -64,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r23,40[ep]
|
|
sst.w r22,44[ep]
|
|
sst.w r21,48[ep]
|
|
sst.w r20,52[ep]
|
|
sst.w r2,56[ep]
|
|
sst.w r31,60[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r2_r31,.-__save_r2_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r20_r31 */
|
|
.align 2
|
|
.globl __return_r2_r31
|
|
.type __return_r2_r31,@function
|
|
__return_r2_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r24
|
|
sld.w 40[ep],r23
|
|
sld.w 44[ep],r22
|
|
sld.w 48[ep],r21
|
|
sld.w 52[ep],r20
|
|
sld.w 56[ep],r2
|
|
sld.w 60[ep],r31
|
|
addi 64,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r2_r31,.-__return_r2_r31
|
|
#endif /* L_save_2c */
|
|
|
|
#ifdef L_save_20c
|
|
.text
|
|
.align 2
|
|
.globl __save_r20_r31
|
|
.type __save_r20_r31,@function
|
|
/* Allocate space and save registers 20 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r20_r31,r10 */
|
|
__save_r20_r31:
|
|
mov ep,r1
|
|
addi -60,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r23,40[ep]
|
|
sst.w r22,44[ep]
|
|
sst.w r21,48[ep]
|
|
sst.w r20,52[ep]
|
|
sst.w r31,56[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r20_r31,.-__save_r20_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r20_r31 */
|
|
.align 2
|
|
.globl __return_r20_r31
|
|
.type __return_r20_r31,@function
|
|
__return_r20_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r24
|
|
sld.w 40[ep],r23
|
|
sld.w 44[ep],r22
|
|
sld.w 48[ep],r21
|
|
sld.w 52[ep],r20
|
|
sld.w 56[ep],r31
|
|
addi 60,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r20_r31,.-__return_r20_r31
|
|
#endif /* L_save_20c */
|
|
|
|
#ifdef L_save_21c
|
|
.text
|
|
.align 2
|
|
.globl __save_r21_r31
|
|
.type __save_r21_r31,@function
|
|
/* Allocate space and save registers 21 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r21_r31,r10 */
|
|
__save_r21_r31:
|
|
mov ep,r1
|
|
addi -56,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r23,40[ep]
|
|
sst.w r22,44[ep]
|
|
sst.w r21,48[ep]
|
|
sst.w r31,52[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r21_r31,.-__save_r21_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r21_r31 */
|
|
.align 2
|
|
.globl __return_r21_r31
|
|
.type __return_r21_r31,@function
|
|
__return_r21_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r24
|
|
sld.w 40[ep],r23
|
|
sld.w 44[ep],r22
|
|
sld.w 48[ep],r21
|
|
sld.w 52[ep],r31
|
|
addi 56,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r21_r31,.-__return_r21_r31
|
|
#endif /* L_save_21c */
|
|
|
|
#ifdef L_save_22c
|
|
.text
|
|
.align 2
|
|
.globl __save_r22_r31
|
|
.type __save_r22_r31,@function
|
|
/* Allocate space and save registers 22 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r22_r31,r10 */
|
|
__save_r22_r31:
|
|
mov ep,r1
|
|
addi -52,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r23,40[ep]
|
|
sst.w r22,44[ep]
|
|
sst.w r31,48[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r22_r31,.-__save_r22_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r22_r31 */
|
|
.align 2
|
|
.globl __return_r22_r31
|
|
.type __return_r22_r31,@function
|
|
__return_r22_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r24
|
|
sld.w 40[ep],r23
|
|
sld.w 44[ep],r22
|
|
sld.w 48[ep],r31
|
|
addi 52,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r22_r31,.-__return_r22_r31
|
|
#endif /* L_save_22c */
|
|
|
|
#ifdef L_save_23c
|
|
.text
|
|
.align 2
|
|
.globl __save_r23_r31
|
|
.type __save_r23_r31,@function
|
|
/* Allocate space and save registers 23 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r23_r31,r10 */
|
|
__save_r23_r31:
|
|
mov ep,r1
|
|
addi -48,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r23,40[ep]
|
|
sst.w r31,44[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r23_r31,.-__save_r23_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r23_r31 */
|
|
.align 2
|
|
.globl __return_r23_r31
|
|
.type __return_r23_r31,@function
|
|
__return_r23_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r24
|
|
sld.w 40[ep],r23
|
|
sld.w 44[ep],r31
|
|
addi 48,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r23_r31,.-__return_r23_r31
|
|
#endif /* L_save_23c */
|
|
|
|
#ifdef L_save_24c
|
|
.text
|
|
.align 2
|
|
.globl __save_r24_r31
|
|
.type __save_r24_r31,@function
|
|
/* Allocate space and save registers 24 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r24_r31,r10 */
|
|
__save_r24_r31:
|
|
mov ep,r1
|
|
addi -44,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r31,40[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r24_r31,.-__save_r24_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r24_r31 */
|
|
.align 2
|
|
.globl __return_r24_r31
|
|
.type __return_r24_r31,@function
|
|
__return_r24_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r24
|
|
sld.w 40[ep],r31
|
|
addi 44,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r24_r31,.-__return_r24_r31
|
|
#endif /* L_save_24c */
|
|
|
|
#ifdef L_save_25c
|
|
.text
|
|
.align 2
|
|
.globl __save_r25_r31
|
|
.type __save_r25_r31,@function
|
|
/* Allocate space and save registers 25 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r25_r31,r10 */
|
|
__save_r25_r31:
|
|
mov ep,r1
|
|
addi -40,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r31,36[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r25_r31,.-__save_r25_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r25_r31 */
|
|
.align 2
|
|
.globl __return_r25_r31
|
|
.type __return_r25_r31,@function
|
|
__return_r25_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r25
|
|
sld.w 36[ep],r31
|
|
addi 40,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r25_r31,.-__return_r25_r31
|
|
#endif /* L_save_25c */
|
|
|
|
#ifdef L_save_26c
|
|
.text
|
|
.align 2
|
|
.globl __save_r26_r31
|
|
.type __save_r26_r31,@function
|
|
/* Allocate space and save registers 26 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r26_r31,r10 */
|
|
__save_r26_r31:
|
|
mov ep,r1
|
|
addi -36,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r31,32[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r26_r31,.-__save_r26_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r26_r31 */
|
|
.align 2
|
|
.globl __return_r26_r31
|
|
.type __return_r26_r31,@function
|
|
__return_r26_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r26
|
|
sld.w 32[ep],r31
|
|
addi 36,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r26_r31,.-__return_r26_r31
|
|
#endif /* L_save_26c */
|
|
|
|
#ifdef L_save_27c
|
|
.text
|
|
.align 2
|
|
.globl __save_r27_r31
|
|
.type __save_r27_r31,@function
|
|
/* Allocate space and save registers 27 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r27_r31,r10 */
|
|
__save_r27_r31:
|
|
mov ep,r1
|
|
addi -32,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,16[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r31,28[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r27_r31,.-__save_r27_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r27_r31 */
|
|
.align 2
|
|
.globl __return_r27_r31
|
|
.type __return_r27_r31,@function
|
|
__return_r27_r31:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 16[ep],r29
|
|
sld.w 20[ep],r28
|
|
sld.w 24[ep],r27
|
|
sld.w 28[ep],r31
|
|
addi 32,sp,sp
|
|
mov r1,ep
|
|
jmp [r31]
|
|
.size __return_r27_r31,.-__return_r27_r31
|
|
#endif /* L_save_27c */
|
|
|
|
#ifdef L_save_28c
|
|
.text
|
|
.align 2
|
|
.globl __save_r28_r31
|
|
.type __save_r28_r31,@function
|
|
/* Allocate space and save registers 28 .. 29, 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r28_r31,r10 */
|
|
__save_r28_r31:
|
|
addi -28,sp,sp
|
|
st.w r29,16[sp]
|
|
st.w r28,20[sp]
|
|
st.w r31,24[sp]
|
|
jmp [r10]
|
|
.size __save_r28_r31,.-__save_r28_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r28_r31 */
|
|
.align 2
|
|
.globl __return_r28_r31
|
|
.type __return_r28_r31,@function
|
|
__return_r28_r31:
|
|
ld.w 16[sp],r29
|
|
ld.w 20[sp],r28
|
|
ld.w 24[sp],r31
|
|
addi 28,sp,sp
|
|
jmp [r31]
|
|
.size __return_r28_r31,.-__return_r28_r31
|
|
#endif /* L_save_28c */
|
|
|
|
#ifdef L_save_29c
|
|
.text
|
|
.align 2
|
|
.globl __save_r29_r31
|
|
.type __save_r29_r31,@function
|
|
/* Allocate space and save registers 29 & 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r29_r31,r10 */
|
|
__save_r29_r31:
|
|
addi -24,sp,sp
|
|
st.w r29,16[sp]
|
|
st.w r31,20[sp]
|
|
jmp [r10]
|
|
.size __save_r29_r31,.-__save_r29_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r29_r31 */
|
|
.align 2
|
|
.globl __return_r29_r31
|
|
.type __return_r29_r31,@function
|
|
__return_r29_r31:
|
|
ld.w 16[sp],r29
|
|
ld.w 20[sp],r31
|
|
addi 24,sp,sp
|
|
jmp [r31]
|
|
.size __return_r29_r31,.-__return_r29_r31
|
|
#endif /* L_save_29c */
|
|
|
|
#ifdef L_save_31c
|
|
.text
|
|
.align 2
|
|
.globl __save_r31
|
|
.type __save_r31,@function
|
|
/* Allocate space and save register 31 on the stack */
|
|
/* Also allocate space for the argument save area */
|
|
/* Called via: jalr __save_r29_r31,r10 */
|
|
__save_r31:
|
|
addi -20,sp,sp
|
|
st.w r31,16[sp]
|
|
jmp [r10]
|
|
.size __save_r31,.-__save_r31
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user */
|
|
/* Called via: jr __return_r31 */
|
|
.align 2
|
|
.globl __return_r31
|
|
.type __return_r31,@function
|
|
__return_r31:
|
|
ld.w 16[sp],r31
|
|
addi 20,sp,sp
|
|
jmp [r31]
|
|
.size __return_r29_r31,.-__return_r29_r31
|
|
#endif /* L_save_31c */
|
|
|
|
#ifdef L_save_varargs
|
|
.text
|
|
.align 2
|
|
.globl __save_r6_r9
|
|
.type __save_r6_r9,@function
|
|
/* Save registers 6 .. 9 on the stack for variable argument functions */
|
|
/* Called via: jalr __save_r6_r9,r10 */
|
|
__save_r6_r9:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sst.w r6,0[ep]
|
|
sst.w r7,4[ep]
|
|
sst.w r8,8[ep]
|
|
sst.w r9,12[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_r6_r9,.-__save_r6_r9
|
|
#endif /* L_save_varargs */
|
|
|
|
#ifdef L_save_interrupt
|
|
.text
|
|
.align 2
|
|
.globl __save_interrupt
|
|
.type __save_interrupt,@function
|
|
/* Save registers r1, r4 on stack and load up with expected values */
|
|
/* Note, 12 bytes of stack have already been allocated. */
|
|
/* Called via: jalr __save_interrupt,r10 */
|
|
__save_interrupt:
|
|
st.w ep,0[sp]
|
|
st.w gp,4[sp]
|
|
st.w r1,8[sp]
|
|
movhi hi(__ep),r0,ep
|
|
movea lo(__ep),ep,ep
|
|
movhi hi(__gp),r0,gp
|
|
movea lo(__gp),gp,gp
|
|
jmp [r10]
|
|
.size __save_interrupt,.-__save_interrupt
|
|
|
|
/* Restore saved registers, deallocate stack and return from the interrupt */
|
|
/* Called via: jr __return_interrupt */
|
|
.align 2
|
|
.globl __return_interrupt
|
|
.type __return_interrupt,@function
|
|
__return_interrupt:
|
|
ld.w 0[sp],ep
|
|
ld.w 4[sp],gp
|
|
ld.w 8[sp],r1
|
|
ld.w 12[sp],r10
|
|
addi 16,sp,sp
|
|
reti
|
|
.size __return_interrupt,.-__return_interrupt
|
|
#endif /* L_save_interrupt */
|
|
|
|
#ifdef L_save_all_interrupt
|
|
.text
|
|
.align 2
|
|
.globl __save_all_interrupt
|
|
.type __save_all_interrupt,@function
|
|
/* Save all registers except for those saved in __save_interrupt */
|
|
/* allocate enough stack for all of the registers & 16 bytes of space */
|
|
/* Called via: jalr __save_all_interrupt,r10 */
|
|
__save_all_interrupt:
|
|
addi -120,sp,sp
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sst.w r31,116[ep]
|
|
sst.w r2,112[ep]
|
|
sst.w gp,108[ep]
|
|
sst.w r6,104[ep]
|
|
sst.w r7,100[ep]
|
|
sst.w r8,96[ep]
|
|
sst.w r9,92[ep]
|
|
sst.w r11,88[ep]
|
|
sst.w r12,84[ep]
|
|
sst.w r13,80[ep]
|
|
sst.w r14,76[ep]
|
|
sst.w r15,72[ep]
|
|
sst.w r16,68[ep]
|
|
sst.w r17,64[ep]
|
|
sst.w r18,60[ep]
|
|
sst.w r19,56[ep]
|
|
sst.w r20,52[ep]
|
|
sst.w r21,48[ep]
|
|
sst.w r22,44[ep]
|
|
sst.w r23,40[ep]
|
|
sst.w r24,36[ep]
|
|
sst.w r25,32[ep]
|
|
sst.w r26,28[ep]
|
|
sst.w r27,24[ep]
|
|
sst.w r28,20[ep]
|
|
sst.w r29,16[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
.size __save_all_interrupt,.-__save_all_interrupt
|
|
|
|
.globl __restore_all_interrupt
|
|
.type __restore_all_interrupt,@function
|
|
/* Restore all registers saved in __save_all_interrupt */
|
|
/* & deallocate the stack space */
|
|
/* Called via: jalr __restore_all_interrupt,r10 */
|
|
__restore_all_interrupt:
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 116[ep],r31
|
|
sld.w 112[ep],r2
|
|
sld.w 108[ep],gp
|
|
sld.w 104[ep],r6
|
|
sld.w 100[ep],r7
|
|
sld.w 96[ep],r8
|
|
sld.w 92[ep],r9
|
|
sld.w 88[ep],r11
|
|
sld.w 84[ep],r12
|
|
sld.w 80[ep],r13
|
|
sld.w 76[ep],r14
|
|
sld.w 72[ep],r15
|
|
sld.w 68[ep],r16
|
|
sld.w 64[ep],r17
|
|
sld.w 60[ep],r18
|
|
sld.w 56[ep],r19
|
|
sld.w 52[ep],r20
|
|
sld.w 48[ep],r21
|
|
sld.w 44[ep],r22
|
|
sld.w 40[ep],r23
|
|
sld.w 36[ep],r24
|
|
sld.w 32[ep],r25
|
|
sld.w 28[ep],r26
|
|
sld.w 24[ep],r27
|
|
sld.w 20[ep],r28
|
|
sld.w 16[ep],r29
|
|
mov r1,ep
|
|
addi 120,sp,sp
|
|
jmp [r10]
|
|
.size __restore_all_interrupt,.-__restore_all_interrupt
|
|
#endif /* L_save_all_interrupt */
|