mirror of
https://github.com/autc04/Retro68.git
synced 2024-12-12 11:29:30 +00:00
2331 lines
48 KiB
ArmAsm
2331 lines
48 KiB
ArmAsm
/* libgcc routines for NEC V850.
|
|
Copyright (C) 1996-2017 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC 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, or (at your option) any
|
|
later version.
|
|
|
|
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.
|
|
|
|
Under Section 7 of GPL version 3, you are granted additional
|
|
permissions described in the GCC Runtime Library Exception, version
|
|
3.1, as published by the Free Software Foundation.
|
|
|
|
You should have received a copy of the GNU General Public License and
|
|
a copy of the GCC Runtime Library Exception along with this program;
|
|
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#ifdef L_mulsi3
|
|
.text
|
|
.globl ___mulsi3
|
|
.type ___mulsi3,@function
|
|
___mulsi3:
|
|
#ifdef __v850__
|
|
/*
|
|
#define SHIFT 12
|
|
#define MASK ((1 << SHIFT) - 1)
|
|
|
|
#define STEP(i, j) \
|
|
({ \
|
|
short a_part = (a >> (i)) & MASK; \
|
|
short b_part = (b >> (j)) & MASK; \
|
|
int res = (((int) a_part) * ((int) b_part)); \
|
|
res; \
|
|
})
|
|
|
|
int
|
|
__mulsi3 (unsigned a, unsigned b)
|
|
{
|
|
return STEP (0, 0) +
|
|
((STEP (SHIFT, 0) + STEP (0, SHIFT)) << SHIFT) +
|
|
((STEP (0, 2 * SHIFT) + STEP (SHIFT, SHIFT) + STEP (2 * SHIFT, 0))
|
|
<< (2 * SHIFT));
|
|
}
|
|
*/
|
|
mov r6, r14
|
|
movea lo(32767), r0, r10
|
|
and r10, r14
|
|
mov r7, r15
|
|
and r10, r15
|
|
shr 15, r6
|
|
mov r6, r13
|
|
and r10, r13
|
|
shr 15, r7
|
|
mov r7, r12
|
|
and r10, r12
|
|
shr 15, r6
|
|
shr 15, r7
|
|
mov r14, r10
|
|
mulh r15, r10
|
|
mov r14, r11
|
|
mulh r12, r11
|
|
mov r13, r16
|
|
mulh r15, r16
|
|
mulh r14, r7
|
|
mulh r15, r6
|
|
add r16, r11
|
|
mulh r13, r12
|
|
shl 15, r11
|
|
add r11, r10
|
|
add r12, r7
|
|
add r6, r7
|
|
shl 30, r7
|
|
add r7, r10
|
|
jmp [r31]
|
|
#endif /* __v850__ */
|
|
#if defined(__v850e__) || defined(__v850ea__) || defined(__v850e2__) || defined(__v850e2v3__) || defined(__v850e3v5__)
|
|
/* This routine is almost unneccesarry because gcc
|
|
generates the MUL instruction for the RTX mulsi3.
|
|
But if someone wants to link his application with
|
|
previsously compiled v850 objects then they will
|
|
need this function. */
|
|
|
|
/* It isn't good to put the inst sequence as below;
|
|
mul r7, r6,
|
|
mov r6, r10, r0
|
|
In this case, there is a RAW hazard between them.
|
|
MUL inst takes 2 cycle in EX stage, then MOV inst
|
|
must wait 1cycle. */
|
|
mov r7, r10
|
|
mul r6, r10, r0
|
|
jmp [r31]
|
|
#endif /* __v850e__ */
|
|
.size ___mulsi3,.-___mulsi3
|
|
#endif /* L_mulsi3 */
|
|
|
|
|
|
#ifdef L_udivsi3
|
|
.text
|
|
.global ___udivsi3
|
|
.type ___udivsi3,@function
|
|
___udivsi3:
|
|
#ifdef __v850__
|
|
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,r19
|
|
and r13,r19
|
|
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]
|
|
|
|
#else /* defined(__v850e__) */
|
|
|
|
/* See comments at end of __mulsi3. */
|
|
mov r6, r10
|
|
divu r7, r10, r0
|
|
jmp [r31]
|
|
|
|
#endif /* __v850e__ */
|
|
|
|
.size ___udivsi3,.-___udivsi3
|
|
#endif
|
|
|
|
#ifdef L_divsi3
|
|
.text
|
|
.globl ___divsi3
|
|
.type ___divsi3,@function
|
|
___divsi3:
|
|
#ifdef __v850__
|
|
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]
|
|
|
|
#else /* defined(__v850e__) */
|
|
|
|
/* See comments at end of __mulsi3. */
|
|
mov r6, r10
|
|
div r7, r10, r0
|
|
jmp [r31]
|
|
|
|
#endif /* __v850e__ */
|
|
|
|
.size ___divsi3,.-___divsi3
|
|
#endif
|
|
|
|
#ifdef L_umodsi3
|
|
.text
|
|
.globl ___umodsi3
|
|
.type ___umodsi3,@function
|
|
___umodsi3:
|
|
#ifdef __v850__
|
|
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]
|
|
|
|
#else /* defined(__v850e__) */
|
|
|
|
/* See comments at end of __mulsi3. */
|
|
divu r7, r6, r10
|
|
jmp [r31]
|
|
|
|
#endif /* __v850e__ */
|
|
|
|
.size ___umodsi3,.-___umodsi3
|
|
#endif /* L_umodsi3 */
|
|
|
|
#ifdef L_modsi3
|
|
.text
|
|
.globl ___modsi3
|
|
.type ___modsi3,@function
|
|
___modsi3:
|
|
#ifdef __v850__
|
|
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]
|
|
|
|
#else /* defined(__v850e__) */
|
|
|
|
/* See comments at end of __mulsi3. */
|
|
div r7, r6, r10
|
|
jmp [r31]
|
|
|
|
#endif /* __v850e__ */
|
|
|
|
.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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -44,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r21,32[sp]
|
|
st.w r20,36[sp]
|
|
st.w r2,40[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
ld.w 32[sp],r21
|
|
ld.w 36[sp],r20
|
|
ld.w 40[sp],r2
|
|
addi 44,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -40,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r21,32[sp]
|
|
st.w r20,36[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
ld.w 32[sp],r21
|
|
ld.w 36[sp],r20
|
|
addi 40,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -36,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r21,32[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
ld.w 32[sp],r21
|
|
addi 36,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -32,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
addi 32,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -28,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
addi 28,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -24,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
addi 24,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
addi -20,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[ep],r29
|
|
ld.w 4[ep],r28
|
|
ld.w 8[ep],r27
|
|
ld.w 12[ep],r26
|
|
ld.w 16[ep],r25
|
|
addi 20,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
add -16,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
addi 16,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
mov ep,r1
|
|
addi -48,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]
|
|
sst.w r31,44[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -48,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r21,32[sp]
|
|
st.w r20,36[sp]
|
|
st.w r2,40[sp]
|
|
st.w r31,44[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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
|
|
sld.w 44[ep],r31
|
|
addi 48,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 44[sp],r29
|
|
ld.w 40[sp],r28
|
|
ld.w 36[sp],r27
|
|
ld.w 32[sp],r26
|
|
ld.w 28[sp],r25
|
|
ld.w 24[sp],r24
|
|
ld.w 20[sp],r23
|
|
ld.w 16[sp],r22
|
|
ld.w 12[sp],r21
|
|
ld.w 8[sp],r20
|
|
ld.w 4[sp],r2
|
|
ld.w 0[sp],r31
|
|
addi 48,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,40[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -44,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r21,32[sp]
|
|
st.w r20,36[sp]
|
|
st.w r31,40[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 44,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
ld.w 32[sp],r21
|
|
ld.w 36[sp],r20
|
|
ld.w 40[sp],r31
|
|
addi 44,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,36[ep]
|
|
mov r1,ep
|
|
jmp [r10]
|
|
#else
|
|
addi -40,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r21,32[sp]
|
|
st.w r31,36[sp]
|
|
jmp [r10]
|
|
#endif
|
|
.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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 40,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
ld.w 32[sp],r21
|
|
ld.w 36[sp],r31
|
|
addi 40,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,32[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -36,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r22,28[sp]
|
|
st.w r31,32[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 36,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r22
|
|
ld.w 32[sp],r31
|
|
addi 36,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,28[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -32,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r23,24[sp]
|
|
st.w r31,28[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 32,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r23
|
|
ld.w 28[sp],r31
|
|
addi 32,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,24[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -28,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r24,20[sp]
|
|
st.w r31,24[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 28,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r24
|
|
ld.w 24[sp],r31
|
|
addi 28,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,20[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -24,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r25,16[sp]
|
|
st.w r31,20[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 24,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r25
|
|
ld.w 20[sp],r31
|
|
addi 24,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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 r31,16[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -20,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r26,12[sp]
|
|
st.w r31,16[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 20,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r26
|
|
ld.w 16[sp],r31
|
|
addi 20,sp,sp
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
mov ep,r1
|
|
addi -16,sp,sp
|
|
mov sp,ep
|
|
sst.w r29,0[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r31,12[ep]
|
|
mov r1,ep
|
|
#else
|
|
addi -16,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r27,8[sp]
|
|
st.w r31,12[sp]
|
|
#endif
|
|
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:
|
|
#ifdef __EP__
|
|
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],r31
|
|
addi 16,sp,sp
|
|
mov r1,ep
|
|
#else
|
|
ld.w 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r27
|
|
ld.w 12[sp],r31
|
|
addi 16,sp,sp
|
|
#endif
|
|
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 -12,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r28,4[sp]
|
|
st.w r31,8[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 0[sp],r29
|
|
ld.w 4[sp],r28
|
|
ld.w 8[sp],r31
|
|
addi 12,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 -8,sp,sp
|
|
st.w r29,0[sp]
|
|
st.w r31,4[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 0[sp],r29
|
|
ld.w 4[sp],r31
|
|
addi 8,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_r31,r10. */
|
|
__save_r31:
|
|
addi -4,sp,sp
|
|
st.w r31,0[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 0[sp],r31
|
|
addi 4,sp,sp
|
|
jmp [r31]
|
|
.size __return_r31,.-__return_r31
|
|
#endif /* L_save_31c */
|
|
|
|
#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, 20 bytes of stack have already been allocated. */
|
|
/* Called via: jalr __save_interrupt,r10. */
|
|
__save_interrupt:
|
|
/* add -20,sp ; st.w r11,16[sp] ; st.w r10,12[sp] ; */
|
|
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
|
|
ld.w 16[sp],r11
|
|
addi 20,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 -104,sp,sp
|
|
#ifdef __EP__
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sst.w r31,100[ep]
|
|
sst.w r2,96[ep]
|
|
sst.w gp,92[ep]
|
|
sst.w r6,88[ep]
|
|
sst.w r7,84[ep]
|
|
sst.w r8,80[ep]
|
|
sst.w r9,76[ep]
|
|
sst.w r11,72[ep]
|
|
sst.w r12,68[ep]
|
|
sst.w r13,64[ep]
|
|
sst.w r14,60[ep]
|
|
sst.w r15,56[ep]
|
|
sst.w r16,52[ep]
|
|
sst.w r17,48[ep]
|
|
sst.w r18,44[ep]
|
|
sst.w r19,40[ep]
|
|
sst.w r20,36[ep]
|
|
sst.w r21,32[ep]
|
|
sst.w r22,28[ep]
|
|
sst.w r23,24[ep]
|
|
sst.w r24,20[ep]
|
|
sst.w r25,16[ep]
|
|
sst.w r26,12[ep]
|
|
sst.w r27,8[ep]
|
|
sst.w r28,4[ep]
|
|
sst.w r29,0[ep]
|
|
mov r1,ep
|
|
#else
|
|
st.w r31,100[sp]
|
|
st.w r2,96[sp]
|
|
st.w gp,92[sp]
|
|
st.w r6,88[sp]
|
|
st.w r7,84[sp]
|
|
st.w r8,80[sp]
|
|
st.w r9,76[sp]
|
|
st.w r11,72[sp]
|
|
st.w r12,68[sp]
|
|
st.w r13,64[sp]
|
|
st.w r14,60[sp]
|
|
st.w r15,56[sp]
|
|
st.w r16,52[sp]
|
|
st.w r17,48[sp]
|
|
st.w r18,44[sp]
|
|
st.w r19,40[sp]
|
|
st.w r20,36[sp]
|
|
st.w r21,32[sp]
|
|
st.w r22,28[sp]
|
|
st.w r23,24[sp]
|
|
st.w r24,20[sp]
|
|
st.w r25,16[sp]
|
|
st.w r26,12[sp]
|
|
st.w r27,8[sp]
|
|
st.w r28,4[sp]
|
|
st.w r29,0[sp]
|
|
#endif
|
|
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 and
|
|
deallocate the stack space. */
|
|
/* Called via: jalr __restore_all_interrupt,r10. */
|
|
__restore_all_interrupt:
|
|
#ifdef __EP__
|
|
mov ep,r1
|
|
mov sp,ep
|
|
sld.w 100[ep],r31
|
|
sld.w 96[ep],r2
|
|
sld.w 92[ep],gp
|
|
sld.w 88[ep],r6
|
|
sld.w 84[ep],r7
|
|
sld.w 80[ep],r8
|
|
sld.w 76[ep],r9
|
|
sld.w 72[ep],r11
|
|
sld.w 68[ep],r12
|
|
sld.w 64[ep],r13
|
|
sld.w 60[ep],r14
|
|
sld.w 56[ep],r15
|
|
sld.w 52[ep],r16
|
|
sld.w 48[ep],r17
|
|
sld.w 44[ep],r18
|
|
sld.w 40[ep],r19
|
|
sld.w 36[ep],r20
|
|
sld.w 32[ep],r21
|
|
sld.w 28[ep],r22
|
|
sld.w 24[ep],r23
|
|
sld.w 20[ep],r24
|
|
sld.w 16[ep],r25
|
|
sld.w 12[ep],r26
|
|
sld.w 8[ep],r27
|
|
sld.w 4[ep],r28
|
|
sld.w 0[ep],r29
|
|
mov r1,ep
|
|
#else
|
|
ld.w 100[sp],r31
|
|
ld.w 96[sp],r2
|
|
ld.w 92[sp],gp
|
|
ld.w 88[sp],r6
|
|
ld.w 84[sp],r7
|
|
ld.w 80[sp],r8
|
|
ld.w 76[sp],r9
|
|
ld.w 72[sp],r11
|
|
ld.w 68[sp],r12
|
|
ld.w 64[sp],r13
|
|
ld.w 60[sp],r14
|
|
ld.w 56[sp],r15
|
|
ld.w 52[sp],r16
|
|
ld.w 48[sp],r17
|
|
ld.w 44[sp],r18
|
|
ld.w 40[sp],r19
|
|
ld.w 36[sp],r20
|
|
ld.w 32[sp],r21
|
|
ld.w 28[sp],r22
|
|
ld.w 24[sp],r23
|
|
ld.w 20[sp],r24
|
|
ld.w 16[sp],r25
|
|
ld.w 12[sp],r26
|
|
ld.w 8[sp],r27
|
|
ld.w 4[sp],r28
|
|
ld.w 0[sp],r29
|
|
#endif
|
|
addi 104,sp,sp
|
|
jmp [r10]
|
|
.size __restore_all_interrupt,.-__restore_all_interrupt
|
|
#endif /* L_save_all_interrupt */
|
|
|
|
#if defined __V850_CALLT__
|
|
#if defined(__v850e__) || defined(__v850e1__) || defined(__v850e2__) || defined(__v850e2v3__) || defined(__v850e3v5__)
|
|
#ifdef L_callt_save_r2_r29
|
|
/* Put these functions into the call table area. */
|
|
.call_table_text
|
|
|
|
/* Allocate space and save registers 2, 20 .. 29 on the stack. */
|
|
/* Called via: callt ctoff(__callt_save_r2_r29). */
|
|
.align 2
|
|
.L_save_r2_r29:
|
|
add -4, sp
|
|
st.w r2, 0[sp]
|
|
prepare {r20 - r29}, 0
|
|
ctret
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user. */
|
|
/* Called via: callt ctoff(__callt_return_r2_r29). */
|
|
.align 2
|
|
.L_return_r2_r29:
|
|
dispose 0, {r20-r29}
|
|
ld.w 0[sp], r2
|
|
add 4, sp
|
|
jmp [r31]
|
|
|
|
/* Place the offsets of the start of these routines into the call table. */
|
|
.call_table_data
|
|
|
|
.global __callt_save_r2_r29
|
|
.type __callt_save_r2_r29,@function
|
|
__callt_save_r2_r29: .short ctoff(.L_save_r2_r29)
|
|
|
|
.global __callt_return_r2_r29
|
|
.type __callt_return_r2_r29,@function
|
|
__callt_return_r2_r29: .short ctoff(.L_return_r2_r29)
|
|
|
|
#endif /* L_callt_save_r2_r29. */
|
|
|
|
#ifdef L_callt_save_r2_r31
|
|
/* Put these functions into the call table area. */
|
|
.call_table_text
|
|
|
|
/* Allocate space and save registers 2 and 20 .. 29, 31 on the stack. */
|
|
/* Also allocate space for the argument save area. */
|
|
/* Called via: callt ctoff(__callt_save_r2_r31). */
|
|
.align 2
|
|
.L_save_r2_r31:
|
|
add -4, sp
|
|
st.w r2, 0[sp]
|
|
prepare {r20 - r29, r31}, 0
|
|
ctret
|
|
|
|
/* Restore saved registers, deallocate stack and return to the user. */
|
|
/* Called via: callt ctoff(__callt_return_r2_r31). */
|
|
.align 2
|
|
.L_return_r2_r31:
|
|
dispose 0, {r20 - r29, r31}
|
|
ld.w 0[sp], r2
|
|
addi 4, sp, sp
|
|
jmp [r31]
|
|
|
|
/* Place the offsets of the start of these routines into the call table. */
|
|
.call_table_data
|
|
|
|
.global __callt_save_r2_r31
|
|
.type __callt_save_r2_r31,@function
|
|
__callt_save_r2_r31: .short ctoff(.L_save_r2_r31)
|
|
|
|
.global __callt_return_r2_r31
|
|
.type __callt_return_r2_r31,@function
|
|
__callt_return_r2_r31: .short ctoff(.L_return_r2_r31)
|
|
|
|
#endif /* L_callt_save_r2_r31 */
|
|
|
|
#ifdef L_callt_save_interrupt
|
|
/* Put these functions into the call table area. */
|
|
.call_table_text
|
|
|
|
/* Save registers r1, ep, gp, r10 on stack and load up with expected values. */
|
|
/* Called via: callt ctoff(__callt_save_interrupt). */
|
|
.align 2
|
|
.L_save_interrupt:
|
|
/* SP has already been moved before callt ctoff(_save_interrupt). */
|
|
/* R1,R10,R11,ctpc,ctpsw has alread been saved bofore callt ctoff(_save_interrupt). */
|
|
/* addi -28, sp, sp */
|
|
/* st.w r1, 24[sp] */
|
|
/* st.w r10, 12[sp] */
|
|
/* st.w r11, 16[sp] */
|
|
/* stsr ctpc, r10 */
|
|
/* st.w r10, 20[sp] */
|
|
/* stsr ctpsw, r10 */
|
|
/* st.w r10, 24[sp] */
|
|
st.w ep, 0[sp]
|
|
st.w gp, 4[sp]
|
|
st.w r1, 8[sp]
|
|
mov hilo(__ep),ep
|
|
mov hilo(__gp),gp
|
|
ctret
|
|
|
|
.call_table_text
|
|
/* Restore saved registers, deallocate stack and return from the interrupt. */
|
|
/* Called via: callt ctoff(__callt_restore_interrupt). */
|
|
.align 2
|
|
.globl __return_interrupt
|
|
.type __return_interrupt,@function
|
|
.L_return_interrupt:
|
|
ld.w 24[sp], r1
|
|
ldsr r1, ctpsw
|
|
ld.w 20[sp], r1
|
|
ldsr r1, ctpc
|
|
ld.w 16[sp], r11
|
|
ld.w 12[sp], r10
|
|
ld.w 8[sp], r1
|
|
ld.w 4[sp], gp
|
|
ld.w 0[sp], ep
|
|
addi 28, sp, sp
|
|
reti
|
|
|
|
/* Place the offsets of the start of these routines into the call table. */
|
|
.call_table_data
|
|
|
|
.global __callt_save_interrupt
|
|
.type __callt_save_interrupt,@function
|
|
__callt_save_interrupt: .short ctoff(.L_save_interrupt)
|
|
|
|
.global __callt_return_interrupt
|
|
.type __callt_return_interrupt,@function
|
|
__callt_return_interrupt: .short ctoff(.L_return_interrupt)
|
|
|
|
#endif /* L_callt_save_interrupt */
|
|
|
|
#ifdef L_callt_save_all_interrupt
|
|
/* Put these functions into the call table area. */
|
|
.call_table_text
|
|
|
|
/* Save all registers except for those saved in __save_interrupt. */
|
|
/* Allocate enough stack for all of the registers & 16 bytes of space. */
|
|
/* Called via: callt ctoff(__callt_save_all_interrupt). */
|
|
.align 2
|
|
.L_save_all_interrupt:
|
|
addi -60, sp, sp
|
|
#ifdef __EP__
|
|
mov ep, r1
|
|
mov sp, ep
|
|
sst.w r2, 56[ep]
|
|
sst.w r5, 52[ep]
|
|
sst.w r6, 48[ep]
|
|
sst.w r7, 44[ep]
|
|
sst.w r8, 40[ep]
|
|
sst.w r9, 36[ep]
|
|
sst.w r11, 32[ep]
|
|
sst.w r12, 28[ep]
|
|
sst.w r13, 24[ep]
|
|
sst.w r14, 20[ep]
|
|
sst.w r15, 16[ep]
|
|
sst.w r16, 12[ep]
|
|
sst.w r17, 8[ep]
|
|
sst.w r18, 4[ep]
|
|
sst.w r19, 0[ep]
|
|
mov r1, ep
|
|
#else
|
|
st.w r2, 56[sp]
|
|
st.w r5, 52[sp]
|
|
st.w r6, 48[sp]
|
|
st.w r7, 44[sp]
|
|
st.w r8, 40[sp]
|
|
st.w r9, 36[sp]
|
|
st.w r11, 32[sp]
|
|
st.w r12, 28[sp]
|
|
st.w r13, 24[sp]
|
|
st.w r14, 20[sp]
|
|
st.w r15, 16[sp]
|
|
st.w r16, 12[sp]
|
|
st.w r17, 8[sp]
|
|
st.w r18, 4[sp]
|
|
st.w r19, 0[sp]
|
|
#endif
|
|
prepare {r20 - r29, r31}, 0
|
|
ctret
|
|
|
|
/* Restore all registers saved in __save_all_interrupt
|
|
deallocate the stack space. */
|
|
/* Called via: callt ctoff(__callt_restore_all_interrupt). */
|
|
.align 2
|
|
.L_restore_all_interrupt:
|
|
dispose 0, {r20 - r29, r31}
|
|
#ifdef __EP__
|
|
mov ep, r1
|
|
mov sp, ep
|
|
sld.w 0 [ep], r19
|
|
sld.w 4 [ep], r18
|
|
sld.w 8 [ep], r17
|
|
sld.w 12[ep], r16
|
|
sld.w 16[ep], r15
|
|
sld.w 20[ep], r14
|
|
sld.w 24[ep], r13
|
|
sld.w 28[ep], r12
|
|
sld.w 32[ep], r11
|
|
sld.w 36[ep], r9
|
|
sld.w 40[ep], r8
|
|
sld.w 44[ep], r7
|
|
sld.w 48[ep], r6
|
|
sld.w 52[ep], r5
|
|
sld.w 56[ep], r2
|
|
mov r1, ep
|
|
#else
|
|
ld.w 0 [sp], r19
|
|
ld.w 4 [sp], r18
|
|
ld.w 8 [sp], r17
|
|
ld.w 12[sp], r16
|
|
ld.w 16[sp], r15
|
|
ld.w 20[sp], r14
|
|
ld.w 24[sp], r13
|
|
ld.w 28[sp], r12
|
|
ld.w 32[sp], r11
|
|
ld.w 36[sp], r9
|
|
ld.w 40[sp], r8
|
|
ld.w 44[sp], r7
|
|
ld.w 48[sp], r6
|
|
ld.w 52[sp], r5
|
|
ld.w 56[sp], r2
|
|
#endif
|
|
addi 60, sp, sp
|
|
ctret
|
|
|
|
/* Place the offsets of the start of these routines into the call table. */
|
|
.call_table_data
|
|
|
|
.global __callt_save_all_interrupt
|
|
.type __callt_save_all_interrupt,@function
|
|
__callt_save_all_interrupt: .short ctoff(.L_save_all_interrupt)
|
|
|
|
.global __callt_restore_all_interrupt
|
|
.type __callt_restore_all_interrupt,@function
|
|
__callt_restore_all_interrupt: .short ctoff(.L_restore_all_interrupt)
|
|
|
|
#endif /* L_callt_save_all_interrupt */
|
|
|
|
|
|
#define MAKE_CALLT_FUNCS( START ) \
|
|
.call_table_text ;\
|
|
.align 2 ;\
|
|
/* Allocate space and save registers START .. r29 on the stack. */ ;\
|
|
/* Called via: callt ctoff(__callt_save_START_r29). */ ;\
|
|
.L_save_##START##_r29: ;\
|
|
prepare { START - r29 }, 0 ;\
|
|
ctret ;\
|
|
;\
|
|
/* Restore saved registers, deallocate stack and return. */ ;\
|
|
/* Called via: callt ctoff(__return_START_r29). */ ;\
|
|
.align 2 ;\
|
|
.L_return_##START##_r29: ;\
|
|
dispose 0, { START - r29 }, r31 ;\
|
|
;\
|
|
/* Place the offsets of the start of these funcs into the call table. */;\
|
|
.call_table_data ;\
|
|
;\
|
|
.global __callt_save_##START##_r29 ;\
|
|
.type __callt_save_##START##_r29,@function ;\
|
|
__callt_save_##START##_r29: .short ctoff(.L_save_##START##_r29 ) ;\
|
|
;\
|
|
.global __callt_return_##START##_r29 ;\
|
|
.type __callt_return_##START##_r29,@function ;\
|
|
__callt_return_##START##_r29: .short ctoff(.L_return_##START##_r29 )
|
|
|
|
|
|
#define MAKE_CALLT_CFUNCS( START ) \
|
|
.call_table_text ;\
|
|
.align 2 ;\
|
|
/* Allocate space and save registers START .. r31 on the stack. */ ;\
|
|
/* Called via: callt ctoff(__callt_save_START_r31c). */ ;\
|
|
.L_save_##START##_r31c: ;\
|
|
prepare { START - r29, r31}, 0 ;\
|
|
ctret ;\
|
|
;\
|
|
/* Restore saved registers, deallocate stack and return. */ ;\
|
|
/* Called via: callt ctoff(__return_START_r31c). */ ;\
|
|
.align 2 ;\
|
|
.L_return_##START##_r31c: ;\
|
|
dispose 0, { START - r29, r31}, r31 ;\
|
|
;\
|
|
/* Place the offsets of the start of these funcs into the call table. */;\
|
|
.call_table_data ;\
|
|
;\
|
|
.global __callt_save_##START##_r31c ;\
|
|
.type __callt_save_##START##_r31c,@function ;\
|
|
__callt_save_##START##_r31c: .short ctoff(.L_save_##START##_r31c ) ;\
|
|
;\
|
|
.global __callt_return_##START##_r31c ;\
|
|
.type __callt_return_##START##_r31c,@function ;\
|
|
__callt_return_##START##_r31c: .short ctoff(.L_return_##START##_r31c )
|
|
|
|
|
|
#ifdef L_callt_save_20
|
|
MAKE_CALLT_FUNCS (r20)
|
|
#endif
|
|
#ifdef L_callt_save_21
|
|
MAKE_CALLT_FUNCS (r21)
|
|
#endif
|
|
#ifdef L_callt_save_22
|
|
MAKE_CALLT_FUNCS (r22)
|
|
#endif
|
|
#ifdef L_callt_save_23
|
|
MAKE_CALLT_FUNCS (r23)
|
|
#endif
|
|
#ifdef L_callt_save_24
|
|
MAKE_CALLT_FUNCS (r24)
|
|
#endif
|
|
#ifdef L_callt_save_25
|
|
MAKE_CALLT_FUNCS (r25)
|
|
#endif
|
|
#ifdef L_callt_save_26
|
|
MAKE_CALLT_FUNCS (r26)
|
|
#endif
|
|
#ifdef L_callt_save_27
|
|
MAKE_CALLT_FUNCS (r27)
|
|
#endif
|
|
#ifdef L_callt_save_28
|
|
MAKE_CALLT_FUNCS (r28)
|
|
#endif
|
|
#ifdef L_callt_save_29
|
|
MAKE_CALLT_FUNCS (r29)
|
|
#endif
|
|
|
|
#ifdef L_callt_save_20c
|
|
MAKE_CALLT_CFUNCS (r20)
|
|
#endif
|
|
#ifdef L_callt_save_21c
|
|
MAKE_CALLT_CFUNCS (r21)
|
|
#endif
|
|
#ifdef L_callt_save_22c
|
|
MAKE_CALLT_CFUNCS (r22)
|
|
#endif
|
|
#ifdef L_callt_save_23c
|
|
MAKE_CALLT_CFUNCS (r23)
|
|
#endif
|
|
#ifdef L_callt_save_24c
|
|
MAKE_CALLT_CFUNCS (r24)
|
|
#endif
|
|
#ifdef L_callt_save_25c
|
|
MAKE_CALLT_CFUNCS (r25)
|
|
#endif
|
|
#ifdef L_callt_save_26c
|
|
MAKE_CALLT_CFUNCS (r26)
|
|
#endif
|
|
#ifdef L_callt_save_27c
|
|
MAKE_CALLT_CFUNCS (r27)
|
|
#endif
|
|
#ifdef L_callt_save_28c
|
|
MAKE_CALLT_CFUNCS (r28)
|
|
#endif
|
|
#ifdef L_callt_save_29c
|
|
MAKE_CALLT_CFUNCS (r29)
|
|
#endif
|
|
|
|
|
|
#ifdef L_callt_save_31c
|
|
.call_table_text
|
|
.align 2
|
|
/* Allocate space and save register r31 on the stack. */
|
|
/* Called via: callt ctoff(__callt_save_r31c). */
|
|
.L_callt_save_r31c:
|
|
prepare {r31}, 0
|
|
ctret
|
|
|
|
/* Restore saved registers, deallocate stack and return. */
|
|
/* Called via: callt ctoff(__return_r31c). */
|
|
.align 2
|
|
.L_callt_return_r31c:
|
|
dispose 0, {r31}, r31
|
|
|
|
/* Place the offsets of the start of these funcs into the call table. */
|
|
.call_table_data
|
|
|
|
.global __callt_save_r31c
|
|
.type __callt_save_r31c,@function
|
|
__callt_save_r31c: .short ctoff(.L_callt_save_r31c)
|
|
|
|
.global __callt_return_r31c
|
|
.type __callt_return_r31c,@function
|
|
__callt_return_r31c: .short ctoff(.L_callt_return_r31c)
|
|
#endif
|
|
|
|
#endif /* __v850e__ + */
|
|
#endif /* __V850_CALLT__ */
|
|
|
|
/* libgcc2 routines for NEC V850. */
|
|
/* Double Integer Arithmetical Operation. */
|
|
|
|
#ifdef L_negdi2
|
|
.text
|
|
.global ___negdi2
|
|
.type ___negdi2, @function
|
|
___negdi2:
|
|
not r6, r10
|
|
add 1, r10
|
|
setf l, r6
|
|
not r7, r11
|
|
add r6, r11
|
|
jmp [lp]
|
|
|
|
.size ___negdi2,.-___negdi2
|
|
#endif
|
|
|
|
#ifdef L_cmpdi2
|
|
.text
|
|
.global ___cmpdi2
|
|
.type ___cmpdi2,@function
|
|
___cmpdi2:
|
|
# Signed comparison bitween each high word.
|
|
cmp r9, r7
|
|
be .L_cmpdi_cmp_low
|
|
setf ge, r10
|
|
setf gt, r6
|
|
add r6, r10
|
|
jmp [lp]
|
|
.L_cmpdi_cmp_low:
|
|
# Unsigned comparigon bitween each low word.
|
|
cmp r8, r6
|
|
setf nl, r10
|
|
setf h, r6
|
|
add r6, r10
|
|
jmp [lp]
|
|
.size ___cmpdi2, . - ___cmpdi2
|
|
#endif
|
|
|
|
#ifdef L_ucmpdi2
|
|
.text
|
|
.global ___ucmpdi2
|
|
.type ___ucmpdi2,@function
|
|
___ucmpdi2:
|
|
cmp r9, r7 # Check if each high word are same.
|
|
bne .L_ucmpdi_check_psw
|
|
cmp r8, r6 # Compare the word.
|
|
.L_ucmpdi_check_psw:
|
|
setf nl, r10 #
|
|
setf h, r6 #
|
|
add r6, r10 # Add the result of comparison NL and comparison H.
|
|
jmp [lp]
|
|
.size ___ucmpdi2, . - ___ucmpdi2
|
|
#endif
|
|
|
|
#ifdef L_muldi3
|
|
.text
|
|
.global ___muldi3
|
|
.type ___muldi3,@function
|
|
___muldi3:
|
|
#ifdef __v850__
|
|
jarl __save_r26_r31, r10
|
|
addi 16, sp, sp
|
|
mov r6, r28
|
|
shr 15, r28
|
|
movea lo(32767), r0, r14
|
|
and r14, r28
|
|
mov r8, r10
|
|
shr 15, r10
|
|
and r14, r10
|
|
mov r6, r19
|
|
shr 30, r19
|
|
mov r7, r12
|
|
shl 2, r12
|
|
or r12, r19
|
|
and r14, r19
|
|
mov r8, r13
|
|
shr 30, r13
|
|
mov r9, r12
|
|
shl 2, r12
|
|
or r12, r13
|
|
and r14, r13
|
|
mov r7, r11
|
|
shr 13, r11
|
|
and r14, r11
|
|
mov r9, r31
|
|
shr 13, r31
|
|
and r14, r31
|
|
mov r7, r29
|
|
shr 28, r29
|
|
and r14, r29
|
|
mov r9, r12
|
|
shr 28, r12
|
|
and r14, r12
|
|
and r14, r6
|
|
and r14, r8
|
|
mov r6, r14
|
|
mulh r8, r14
|
|
mov r6, r16
|
|
mulh r10, r16
|
|
mov r6, r18
|
|
mulh r13, r18
|
|
mov r6, r15
|
|
mulh r31, r15
|
|
mulh r12, r6
|
|
mov r28, r17
|
|
mulh r10, r17
|
|
add -16, sp
|
|
mov r28, r12
|
|
mulh r8, r12
|
|
add r17, r18
|
|
mov r28, r17
|
|
mulh r31, r17
|
|
add r12, r16
|
|
mov r28, r12
|
|
mulh r13, r12
|
|
add r17, r6
|
|
mov r19, r17
|
|
add r12, r15
|
|
mov r19, r12
|
|
mulh r8, r12
|
|
mulh r10, r17
|
|
add r12, r18
|
|
mov r19, r12
|
|
mulh r13, r12
|
|
add r17, r15
|
|
mov r11, r13
|
|
mulh r8, r13
|
|
add r12, r6
|
|
mov r11, r12
|
|
mulh r10, r12
|
|
add r13, r15
|
|
mulh r29, r8
|
|
add r12, r6
|
|
mov r16, r13
|
|
shl 15, r13
|
|
add r14, r13
|
|
mov r18, r12
|
|
shl 30, r12
|
|
mov r13, r26
|
|
add r12, r26
|
|
shr 15, r14
|
|
movhi hi(131071), r0, r12
|
|
movea lo(131071), r12, r13
|
|
and r13, r14
|
|
mov r16, r12
|
|
and r13, r12
|
|
add r12, r14
|
|
mov r18, r12
|
|
shl 15, r12
|
|
and r13, r12
|
|
add r12, r14
|
|
shr 17, r14
|
|
shr 17, r16
|
|
add r14, r16
|
|
shl 13, r15
|
|
shr 2, r18
|
|
add r18, r15
|
|
add r15, r16
|
|
mov r16, r27
|
|
add r8, r6
|
|
shl 28, r6
|
|
add r6, r27
|
|
mov r26, r10
|
|
mov r27, r11
|
|
jr __return_r26_r31
|
|
#else /* defined(__v850e__) */
|
|
/* (Ahi << 32 + Alo) * (Bhi << 32 + Blo) */
|
|
/* r7 r6 r9 r8 */
|
|
mov r8, r10
|
|
mulu r7, r8, r0 /* Ahi * Blo */
|
|
mulu r6, r9, r0 /* Alo * Bhi */
|
|
mulu r6, r10, r11 /* Alo * Blo */
|
|
add r8, r11
|
|
add r9, r11
|
|
jmp [r31]
|
|
#endif /* defined(__v850e__) */
|
|
.size ___muldi3, . - ___muldi3
|
|
#endif
|