| /* libgcc routines for NEC V850. |
| Copyright (C) 1996-2021 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 |