OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [config/] [v850/] [lib1funcs.asm] - Blame information for rev 856

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* libgcc routines for NEC V850.
2
   Copyright (C) 1996, 1997, 2002, 2005 Free Software Foundation, Inc.
3
 
4
This file is part of GCC.
5
 
6
GCC is free software; you can redistribute it and/or modify it
7
under the terms of the GNU General Public License as published by the
8
Free Software Foundation; either version 2, or (at your option) any
9
later version.
10
 
11
In addition to the permissions in the GNU General Public License, the
12
Free Software Foundation gives you unlimited permission to link the
13
compiled version of this file into combinations with other programs,
14
and to distribute those combinations without any restriction coming
15
from the use of this file.  (The General Public License restrictions
16
do apply in other respects; for example, they cover modification of
17
the file, and distribution when not linked into a combine
18
executable.)
19
 
20
This file is distributed in the hope that it will be useful, but
21
WITHOUT ANY WARRANTY; without even the implied warranty of
22
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
General Public License for more details.
24
 
25
You should have received a copy of the GNU General Public License
26
along with this program; see the file COPYING.  If not, write to
27
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
28
Boston, MA 02110-1301, USA.  */
29
 
30
#ifdef L_mulsi3
31
        .text
32
        .globl ___mulsi3
33
        .type  ___mulsi3,@function
34
___mulsi3:
35
#ifdef __v850__
36
/*
37
   #define SHIFT 12
38
   #define MASK ((1 << SHIFT) - 1)
39
 
40
   #define STEP(i, j)                               \
41
   ({                                               \
42
       short a_part = (a >> (i)) & MASK;            \
43
       short b_part = (b >> (j)) & MASK;            \
44
       int res = (((int) a_part) * ((int) b_part)); \
45
       res;                                         \
46
   })
47
 
48
   int
49
   __mulsi3 (unsigned a, unsigned b)
50
   {
51
      return STEP (0, 0) +
52
          ((STEP (SHIFT, 0) + STEP (0, SHIFT)) << SHIFT) +
53
          ((STEP (0, 2 * SHIFT) + STEP (SHIFT, SHIFT) + STEP (2 * SHIFT, 0))
54
           << (2 * SHIFT));
55
   }
56
*/
57
        mov   r6, r14
58
        movea lo(32767), r0, r10
59
        and   r10, r14
60
        mov   r7,  r15
61
        and   r10, r15
62
        shr   15,  r6
63
        mov   r6,  r13
64
        and   r10, r13
65
        shr   15,  r7
66
        mov   r7,  r12
67
        and   r10, r12
68
        shr   15,  r6
69
        shr   15,  r7
70
        mov   r14, r10
71
        mulh  r15, r10
72
        mov   r14, r11
73
        mulh  r12, r11
74
        mov   r13, r16
75
        mulh  r15, r16
76
        mulh  r14, r7
77
        mulh  r15, r6
78
        add   r16, r11
79
        mulh  r13, r12
80
        shl   15,  r11
81
        add   r11, r10
82
        add   r12, r7
83
        add   r6,  r7
84
        shl   30,  r7
85
        add   r7,  r10
86
        jmp   [r31]
87
#endif /* __v850__ */
88
#if defined(__v850e__) || defined(__v850ea__)
89
        /* This routine is almost unneccesarry because gcc
90
           generates the MUL instruction for the RTX mulsi3.
91
           But if someone wants to link his application with
92
           previsously compiled v850 objects then they will
93
           need this function.  */
94
 
95
        /* It isn't good to put the inst sequence as below;
96
              mul r7, r6,
97
              mov r6, r10, r0
98
           In this case, there is a RAW hazard between them.
99
           MUL inst takes 2 cycle in EX stage, then MOV inst
100
           must wait 1cycle.  */
101
        mov   r7, r10
102
        mul   r6, r10, r0
103
        jmp   [r31]
104
#endif /* __v850e__ */
105
        .size ___mulsi3,.-___mulsi3
106
#endif /* L_mulsi3 */
107
 
108
 
109
#ifdef L_udivsi3
110
        .text
111
        .global ___udivsi3
112
        .type   ___udivsi3,@function
113
___udivsi3:
114
#ifdef __v850__
115
        mov 1,r12
116
        mov 0,r10
117
        cmp r6,r7
118
        bnl .L12
119
        movhi hi(-2147483648),r0,r13
120
        cmp r0,r7
121
        blt .L12
122
.L4:
123
        shl 1,r7
124
        shl 1,r12
125
        cmp r6,r7
126
        bnl .L12
127
        cmp r0,r12
128
        be .L8
129
        mov r7,r19
130
        and r13,r19
131
        be .L4
132
        br .L12
133
.L9:
134
        cmp r7,r6
135
        bl .L10
136
        sub r7,r6
137
        or r12,r10
138
.L10:
139
        shr 1,r12
140
        shr 1,r7
141
.L12:
142
        cmp r0,r12
143
        bne .L9
144
.L8:
145
        jmp [r31]
146
 
147
#else /* defined(__v850e__) */
148
 
149
        /* See comments at end of __mulsi3.  */
150
        mov   r6, r10
151
        divu  r7, r10, r0
152
        jmp   [r31]
153
 
154
#endif /* __v850e__ */
155
 
156
        .size ___udivsi3,.-___udivsi3
157
#endif
158
 
159
#ifdef L_divsi3
160
        .text
161
        .globl ___divsi3
162
        .type  ___divsi3,@function
163
___divsi3:
164
#ifdef __v850__
165
        add -8,sp
166
        st.w r31,4[sp]
167
        st.w r22,0[sp]
168
        mov 1,r22
169
        tst r7,r7
170
        bp .L3
171
        subr r0,r7
172
        subr r0,r22
173
.L3:
174
        tst r6,r6
175
        bp .L4
176
        subr r0,r6
177
        subr r0,r22
178
.L4:
179
        jarl ___udivsi3,r31
180
        cmp r0,r22
181
        bp .L7
182
        subr r0,r10
183
.L7:
184
        ld.w 0[sp],r22
185
        ld.w 4[sp],r31
186
        add 8,sp
187
        jmp [r31]
188
 
189
#else /* defined(__v850e__) */
190
 
191
        /* See comments at end of __mulsi3.  */
192
        mov   r6, r10
193
        div   r7, r10, r0
194
        jmp   [r31]
195
 
196
#endif /* __v850e__ */
197
 
198
        .size ___divsi3,.-___divsi3
199
#endif
200
 
201
#ifdef  L_umodsi3
202
        .text
203
        .globl ___umodsi3
204
        .type  ___umodsi3,@function
205
___umodsi3:
206
#ifdef __v850__
207
        add -12,sp
208
        st.w r31,8[sp]
209
        st.w r7,4[sp]
210
        st.w r6,0[sp]
211
        jarl ___udivsi3,r31
212
        ld.w 4[sp],r7
213
        mov r10,r6
214
        jarl ___mulsi3,r31
215
        ld.w 0[sp],r6
216
        subr r6,r10
217
        ld.w 8[sp],r31
218
        add 12,sp
219
        jmp [r31]
220
 
221
#else /* defined(__v850e__) */
222
 
223
        /* See comments at end of __mulsi3.  */
224
        divu  r7, r6, r10
225
        jmp   [r31]
226
 
227
#endif /* __v850e__ */
228
 
229
        .size ___umodsi3,.-___umodsi3
230
#endif /* L_umodsi3 */
231
 
232
#ifdef  L_modsi3
233
        .text
234
        .globl ___modsi3
235
        .type  ___modsi3,@function
236
___modsi3:
237
#ifdef __v850__
238
        add -12,sp
239
        st.w r31,8[sp]
240
        st.w r7,4[sp]
241
        st.w r6,0[sp]
242
        jarl ___divsi3,r31
243
        ld.w 4[sp],r7
244
        mov r10,r6
245
        jarl ___mulsi3,r31
246
        ld.w 0[sp],r6
247
        subr r6,r10
248
        ld.w 8[sp],r31
249
        add 12,sp
250
        jmp [r31]
251
 
252
#else /* defined(__v850e__) */
253
 
254
        /* See comments at end of __mulsi3.  */
255
        div  r7, r6, r10
256
        jmp [r31]
257
 
258
#endif /* __v850e__ */
259
 
260
        .size ___modsi3,.-___modsi3
261
#endif /* L_modsi3 */
262
 
263
#ifdef  L_save_2
264
        .text
265
        .align  2
266
        .globl  __save_r2_r29
267
        .type   __save_r2_r29,@function
268
        /* Allocate space and save registers 2, 20 .. 29 on the stack */
269
        /* Called via:  jalr __save_r2_r29,r10 */
270
__save_r2_r29:
271
#ifdef __EP__
272
        mov     ep,r1
273
        addi    -44,sp,sp
274
        mov     sp,ep
275
        sst.w   r29,0[ep]
276
        sst.w   r28,4[ep]
277
        sst.w   r27,8[ep]
278
        sst.w   r26,12[ep]
279
        sst.w   r25,16[ep]
280
        sst.w   r24,20[ep]
281
        sst.w   r23,24[ep]
282
        sst.w   r22,28[ep]
283
        sst.w   r21,32[ep]
284
        sst.w   r20,36[ep]
285
        sst.w   r2,40[ep]
286
        mov     r1,ep
287
#else
288
        addi    -44,sp,sp
289
        st.w    r29,0[sp]
290
        st.w    r28,4[sp]
291
        st.w    r27,8[sp]
292
        st.w    r26,12[sp]
293
        st.w    r25,16[sp]
294
        st.w    r24,20[sp]
295
        st.w    r23,24[sp]
296
        st.w    r22,28[sp]
297
        st.w    r21,32[sp]
298
        st.w    r20,36[sp]
299
        st.w    r2,40[sp]
300
#endif
301
        jmp     [r10]
302
        .size   __save_r2_r29,.-__save_r2_r29
303
 
304
        /* Restore saved registers, deallocate stack and return to the user */
305
        /* Called via:  jr __return_r2_r29 */
306
        .align  2
307
        .globl  __return_r2_r29
308
        .type   __return_r2_r29,@function
309
__return_r2_r29:
310
#ifdef __EP__
311
        mov     ep,r1
312
        mov     sp,ep
313
        sld.w   0[ep],r29
314
        sld.w   4[ep],r28
315
        sld.w   8[ep],r27
316
        sld.w   12[ep],r26
317
        sld.w   16[ep],r25
318
        sld.w   20[ep],r24
319
        sld.w   24[ep],r23
320
        sld.w   28[ep],r22
321
        sld.w   32[ep],r21
322
        sld.w   36[ep],r20
323
        sld.w   40[ep],r2
324
        addi    44,sp,sp
325
        mov     r1,ep
326
#else
327
        ld.w    0[sp],r29
328
        ld.w    4[sp],r28
329
        ld.w    8[sp],r27
330
        ld.w    12[sp],r26
331
        ld.w    16[sp],r25
332
        ld.w    20[sp],r24
333
        ld.w    24[sp],r23
334
        ld.w    28[sp],r22
335
        ld.w    32[sp],r21
336
        ld.w    36[sp],r20
337
        ld.w    40[sp],r2
338
        addi    44,sp,sp
339
#endif
340
        jmp     [r31]
341
        .size   __return_r2_r29,.-__return_r2_r29
342
#endif /* L_save_2 */
343
 
344
#ifdef  L_save_20
345
        .text
346
        .align  2
347
        .globl  __save_r20_r29
348
        .type   __save_r20_r29,@function
349
        /* Allocate space and save registers 20 .. 29 on the stack */
350
        /* Called via:  jalr __save_r20_r29,r10 */
351
__save_r20_r29:
352
#ifdef __EP__
353
        mov     ep,r1
354
        addi    -40,sp,sp
355
        mov     sp,ep
356
        sst.w   r29,0[ep]
357
        sst.w   r28,4[ep]
358
        sst.w   r27,8[ep]
359
        sst.w   r26,12[ep]
360
        sst.w   r25,16[ep]
361
        sst.w   r24,20[ep]
362
        sst.w   r23,24[ep]
363
        sst.w   r22,28[ep]
364
        sst.w   r21,32[ep]
365
        sst.w   r20,36[ep]
366
        mov     r1,ep
367
#else
368
        addi    -40,sp,sp
369
        st.w    r29,0[sp]
370
        st.w    r28,4[sp]
371
        st.w    r27,8[sp]
372
        st.w    r26,12[sp]
373
        st.w    r25,16[sp]
374
        st.w    r24,20[sp]
375
        st.w    r23,24[sp]
376
        st.w    r22,28[sp]
377
        st.w    r21,32[sp]
378
        st.w    r20,36[sp]
379
#endif
380
        jmp     [r10]
381
        .size   __save_r20_r29,.-__save_r20_r29
382
 
383
        /* Restore saved registers, deallocate stack and return to the user */
384
        /* Called via:  jr __return_r20_r29 */
385
        .align  2
386
        .globl  __return_r20_r29
387
        .type   __return_r20_r29,@function
388
__return_r20_r29:
389
#ifdef __EP__
390
        mov     ep,r1
391
        mov     sp,ep
392
        sld.w   0[ep],r29
393
        sld.w   4[ep],r28
394
        sld.w   8[ep],r27
395
        sld.w   12[ep],r26
396
        sld.w   16[ep],r25
397
        sld.w   20[ep],r24
398
        sld.w   24[ep],r23
399
        sld.w   28[ep],r22
400
        sld.w   32[ep],r21
401
        sld.w   36[ep],r20
402
        addi    40,sp,sp
403
        mov     r1,ep
404
#else
405
        ld.w    0[sp],r29
406
        ld.w    4[sp],r28
407
        ld.w    8[sp],r27
408
        ld.w    12[sp],r26
409
        ld.w    16[sp],r25
410
        ld.w    20[sp],r24
411
        ld.w    24[sp],r23
412
        ld.w    28[sp],r22
413
        ld.w    32[sp],r21
414
        ld.w    36[sp],r20
415
        addi    40,sp,sp
416
#endif
417
        jmp     [r31]
418
        .size   __return_r20_r29,.-__return_r20_r29
419
#endif /* L_save_20 */
420
 
421
#ifdef  L_save_21
422
        .text
423
        .align  2
424
        .globl  __save_r21_r29
425
        .type   __save_r21_r29,@function
426
        /* Allocate space and save registers 21 .. 29 on the stack */
427
        /* Called via:  jalr __save_r21_r29,r10 */
428
__save_r21_r29:
429
#ifdef __EP__
430
        mov     ep,r1
431
        addi    -36,sp,sp
432
        mov     sp,ep
433
        sst.w   r29,0[ep]
434
        sst.w   r28,4[ep]
435
        sst.w   r27,8[ep]
436
        sst.w   r26,12[ep]
437
        sst.w   r25,16[ep]
438
        sst.w   r24,20[ep]
439
        sst.w   r23,24[ep]
440
        sst.w   r22,28[ep]
441
        sst.w   r21,32[ep]
442
        mov     r1,ep
443
#else
444
        addi    -36,sp,sp
445
        st.w    r29,0[sp]
446
        st.w    r28,4[sp]
447
        st.w    r27,8[sp]
448
        st.w    r26,12[sp]
449
        st.w    r25,16[sp]
450
        st.w    r24,20[sp]
451
        st.w    r23,24[sp]
452
        st.w    r22,28[sp]
453
        st.w    r21,32[sp]
454
#endif
455
        jmp     [r10]
456
        .size   __save_r21_r29,.-__save_r21_r29
457
 
458
        /* Restore saved registers, deallocate stack and return to the user */
459
        /* Called via:  jr __return_r21_r29 */
460
        .align  2
461
        .globl  __return_r21_r29
462
        .type   __return_r21_r29,@function
463
__return_r21_r29:
464
#ifdef __EP__
465
        mov     ep,r1
466
        mov     sp,ep
467
        sld.w   0[ep],r29
468
        sld.w   4[ep],r28
469
        sld.w   8[ep],r27
470
        sld.w   12[ep],r26
471
        sld.w   16[ep],r25
472
        sld.w   20[ep],r24
473
        sld.w   24[ep],r23
474
        sld.w   28[ep],r22
475
        sld.w   32[ep],r21
476
        addi    36,sp,sp
477
        mov     r1,ep
478
#else
479
        ld.w    0[sp],r29
480
        ld.w    4[sp],r28
481
        ld.w    8[sp],r27
482
        ld.w    12[sp],r26
483
        ld.w    16[sp],r25
484
        ld.w    20[sp],r24
485
        ld.w    24[sp],r23
486
        ld.w    28[sp],r22
487
        ld.w    32[sp],r21
488
        addi    36,sp,sp
489
#endif
490
        jmp     [r31]
491
        .size   __return_r21_r29,.-__return_r21_r29
492
#endif /* L_save_21 */
493
 
494
#ifdef  L_save_22
495
        .text
496
        .align  2
497
        .globl  __save_r22_r29
498
        .type   __save_r22_r29,@function
499
        /* Allocate space and save registers 22 .. 29 on the stack */
500
        /* Called via:  jalr __save_r22_r29,r10 */
501
__save_r22_r29:
502
#ifdef __EP__
503
        mov     ep,r1
504
        addi    -32,sp,sp
505
        mov     sp,ep
506
        sst.w   r29,0[ep]
507
        sst.w   r28,4[ep]
508
        sst.w   r27,8[ep]
509
        sst.w   r26,12[ep]
510
        sst.w   r25,16[ep]
511
        sst.w   r24,20[ep]
512
        sst.w   r23,24[ep]
513
        sst.w   r22,28[ep]
514
        mov     r1,ep
515
#else
516
        addi    -32,sp,sp
517
        st.w    r29,0[sp]
518
        st.w    r28,4[sp]
519
        st.w    r27,8[sp]
520
        st.w    r26,12[sp]
521
        st.w    r25,16[sp]
522
        st.w    r24,20[sp]
523
        st.w    r23,24[sp]
524
        st.w    r22,28[sp]
525
#endif
526
        jmp     [r10]
527
        .size   __save_r22_r29,.-__save_r22_r29
528
 
529
        /* Restore saved registers, deallocate stack and return to the user */
530
        /* Called via:  jr __return_r22_r29 */
531
        .align  2
532
        .globl  __return_r22_r29
533
        .type   __return_r22_r29,@function
534
__return_r22_r29:
535
#ifdef __EP__
536
        mov     ep,r1
537
        mov     sp,ep
538
        sld.w   0[ep],r29
539
        sld.w   4[ep],r28
540
        sld.w   8[ep],r27
541
        sld.w   12[ep],r26
542
        sld.w   16[ep],r25
543
        sld.w   20[ep],r24
544
        sld.w   24[ep],r23
545
        sld.w   28[ep],r22
546
        addi    32,sp,sp
547
        mov     r1,ep
548
#else
549
        ld.w    0[sp],r29
550
        ld.w    4[sp],r28
551
        ld.w    8[sp],r27
552
        ld.w    12[sp],r26
553
        ld.w    16[sp],r25
554
        ld.w    20[sp],r24
555
        ld.w    24[sp],r23
556
        ld.w    28[sp],r22
557
        addi    32,sp,sp
558
#endif
559
        jmp     [r31]
560
        .size   __return_r22_r29,.-__return_r22_r29
561
#endif /* L_save_22 */
562
 
563
#ifdef  L_save_23
564
        .text
565
        .align  2
566
        .globl  __save_r23_r29
567
        .type   __save_r23_r29,@function
568
        /* Allocate space and save registers 23 .. 29 on the stack */
569
        /* Called via:  jalr __save_r23_r29,r10 */
570
__save_r23_r29:
571
#ifdef __EP__
572
        mov     ep,r1
573
        addi    -28,sp,sp
574
        mov     sp,ep
575
        sst.w   r29,0[ep]
576
        sst.w   r28,4[ep]
577
        sst.w   r27,8[ep]
578
        sst.w   r26,12[ep]
579
        sst.w   r25,16[ep]
580
        sst.w   r24,20[ep]
581
        sst.w   r23,24[ep]
582
        mov     r1,ep
583
#else
584
        addi    -28,sp,sp
585
        st.w    r29,0[sp]
586
        st.w    r28,4[sp]
587
        st.w    r27,8[sp]
588
        st.w    r26,12[sp]
589
        st.w    r25,16[sp]
590
        st.w    r24,20[sp]
591
        st.w    r23,24[sp]
592
#endif
593
        jmp     [r10]
594
        .size   __save_r23_r29,.-__save_r23_r29
595
 
596
        /* Restore saved registers, deallocate stack and return to the user */
597
        /* Called via:  jr __return_r23_r29 */
598
        .align  2
599
        .globl  __return_r23_r29
600
        .type   __return_r23_r29,@function
601
__return_r23_r29:
602
#ifdef __EP__
603
        mov     ep,r1
604
        mov     sp,ep
605
        sld.w   0[ep],r29
606
        sld.w   4[ep],r28
607
        sld.w   8[ep],r27
608
        sld.w   12[ep],r26
609
        sld.w   16[ep],r25
610
        sld.w   20[ep],r24
611
        sld.w   24[ep],r23
612
        addi    28,sp,sp
613
        mov     r1,ep
614
#else
615
        ld.w    0[sp],r29
616
        ld.w    4[sp],r28
617
        ld.w    8[sp],r27
618
        ld.w    12[sp],r26
619
        ld.w    16[sp],r25
620
        ld.w    20[sp],r24
621
        ld.w    24[sp],r23
622
        addi    28,sp,sp
623
#endif
624
        jmp     [r31]
625
        .size   __return_r23_r29,.-__return_r23_r29
626
#endif /* L_save_23 */
627
 
628
#ifdef  L_save_24
629
        .text
630
        .align  2
631
        .globl  __save_r24_r29
632
        .type   __save_r24_r29,@function
633
        /* Allocate space and save registers 24 .. 29 on the stack */
634
        /* Called via:  jalr __save_r24_r29,r10 */
635
__save_r24_r29:
636
#ifdef __EP__
637
        mov     ep,r1
638
        addi    -24,sp,sp
639
        mov     sp,ep
640
        sst.w   r29,0[ep]
641
        sst.w   r28,4[ep]
642
        sst.w   r27,8[ep]
643
        sst.w   r26,12[ep]
644
        sst.w   r25,16[ep]
645
        sst.w   r24,20[ep]
646
        mov     r1,ep
647
#else
648
        addi    -24,sp,sp
649
        st.w    r29,0[sp]
650
        st.w    r28,4[sp]
651
        st.w    r27,8[sp]
652
        st.w    r26,12[sp]
653
        st.w    r25,16[sp]
654
        st.w    r24,20[sp]
655
#endif
656
        jmp     [r10]
657
        .size   __save_r24_r29,.-__save_r24_r29
658
 
659
        /* Restore saved registers, deallocate stack and return to the user */
660
        /* Called via:  jr __return_r24_r29 */
661
        .align  2
662
        .globl  __return_r24_r29
663
        .type   __return_r24_r29,@function
664
__return_r24_r29:
665
#ifdef __EP__
666
        mov     ep,r1
667
        mov     sp,ep
668
        sld.w   0[ep],r29
669
        sld.w   4[ep],r28
670
        sld.w   8[ep],r27
671
        sld.w   12[ep],r26
672
        sld.w   16[ep],r25
673
        sld.w   20[ep],r24
674
        addi    24,sp,sp
675
        mov     r1,ep
676
#else
677
        ld.w    0[sp],r29
678
        ld.w    4[sp],r28
679
        ld.w    8[sp],r27
680
        ld.w    12[sp],r26
681
        ld.w    16[sp],r25
682
        ld.w    20[sp],r24
683
        addi    24,sp,sp
684
#endif
685
        jmp     [r31]
686
        .size   __return_r24_r29,.-__return_r24_r29
687
#endif /* L_save_24 */
688
 
689
#ifdef  L_save_25
690
        .text
691
        .align  2
692
        .globl  __save_r25_r29
693
        .type   __save_r25_r29,@function
694
        /* Allocate space and save registers 25 .. 29 on the stack */
695
        /* Called via:  jalr __save_r25_r29,r10 */
696
__save_r25_r29:
697
#ifdef __EP__
698
        mov     ep,r1
699
        addi    -20,sp,sp
700
        mov     sp,ep
701
        sst.w   r29,0[ep]
702
        sst.w   r28,4[ep]
703
        sst.w   r27,8[ep]
704
        sst.w   r26,12[ep]
705
        sst.w   r25,16[ep]
706
        mov     r1,ep
707
#else
708
        addi    -20,sp,sp
709
        st.w    r29,0[sp]
710
        st.w    r28,4[sp]
711
        st.w    r27,8[sp]
712
        st.w    r26,12[sp]
713
        st.w    r25,16[sp]
714
#endif
715
        jmp     [r10]
716
        .size   __save_r25_r29,.-__save_r25_r29
717
 
718
        /* Restore saved registers, deallocate stack and return to the user */
719
        /* Called via:  jr __return_r25_r29 */
720
        .align  2
721
        .globl  __return_r25_r29
722
        .type   __return_r25_r29,@function
723
__return_r25_r29:
724
#ifdef __EP__
725
        mov     ep,r1
726
        mov     sp,ep
727
        sld.w   0[ep],r29
728
        sld.w   4[ep],r28
729
        sld.w   8[ep],r27
730
        sld.w   12[ep],r26
731
        sld.w   16[ep],r25
732
        addi    20,sp,sp
733
        mov     r1,ep
734
#else
735
        ld.w    0[ep],r29
736
        ld.w    4[ep],r28
737
        ld.w    8[ep],r27
738
        ld.w    12[ep],r26
739
        ld.w    16[ep],r25
740
        addi    20,sp,sp
741
#endif
742
        jmp     [r31]
743
        .size   __return_r25_r29,.-__return_r25_r29
744
#endif /* L_save_25 */
745
 
746
#ifdef  L_save_26
747
        .text
748
        .align  2
749
        .globl  __save_r26_r29
750
        .type   __save_r26_r29,@function
751
        /* Allocate space and save registers 26 .. 29 on the stack */
752
        /* Called via:  jalr __save_r26_r29,r10 */
753
__save_r26_r29:
754
#ifdef __EP__
755
        mov     ep,r1
756
        add     -16,sp
757
        mov     sp,ep
758
        sst.w   r29,0[ep]
759
        sst.w   r28,4[ep]
760
        sst.w   r27,8[ep]
761
        sst.w   r26,12[ep]
762
        mov     r1,ep
763
#else
764
        add     -16,sp
765
        st.w    r29,0[sp]
766
        st.w    r28,4[sp]
767
        st.w    r27,8[sp]
768
        st.w    r26,12[sp]
769
#endif
770
        jmp     [r10]
771
        .size   __save_r26_r29,.-__save_r26_r29
772
 
773
        /* Restore saved registers, deallocate stack and return to the user */
774
        /* Called via:  jr __return_r26_r29 */
775
        .align  2
776
        .globl  __return_r26_r29
777
        .type   __return_r26_r29,@function
778
__return_r26_r29:
779
#ifdef __EP__
780
        mov     ep,r1
781
        mov     sp,ep
782
        sld.w   0[ep],r29
783
        sld.w   4[ep],r28
784
        sld.w   8[ep],r27
785
        sld.w   12[ep],r26
786
        addi    16,sp,sp
787
        mov     r1,ep
788
#else
789
        ld.w    0[sp],r29
790
        ld.w    4[sp],r28
791
        ld.w    8[sp],r27
792
        ld.w    12[sp],r26
793
        addi    16,sp,sp
794
#endif
795
        jmp     [r31]
796
        .size   __return_r26_r29,.-__return_r26_r29
797
#endif /* L_save_26 */
798
 
799
#ifdef  L_save_27
800
        .text
801
        .align  2
802
        .globl  __save_r27_r29
803
        .type   __save_r27_r29,@function
804
        /* Allocate space and save registers 27 .. 29 on the stack */
805
        /* Called via:  jalr __save_r27_r29,r10 */
806
__save_r27_r29:
807
        add     -12,sp
808
        st.w    r29,0[sp]
809
        st.w    r28,4[sp]
810
        st.w    r27,8[sp]
811
        jmp     [r10]
812
        .size   __save_r27_r29,.-__save_r27_r29
813
 
814
        /* Restore saved registers, deallocate stack and return to the user */
815
        /* Called via:  jr __return_r27_r29 */
816
        .align  2
817
        .globl  __return_r27_r29
818
        .type   __return_r27_r29,@function
819
__return_r27_r29:
820
        ld.w    0[sp],r29
821
        ld.w    4[sp],r28
822
        ld.w    8[sp],r27
823
        add     12,sp
824
        jmp     [r31]
825
        .size   __return_r27_r29,.-__return_r27_r29
826
#endif /* L_save_27 */
827
 
828
#ifdef  L_save_28
829
        .text
830
        .align  2
831
        .globl  __save_r28_r29
832
        .type   __save_r28_r29,@function
833
        /* Allocate space and save registers 28,29 on the stack */
834
        /* Called via:  jalr __save_r28_r29,r10 */
835
__save_r28_r29:
836
        add     -8,sp
837
        st.w    r29,0[sp]
838
        st.w    r28,4[sp]
839
        jmp     [r10]
840
        .size   __save_r28_r29,.-__save_r28_r29
841
 
842
        /* Restore saved registers, deallocate stack and return to the user */
843
        /* Called via:  jr __return_r28_r29 */
844
        .align  2
845
        .globl  __return_r28_r29
846
        .type   __return_r28_r29,@function
847
__return_r28_r29:
848
        ld.w    0[sp],r29
849
        ld.w    4[sp],r28
850
        add     8,sp
851
        jmp     [r31]
852
        .size   __return_r28_r29,.-__return_r28_r29
853
#endif /* L_save_28 */
854
 
855
#ifdef  L_save_29
856
        .text
857
        .align  2
858
        .globl  __save_r29
859
        .type   __save_r29,@function
860
        /* Allocate space and save register 29 on the stack */
861
        /* Called via:  jalr __save_r29,r10 */
862
__save_r29:
863
        add     -4,sp
864
        st.w    r29,0[sp]
865
        jmp     [r10]
866
        .size   __save_r29,.-__save_r29
867
 
868
        /* Restore saved register 29, deallocate stack and return to the user */
869
        /* Called via:  jr __return_r29 */
870
        .align  2
871
        .globl  __return_r29
872
        .type   __return_r29,@function
873
__return_r29:
874
        ld.w    0[sp],r29
875
        add     4,sp
876
        jmp     [r31]
877
        .size   __return_r29,.-__return_r29
878
#endif /* L_save_28 */
879
 
880
#ifdef  L_save_2c
881
        .text
882
        .align  2
883
        .globl  __save_r2_r31
884
        .type   __save_r2_r31,@function
885
        /* Allocate space and save registers 20 .. 29, 31 on the stack.  */
886
        /* Also allocate space for the argument save area.  */
887
        /* Called via:  jalr __save_r2_r31,r10.  */
888
__save_r2_r31:
889
#ifdef __EP__
890
        mov     ep,r1
891
        addi    -64,sp,sp
892
        mov     sp,ep
893
        sst.w   r29,16[ep]
894
        sst.w   r28,20[ep]
895
        sst.w   r27,24[ep]
896
        sst.w   r26,28[ep]
897
        sst.w   r25,32[ep]
898
        sst.w   r24,36[ep]
899
        sst.w   r23,40[ep]
900
        sst.w   r22,44[ep]
901
        sst.w   r21,48[ep]
902
        sst.w   r20,52[ep]
903
        sst.w   r2,56[ep]
904
        sst.w   r31,60[ep]
905
        mov     r1,ep
906
#else
907
        addi    -64,sp,sp
908
        st.w    r29,16[sp]
909
        st.w    r28,20[sp]
910
        st.w    r27,24[sp]
911
        st.w    r26,28[sp]
912
        st.w    r25,32[sp]
913
        st.w    r24,36[sp]
914
        st.w    r23,40[sp]
915
        st.w    r22,44[sp]
916
        st.w    r21,48[sp]
917
        st.w    r20,52[sp]
918
        st.w    r2,56[sp]
919
        st.w    r31,60[sp]
920
#endif
921
        jmp     [r10]
922
        .size   __save_r2_r31,.-__save_r2_r31
923
 
924
        /* Restore saved registers, deallocate stack and return to the user */
925
        /* Called via:  jr __return_r20_r31 */
926
        .align  2
927
        .globl  __return_r2_r31
928
        .type   __return_r2_r31,@function
929
__return_r2_r31:
930
#ifdef __EP__
931
        mov     ep,r1
932
        mov     sp,ep
933
        sld.w   16[ep],r29
934
        sld.w   20[ep],r28
935
        sld.w   24[ep],r27
936
        sld.w   28[ep],r26
937
        sld.w   32[ep],r25
938
        sld.w   36[ep],r24
939
        sld.w   40[ep],r23
940
        sld.w   44[ep],r22
941
        sld.w   48[ep],r21
942
        sld.w   52[ep],r20
943
        sld.w   56[ep],r2
944
        sld.w   60[ep],r31
945
        addi    64,sp,sp
946
        mov     r1,ep
947
#else
948
        ld.w    16[sp],r29
949
        ld.w    20[sp],r28
950
        ld.w    24[sp],r27
951
        ld.w    28[sp],r26
952
        ld.w    32[sp],r25
953
        ld.w    36[sp],r24
954
        ld.w    40[sp],r23
955
        ld.w    44[sp],r22
956
        ld.w    48[sp],r21
957
        ld.w    52[sp],r20
958
        ld.w    56[sp],r2
959
        ld.w    60[sp],r31
960
        addi    64,sp,sp
961
#endif
962
        jmp     [r31]
963
        .size   __return_r2_r31,.-__return_r2_r31
964
#endif /* L_save_2c */
965
 
966
#ifdef  L_save_20c
967
        .text
968
        .align  2
969
        .globl  __save_r20_r31
970
        .type   __save_r20_r31,@function
971
        /* Allocate space and save registers 20 .. 29, 31 on the stack */
972
        /* Also allocate space for the argument save area */
973
        /* Called via:  jalr __save_r20_r31,r10 */
974
__save_r20_r31:
975
#ifdef __EP__
976
        mov     ep,r1
977
        addi    -60,sp,sp
978
        mov     sp,ep
979
        sst.w   r29,16[ep]
980
        sst.w   r28,20[ep]
981
        sst.w   r27,24[ep]
982
        sst.w   r26,28[ep]
983
        sst.w   r25,32[ep]
984
        sst.w   r24,36[ep]
985
        sst.w   r23,40[ep]
986
        sst.w   r22,44[ep]
987
        sst.w   r21,48[ep]
988
        sst.w   r20,52[ep]
989
        sst.w   r31,56[ep]
990
        mov     r1,ep
991
#else
992
        addi    -60,sp,sp
993
        st.w    r29,16[sp]
994
        st.w    r28,20[sp]
995
        st.w    r27,24[sp]
996
        st.w    r26,28[sp]
997
        st.w    r25,32[sp]
998
        st.w    r24,36[sp]
999
        st.w    r23,40[sp]
1000
        st.w    r22,44[sp]
1001
        st.w    r21,48[sp]
1002
        st.w    r20,52[sp]
1003
        st.w    r31,56[sp]
1004
#endif
1005
        jmp     [r10]
1006
        .size   __save_r20_r31,.-__save_r20_r31
1007
 
1008
        /* Restore saved registers, deallocate stack and return to the user */
1009
        /* Called via:  jr __return_r20_r31 */
1010
        .align  2
1011
        .globl  __return_r20_r31
1012
        .type   __return_r20_r31,@function
1013
__return_r20_r31:
1014
#ifdef __EP__
1015
        mov     ep,r1
1016
        mov     sp,ep
1017
        sld.w   16[ep],r29
1018
        sld.w   20[ep],r28
1019
        sld.w   24[ep],r27
1020
        sld.w   28[ep],r26
1021
        sld.w   32[ep],r25
1022
        sld.w   36[ep],r24
1023
        sld.w   40[ep],r23
1024
        sld.w   44[ep],r22
1025
        sld.w   48[ep],r21
1026
        sld.w   52[ep],r20
1027
        sld.w   56[ep],r31
1028
        addi    60,sp,sp
1029
        mov     r1,ep
1030
#else
1031
        ld.w    16[sp],r29
1032
        ld.w    20[sp],r28
1033
        ld.w    24[sp],r27
1034
        ld.w    28[sp],r26
1035
        ld.w    32[sp],r25
1036
        ld.w    36[sp],r24
1037
        ld.w    40[sp],r23
1038
        ld.w    44[sp],r22
1039
        ld.w    48[sp],r21
1040
        ld.w    52[sp],r20
1041
        ld.w    56[sp],r31
1042
        addi    60,sp,sp
1043
#endif
1044
        jmp     [r31]
1045
        .size   __return_r20_r31,.-__return_r20_r31
1046
#endif /* L_save_20c */
1047
 
1048
#ifdef  L_save_21c
1049
        .text
1050
        .align  2
1051
        .globl  __save_r21_r31
1052
        .type   __save_r21_r31,@function
1053
        /* Allocate space and save registers 21 .. 29, 31 on the stack */
1054
        /* Also allocate space for the argument save area */
1055
        /* Called via:  jalr __save_r21_r31,r10 */
1056
__save_r21_r31:
1057
#ifdef __EP__
1058
        mov     ep,r1
1059
        addi    -56,sp,sp
1060
        mov     sp,ep
1061
        sst.w   r29,16[ep]
1062
        sst.w   r28,20[ep]
1063
        sst.w   r27,24[ep]
1064
        sst.w   r26,28[ep]
1065
        sst.w   r25,32[ep]
1066
        sst.w   r24,36[ep]
1067
        sst.w   r23,40[ep]
1068
        sst.w   r22,44[ep]
1069
        sst.w   r21,48[ep]
1070
        sst.w   r31,52[ep]
1071
        mov     r1,ep
1072
#else
1073
        addi    -56,sp,sp
1074
        st.w    r29,16[sp]
1075
        st.w    r28,20[sp]
1076
        st.w    r27,24[sp]
1077
        st.w    r26,28[sp]
1078
        st.w    r25,32[sp]
1079
        st.w    r24,36[sp]
1080
        st.w    r23,40[sp]
1081
        st.w    r22,44[sp]
1082
        st.w    r21,48[sp]
1083
        st.w    r31,52[sp]
1084
#endif
1085
        jmp     [r10]
1086
        .size   __save_r21_r31,.-__save_r21_r31
1087
 
1088
        /* Restore saved registers, deallocate stack and return to the user */
1089
        /* Called via:  jr __return_r21_r31 */
1090
        .align  2
1091
        .globl  __return_r21_r31
1092
        .type   __return_r21_r31,@function
1093
__return_r21_r31:
1094
#ifdef __EP__
1095
        mov     ep,r1
1096
        mov     sp,ep
1097
        sld.w   16[ep],r29
1098
        sld.w   20[ep],r28
1099
        sld.w   24[ep],r27
1100
        sld.w   28[ep],r26
1101
        sld.w   32[ep],r25
1102
        sld.w   36[ep],r24
1103
        sld.w   40[ep],r23
1104
        sld.w   44[ep],r22
1105
        sld.w   48[ep],r21
1106
        sld.w   52[ep],r31
1107
        addi    56,sp,sp
1108
        mov     r1,ep
1109
#else
1110
        ld.w    16[sp],r29
1111
        ld.w    20[sp],r28
1112
        ld.w    24[sp],r27
1113
        ld.w    28[sp],r26
1114
        ld.w    32[sp],r25
1115
        ld.w    36[sp],r24
1116
        ld.w    40[sp],r23
1117
        ld.w    44[sp],r22
1118
        ld.w    48[sp],r21
1119
        ld.w    52[sp],r31
1120
        addi    56,sp,sp
1121
#endif
1122
        jmp     [r31]
1123
        .size   __return_r21_r31,.-__return_r21_r31
1124
#endif /* L_save_21c */
1125
 
1126
#ifdef  L_save_22c
1127
        .text
1128
        .align  2
1129
        .globl  __save_r22_r31
1130
        .type   __save_r22_r31,@function
1131
        /* Allocate space and save registers 22 .. 29, 31 on the stack */
1132
        /* Also allocate space for the argument save area */
1133
        /* Called via:  jalr __save_r22_r31,r10 */
1134
__save_r22_r31:
1135
#ifdef __EP__
1136
        mov     ep,r1
1137
        addi    -52,sp,sp
1138
        mov     sp,ep
1139
        sst.w   r29,16[ep]
1140
        sst.w   r28,20[ep]
1141
        sst.w   r27,24[ep]
1142
        sst.w   r26,28[ep]
1143
        sst.w   r25,32[ep]
1144
        sst.w   r24,36[ep]
1145
        sst.w   r23,40[ep]
1146
        sst.w   r22,44[ep]
1147
        sst.w   r31,48[ep]
1148
        mov     r1,ep
1149
#else
1150
        addi    -52,sp,sp
1151
        st.w    r29,16[sp]
1152
        st.w    r28,20[sp]
1153
        st.w    r27,24[sp]
1154
        st.w    r26,28[sp]
1155
        st.w    r25,32[sp]
1156
        st.w    r24,36[sp]
1157
        st.w    r23,40[sp]
1158
        st.w    r22,44[sp]
1159
        st.w    r31,48[sp]
1160
#endif
1161
        jmp     [r10]
1162
        .size   __save_r22_r31,.-__save_r22_r31
1163
 
1164
        /* Restore saved registers, deallocate stack and return to the user */
1165
        /* Called via:  jr __return_r22_r31 */
1166
        .align  2
1167
        .globl  __return_r22_r31
1168
        .type   __return_r22_r31,@function
1169
__return_r22_r31:
1170
#ifdef __EP__
1171
        mov     ep,r1
1172
        mov     sp,ep
1173
        sld.w   16[ep],r29
1174
        sld.w   20[ep],r28
1175
        sld.w   24[ep],r27
1176
        sld.w   28[ep],r26
1177
        sld.w   32[ep],r25
1178
        sld.w   36[ep],r24
1179
        sld.w   40[ep],r23
1180
        sld.w   44[ep],r22
1181
        sld.w   48[ep],r31
1182
        addi    52,sp,sp
1183
        mov     r1,ep
1184
#else
1185
        ld.w    16[sp],r29
1186
        ld.w    20[sp],r28
1187
        ld.w    24[sp],r27
1188
        ld.w    28[sp],r26
1189
        ld.w    32[sp],r25
1190
        ld.w    36[sp],r24
1191
        ld.w    40[sp],r23
1192
        ld.w    44[sp],r22
1193
        ld.w    48[sp],r31
1194
        addi    52,sp,sp
1195
#endif
1196
        jmp     [r31]
1197
        .size   __return_r22_r31,.-__return_r22_r31
1198
#endif /* L_save_22c */
1199
 
1200
#ifdef  L_save_23c
1201
        .text
1202
        .align  2
1203
        .globl  __save_r23_r31
1204
        .type   __save_r23_r31,@function
1205
        /* Allocate space and save registers 23 .. 29, 31 on the stack */
1206
        /* Also allocate space for the argument save area */
1207
        /* Called via:  jalr __save_r23_r31,r10 */
1208
__save_r23_r31:
1209
#ifdef __EP__
1210
        mov     ep,r1
1211
        addi    -48,sp,sp
1212
        mov     sp,ep
1213
        sst.w   r29,16[ep]
1214
        sst.w   r28,20[ep]
1215
        sst.w   r27,24[ep]
1216
        sst.w   r26,28[ep]
1217
        sst.w   r25,32[ep]
1218
        sst.w   r24,36[ep]
1219
        sst.w   r23,40[ep]
1220
        sst.w   r31,44[ep]
1221
        mov     r1,ep
1222
#else
1223
        addi    -48,sp,sp
1224
        st.w    r29,16[sp]
1225
        st.w    r28,20[sp]
1226
        st.w    r27,24[sp]
1227
        st.w    r26,28[sp]
1228
        st.w    r25,32[sp]
1229
        st.w    r24,36[sp]
1230
        st.w    r23,40[sp]
1231
        st.w    r31,44[sp]
1232
#endif
1233
        jmp     [r10]
1234
        .size   __save_r23_r31,.-__save_r23_r31
1235
 
1236
        /* Restore saved registers, deallocate stack and return to the user */
1237
        /* Called via:  jr __return_r23_r31 */
1238
        .align  2
1239
        .globl  __return_r23_r31
1240
        .type   __return_r23_r31,@function
1241
__return_r23_r31:
1242
#ifdef __EP__
1243
        mov     ep,r1
1244
        mov     sp,ep
1245
        sld.w   16[ep],r29
1246
        sld.w   20[ep],r28
1247
        sld.w   24[ep],r27
1248
        sld.w   28[ep],r26
1249
        sld.w   32[ep],r25
1250
        sld.w   36[ep],r24
1251
        sld.w   40[ep],r23
1252
        sld.w   44[ep],r31
1253
        addi    48,sp,sp
1254
        mov     r1,ep
1255
#else
1256
        ld.w    16[sp],r29
1257
        ld.w    20[sp],r28
1258
        ld.w    24[sp],r27
1259
        ld.w    28[sp],r26
1260
        ld.w    32[sp],r25
1261
        ld.w    36[sp],r24
1262
        ld.w    40[sp],r23
1263
        ld.w    44[sp],r31
1264
        addi    48,sp,sp
1265
#endif
1266
        jmp     [r31]
1267
        .size   __return_r23_r31,.-__return_r23_r31
1268
#endif /* L_save_23c */
1269
 
1270
#ifdef  L_save_24c
1271
        .text
1272
        .align  2
1273
        .globl  __save_r24_r31
1274
        .type   __save_r24_r31,@function
1275
        /* Allocate space and save registers 24 .. 29, 31 on the stack */
1276
        /* Also allocate space for the argument save area */
1277
        /* Called via:  jalr __save_r24_r31,r10 */
1278
__save_r24_r31:
1279
#ifdef __EP__
1280
        mov     ep,r1
1281
        addi    -44,sp,sp
1282
        mov     sp,ep
1283
        sst.w   r29,16[ep]
1284
        sst.w   r28,20[ep]
1285
        sst.w   r27,24[ep]
1286
        sst.w   r26,28[ep]
1287
        sst.w   r25,32[ep]
1288
        sst.w   r24,36[ep]
1289
        sst.w   r31,40[ep]
1290
        mov     r1,ep
1291
#else
1292
        addi    -44,sp,sp
1293
        st.w    r29,16[sp]
1294
        st.w    r28,20[sp]
1295
        st.w    r27,24[sp]
1296
        st.w    r26,28[sp]
1297
        st.w    r25,32[sp]
1298
        st.w    r24,36[sp]
1299
        st.w    r31,40[sp]
1300
#endif
1301
        jmp     [r10]
1302
        .size   __save_r24_r31,.-__save_r24_r31
1303
 
1304
        /* Restore saved registers, deallocate stack and return to the user */
1305
        /* Called via:  jr __return_r24_r31 */
1306
        .align  2
1307
        .globl  __return_r24_r31
1308
        .type   __return_r24_r31,@function
1309
__return_r24_r31:
1310
#ifdef __EP__
1311
        mov     ep,r1
1312
        mov     sp,ep
1313
        sld.w   16[ep],r29
1314
        sld.w   20[ep],r28
1315
        sld.w   24[ep],r27
1316
        sld.w   28[ep],r26
1317
        sld.w   32[ep],r25
1318
        sld.w   36[ep],r24
1319
        sld.w   40[ep],r31
1320
        addi    44,sp,sp
1321
        mov     r1,ep
1322
#else
1323
        ld.w    16[sp],r29
1324
        ld.w    20[sp],r28
1325
        ld.w    24[sp],r27
1326
        ld.w    28[sp],r26
1327
        ld.w    32[sp],r25
1328
        ld.w    36[sp],r24
1329
        ld.w    40[sp],r31
1330
        addi    44,sp,sp
1331
#endif
1332
        jmp     [r31]
1333
        .size   __return_r24_r31,.-__return_r24_r31
1334
#endif /* L_save_24c */
1335
 
1336
#ifdef  L_save_25c
1337
        .text
1338
        .align  2
1339
        .globl  __save_r25_r31
1340
        .type   __save_r25_r31,@function
1341
        /* Allocate space and save registers 25 .. 29, 31 on the stack */
1342
        /* Also allocate space for the argument save area */
1343
        /* Called via:  jalr __save_r25_r31,r10 */
1344
__save_r25_r31:
1345
#ifdef __EP__
1346
        mov     ep,r1
1347
        addi    -40,sp,sp
1348
        mov     sp,ep
1349
        sst.w   r29,16[ep]
1350
        sst.w   r28,20[ep]
1351
        sst.w   r27,24[ep]
1352
        sst.w   r26,28[ep]
1353
        sst.w   r25,32[ep]
1354
        sst.w   r31,36[ep]
1355
        mov     r1,ep
1356
#else
1357
        addi    -40,sp,sp
1358
        st.w    r29,16[sp]
1359
        st.w    r28,20[sp]
1360
        st.w    r27,24[sp]
1361
        st.w    r26,28[sp]
1362
        st.w    r25,32[sp]
1363
        st.w    r31,36[sp]
1364
#endif
1365
        jmp     [r10]
1366
        .size   __save_r25_r31,.-__save_r25_r31
1367
 
1368
        /* Restore saved registers, deallocate stack and return to the user */
1369
        /* Called via:  jr __return_r25_r31 */
1370
        .align  2
1371
        .globl  __return_r25_r31
1372
        .type   __return_r25_r31,@function
1373
__return_r25_r31:
1374
#ifdef __EP__
1375
        mov     ep,r1
1376
        mov     sp,ep
1377
        sld.w   16[ep],r29
1378
        sld.w   20[ep],r28
1379
        sld.w   24[ep],r27
1380
        sld.w   28[ep],r26
1381
        sld.w   32[ep],r25
1382
        sld.w   36[ep],r31
1383
        addi    40,sp,sp
1384
        mov     r1,ep
1385
#else
1386
        ld.w    16[sp],r29
1387
        ld.w    20[sp],r28
1388
        ld.w    24[sp],r27
1389
        ld.w    28[sp],r26
1390
        ld.w    32[sp],r25
1391
        ld.w    36[sp],r31
1392
        addi    40,sp,sp
1393
#endif
1394
        jmp     [r31]
1395
        .size   __return_r25_r31,.-__return_r25_r31
1396
#endif /* L_save_25c */
1397
 
1398
#ifdef  L_save_26c
1399
        .text
1400
        .align  2
1401
        .globl  __save_r26_r31
1402
        .type   __save_r26_r31,@function
1403
        /* Allocate space and save registers 26 .. 29, 31 on the stack */
1404
        /* Also allocate space for the argument save area */
1405
        /* Called via:  jalr __save_r26_r31,r10 */
1406
__save_r26_r31:
1407
#ifdef __EP__
1408
        mov     ep,r1
1409
        addi    -36,sp,sp
1410
        mov     sp,ep
1411
        sst.w   r29,16[ep]
1412
        sst.w   r28,20[ep]
1413
        sst.w   r27,24[ep]
1414
        sst.w   r26,28[ep]
1415
        sst.w   r31,32[ep]
1416
        mov     r1,ep
1417
#else
1418
        addi    -36,sp,sp
1419
        st.w    r29,16[sp]
1420
        st.w    r28,20[sp]
1421
        st.w    r27,24[sp]
1422
        st.w    r26,28[sp]
1423
        st.w    r31,32[sp]
1424
#endif
1425
        jmp     [r10]
1426
        .size   __save_r26_r31,.-__save_r26_r31
1427
 
1428
        /* Restore saved registers, deallocate stack and return to the user */
1429
        /* Called via:  jr __return_r26_r31 */
1430
        .align  2
1431
        .globl  __return_r26_r31
1432
        .type   __return_r26_r31,@function
1433
__return_r26_r31:
1434
#ifdef __EP__
1435
        mov     ep,r1
1436
        mov     sp,ep
1437
        sld.w   16[ep],r29
1438
        sld.w   20[ep],r28
1439
        sld.w   24[ep],r27
1440
        sld.w   28[ep],r26
1441
        sld.w   32[ep],r31
1442
        addi    36,sp,sp
1443
        mov     r1,ep
1444
#else
1445
        ld.w    16[sp],r29
1446
        ld.w    20[sp],r28
1447
        ld.w    24[sp],r27
1448
        ld.w    28[sp],r26
1449
        ld.w    32[sp],r31
1450
        addi    36,sp,sp
1451
#endif
1452
        jmp     [r31]
1453
        .size   __return_r26_r31,.-__return_r26_r31
1454
#endif /* L_save_26c */
1455
 
1456
#ifdef  L_save_27c
1457
        .text
1458
        .align  2
1459
        .globl  __save_r27_r31
1460
        .type   __save_r27_r31,@function
1461
        /* Allocate space and save registers 27 .. 29, 31 on the stack */
1462
        /* Also allocate space for the argument save area */
1463
        /* Called via:  jalr __save_r27_r31,r10 */
1464
__save_r27_r31:
1465
#ifdef __EP__
1466
        mov     ep,r1
1467
        addi    -32,sp,sp
1468
        mov     sp,ep
1469
        sst.w   r29,16[ep]
1470
        sst.w   r28,20[ep]
1471
        sst.w   r27,24[ep]
1472
        sst.w   r31,28[ep]
1473
        mov     r1,ep
1474
#else
1475
        addi    -32,sp,sp
1476
        st.w    r29,16[sp]
1477
        st.w    r28,20[sp]
1478
        st.w    r27,24[sp]
1479
        st.w    r31,28[sp]
1480
#endif
1481
        jmp     [r10]
1482
        .size   __save_r27_r31,.-__save_r27_r31
1483
 
1484
        /* Restore saved registers, deallocate stack and return to the user */
1485
        /* Called via:  jr __return_r27_r31 */
1486
        .align  2
1487
        .globl  __return_r27_r31
1488
        .type   __return_r27_r31,@function
1489
__return_r27_r31:
1490
#ifdef __EP__
1491
        mov     ep,r1
1492
        mov     sp,ep
1493
        sld.w   16[ep],r29
1494
        sld.w   20[ep],r28
1495
        sld.w   24[ep],r27
1496
        sld.w   28[ep],r31
1497
        addi    32,sp,sp
1498
        mov     r1,ep
1499
#else
1500
        ld.w    16[sp],r29
1501
        ld.w    20[sp],r28
1502
        ld.w    24[sp],r27
1503
        ld.w    28[sp],r31
1504
        addi    32,sp,sp
1505
#endif
1506
        jmp     [r31]
1507
        .size   __return_r27_r31,.-__return_r27_r31
1508
#endif /* L_save_27c */
1509
 
1510
#ifdef  L_save_28c
1511
        .text
1512
        .align  2
1513
        .globl  __save_r28_r31
1514
        .type   __save_r28_r31,@function
1515
        /* Allocate space and save registers 28 .. 29, 31 on the stack */
1516
        /* Also allocate space for the argument save area */
1517
        /* Called via:  jalr __save_r28_r31,r10 */
1518
__save_r28_r31:
1519
        addi    -28,sp,sp
1520
        st.w    r29,16[sp]
1521
        st.w    r28,20[sp]
1522
        st.w    r31,24[sp]
1523
        jmp     [r10]
1524
        .size   __save_r28_r31,.-__save_r28_r31
1525
 
1526
        /* Restore saved registers, deallocate stack and return to the user */
1527
        /* Called via:  jr __return_r28_r31 */
1528
        .align  2
1529
        .globl  __return_r28_r31
1530
        .type   __return_r28_r31,@function
1531
__return_r28_r31:
1532
        ld.w    16[sp],r29
1533
        ld.w    20[sp],r28
1534
        ld.w    24[sp],r31
1535
        addi    28,sp,sp
1536
        jmp     [r31]
1537
        .size   __return_r28_r31,.-__return_r28_r31
1538
#endif /* L_save_28c */
1539
 
1540
#ifdef  L_save_29c
1541
        .text
1542
        .align  2
1543
        .globl  __save_r29_r31
1544
        .type   __save_r29_r31,@function
1545
        /* Allocate space and save registers 29 & 31 on the stack */
1546
        /* Also allocate space for the argument save area */
1547
        /* Called via:  jalr __save_r29_r31,r10 */
1548
__save_r29_r31:
1549
        addi    -24,sp,sp
1550
        st.w    r29,16[sp]
1551
        st.w    r31,20[sp]
1552
        jmp     [r10]
1553
        .size   __save_r29_r31,.-__save_r29_r31
1554
 
1555
        /* Restore saved registers, deallocate stack and return to the user */
1556
        /* Called via:  jr __return_r29_r31 */
1557
        .align  2
1558
        .globl  __return_r29_r31
1559
        .type   __return_r29_r31,@function
1560
__return_r29_r31:
1561
        ld.w    16[sp],r29
1562
        ld.w    20[sp],r31
1563
        addi    24,sp,sp
1564
        jmp     [r31]
1565
        .size   __return_r29_r31,.-__return_r29_r31
1566
#endif /* L_save_29c */
1567
 
1568
#ifdef  L_save_31c
1569
        .text
1570
        .align  2
1571
        .globl  __save_r31
1572
        .type   __save_r31,@function
1573
        /* Allocate space and save register 31 on the stack.  */
1574
        /* Also allocate space for the argument save area.  */
1575
        /* Called via:  jalr __save_r31,r10 */
1576
__save_r31:
1577
        addi    -20,sp,sp
1578
        st.w    r31,16[sp]
1579
        jmp     [r10]
1580
        .size   __save_r31,.-__save_r31
1581
 
1582
        /* Restore saved registers, deallocate stack and return to the user.  */
1583
        /* Called via:  jr __return_r31 */
1584
        .align  2
1585
        .globl  __return_r31
1586
        .type   __return_r31,@function
1587
__return_r31:
1588
        ld.w    16[sp],r31
1589
        addi    20,sp,sp
1590
        jmp     [r31]
1591
        .size   __return_r31,.-__return_r31
1592
#endif /* L_save_31c */
1593
 
1594
#ifdef L_save_varargs
1595
        .text
1596
        .align  2
1597
        .globl  __save_r6_r9
1598
        .type   __save_r6_r9,@function
1599
        /* Save registers 6 .. 9 on the stack for variable argument functions.  */
1600
        /* Called via:  jalr __save_r6_r9,r10 */
1601
__save_r6_r9:
1602
#ifdef __EP__
1603
        mov     ep,r1
1604
        mov     sp,ep
1605
        sst.w   r6,0[ep]
1606
        sst.w   r7,4[ep]
1607
        sst.w   r8,8[ep]
1608
        sst.w   r9,12[ep]
1609
        mov     r1,ep
1610
#else
1611
        st.w    r6,0[sp]
1612
        st.w    r7,4[sp]
1613
        st.w    r8,8[sp]
1614
        st.w    r9,12[sp]
1615
#endif
1616
        jmp     [r10]
1617
        .size   __save_r6_r9,.-__save_r6_r9
1618
#endif /* L_save_varargs */
1619
 
1620
#ifdef  L_save_interrupt
1621
        .text
1622
        .align  2
1623
        .globl  __save_interrupt
1624
        .type   __save_interrupt,@function
1625
        /* Save registers r1, r4 on stack and load up with expected values.  */
1626
        /* Note, 12 bytes of stack have already been allocated.  */
1627
        /* Called via:  jalr __save_interrupt,r10 */
1628
__save_interrupt:
1629
        st.w    ep,0[sp]
1630
        st.w    gp,4[sp]
1631
        st.w    r1,8[sp]
1632
        movhi   hi(__ep),r0,ep
1633
        movea   lo(__ep),ep,ep
1634
        movhi   hi(__gp),r0,gp
1635
        movea   lo(__gp),gp,gp
1636
        jmp     [r10]
1637
        .size   __save_interrupt,.-__save_interrupt
1638
 
1639
        /* Restore saved registers, deallocate stack and return from the interrupt.  */
1640
        /* Called via:  jr __return_interrupt */
1641
        .align  2
1642
        .globl  __return_interrupt
1643
        .type   __return_interrupt,@function
1644
__return_interrupt:
1645
        ld.w    0[sp],ep
1646
        ld.w    4[sp],gp
1647
        ld.w    8[sp],r1
1648
        ld.w    12[sp],r10
1649
        addi    16,sp,sp
1650
        reti
1651
        .size   __return_interrupt,.-__return_interrupt
1652
#endif /* L_save_interrupt */
1653
 
1654
#ifdef L_save_all_interrupt
1655
        .text
1656
        .align  2
1657
        .globl  __save_all_interrupt
1658
        .type   __save_all_interrupt,@function
1659
        /* Save all registers except for those saved in __save_interrupt.  */
1660
        /* Allocate enough stack for all of the registers & 16 bytes of space.  */
1661
        /* Called via:  jalr __save_all_interrupt,r10 */
1662
__save_all_interrupt:
1663
        addi    -120,sp,sp
1664
#ifdef __EP__
1665
        mov     ep,r1
1666
        mov     sp,ep
1667
        sst.w   r31,116[ep]
1668
        sst.w   r2,112[ep]
1669
        sst.w   gp,108[ep]
1670
        sst.w   r6,104[ep]
1671
        sst.w   r7,100[ep]
1672
        sst.w   r8,96[ep]
1673
        sst.w   r9,92[ep]
1674
        sst.w   r11,88[ep]
1675
        sst.w   r12,84[ep]
1676
        sst.w   r13,80[ep]
1677
        sst.w   r14,76[ep]
1678
        sst.w   r15,72[ep]
1679
        sst.w   r16,68[ep]
1680
        sst.w   r17,64[ep]
1681
        sst.w   r18,60[ep]
1682
        sst.w   r19,56[ep]
1683
        sst.w   r20,52[ep]
1684
        sst.w   r21,48[ep]
1685
        sst.w   r22,44[ep]
1686
        sst.w   r23,40[ep]
1687
        sst.w   r24,36[ep]
1688
        sst.w   r25,32[ep]
1689
        sst.w   r26,28[ep]
1690
        sst.w   r27,24[ep]
1691
        sst.w   r28,20[ep]
1692
        sst.w   r29,16[ep]
1693
        mov     r1,ep
1694
#else
1695
        st.w    r31,116[sp]
1696
        st.w    r2,112[sp]
1697
        st.w    gp,108[sp]
1698
        st.w    r6,104[sp]
1699
        st.w    r7,100[sp]
1700
        st.w    r8,96[sp]
1701
        st.w    r9,92[sp]
1702
        st.w    r11,88[sp]
1703
        st.w    r12,84[sp]
1704
        st.w    r13,80[sp]
1705
        st.w    r14,76[sp]
1706
        st.w    r15,72[sp]
1707
        st.w    r16,68[sp]
1708
        st.w    r17,64[sp]
1709
        st.w    r18,60[sp]
1710
        st.w    r19,56[sp]
1711
        st.w    r20,52[sp]
1712
        st.w    r21,48[sp]
1713
        st.w    r22,44[sp]
1714
        st.w    r23,40[sp]
1715
        st.w    r24,36[sp]
1716
        st.w    r25,32[sp]
1717
        st.w    r26,28[sp]
1718
        st.w    r27,24[sp]
1719
        st.w    r28,20[sp]
1720
        st.w    r29,16[sp]
1721
#endif
1722
        jmp     [r10]
1723
        .size   __save_all_interrupt,.-__save_all_interrupt
1724
 
1725
        .globl  __restore_all_interrupt
1726
        .type   __restore_all_interrupt,@function
1727
        /* Restore all registers saved in __save_all_interrupt and
1728
           deallocate the stack space.  */
1729
        /* Called via:  jalr __restore_all_interrupt,r10 */
1730
__restore_all_interrupt:
1731
#ifdef __EP__
1732
        mov     ep,r1
1733
        mov     sp,ep
1734
        sld.w   116[ep],r31
1735
        sld.w   112[ep],r2
1736
        sld.w   108[ep],gp
1737
        sld.w   104[ep],r6
1738
        sld.w   100[ep],r7
1739
        sld.w   96[ep],r8
1740
        sld.w   92[ep],r9
1741
        sld.w   88[ep],r11
1742
        sld.w   84[ep],r12
1743
        sld.w   80[ep],r13
1744
        sld.w   76[ep],r14
1745
        sld.w   72[ep],r15
1746
        sld.w   68[ep],r16
1747
        sld.w   64[ep],r17
1748
        sld.w   60[ep],r18
1749
        sld.w   56[ep],r19
1750
        sld.w   52[ep],r20
1751
        sld.w   48[ep],r21
1752
        sld.w   44[ep],r22
1753
        sld.w   40[ep],r23
1754
        sld.w   36[ep],r24
1755
        sld.w   32[ep],r25
1756
        sld.w   28[ep],r26
1757
        sld.w   24[ep],r27
1758
        sld.w   20[ep],r28
1759
        sld.w   16[ep],r29
1760
        mov     r1,ep
1761
#else
1762
        ld.w    116[sp],r31
1763
        ld.w    112[sp],r2
1764
        ld.w    108[sp],gp
1765
        ld.w    104[sp],r6
1766
        ld.w    100[sp],r7
1767
        ld.w    96[sp],r8
1768
        ld.w    92[sp],r9
1769
        ld.w    88[sp],r11
1770
        ld.w    84[sp],r12
1771
        ld.w    80[sp],r13
1772
        ld.w    76[sp],r14
1773
        ld.w    72[sp],r15
1774
        ld.w    68[sp],r16
1775
        ld.w    64[sp],r17
1776
        ld.w    60[sp],r18
1777
        ld.w    56[sp],r19
1778
        ld.w    52[sp],r20
1779
        ld.w    48[sp],r21
1780
        ld.w    44[sp],r22
1781
        ld.w    40[sp],r23
1782
        ld.w    36[sp],r24
1783
        ld.w    32[sp],r25
1784
        ld.w    28[sp],r26
1785
        ld.w    24[sp],r27
1786
        ld.w    20[sp],r28
1787
        ld.w    16[sp],r29
1788
#endif
1789
        addi    120,sp,sp
1790
        jmp     [r10]
1791
        .size   __restore_all_interrupt,.-__restore_all_interrupt
1792
#endif /* L_save_all_interrupt */
1793
 
1794
 
1795
#if defined __v850e__
1796
#ifdef  L_callt_save_r2_r29
1797
        /* Put these functions into the call table area.  */
1798
        .call_table_text
1799
 
1800
        /* Allocate space and save registers 2, 20 .. 29 on the stack.  */
1801
        /* Called via:  callt ctoff(__callt_save_r2_r29).  */
1802
        .align  2
1803
.L_save_r2_r29:
1804
        add     -4, sp
1805
        st.w    r2, 0[sp]
1806
        prepare {r20 - r29}, 0
1807
        ctret
1808
 
1809
        /* Restore saved registers, deallocate stack and return to the user.  */
1810
        /* Called via:  callt ctoff(__callt_return_r2_r29).  */
1811
        .align  2
1812
.L_return_r2_r29:
1813
        dispose 0, {r20-r29}
1814
        ld.w    0[sp], r2
1815
        add     4, sp
1816
        jmp     [r31]
1817
 
1818
        /* Place the offsets of the start of these routines into the call table.  */
1819
        .call_table_data
1820
 
1821
        .global __callt_save_r2_r29
1822
        .type   __callt_save_r2_r29,@function
1823
__callt_save_r2_r29:    .short ctoff(.L_save_r2_r29)
1824
 
1825
        .global __callt_return_r2_r29
1826
        .type   __callt_return_r2_r29,@function
1827
__callt_return_r2_r29:  .short ctoff(.L_return_r2_r29)
1828
 
1829
#endif /* L_callt_save_r2_r29 */
1830
 
1831
#ifdef  L_callt_save_r2_r31
1832
        /* Put these functions into the call table area.  */
1833
        .call_table_text
1834
 
1835
        /* Allocate space and save registers 2 and 20 .. 29, 31 on the stack.  */
1836
        /* Also allocate space for the argument save area.  */
1837
        /* Called via:  callt ctoff(__callt_save_r2_r31).  */
1838
        .align  2
1839
.L_save_r2_r31:
1840
        add     -4, sp
1841
        st.w    r2, 0[sp]
1842
        prepare {r20 - r29, r31}, 4
1843
        ctret
1844
 
1845
        /* Restore saved registers, deallocate stack and return to the user.  */
1846
        /* Called via:  callt ctoff(__callt_return_r2_r31).  */
1847
        .align  2
1848
.L_return_r2_r31:
1849
        dispose 4, {r20 - r29, r31}
1850
        ld.w    0[sp], r2
1851
        addi    4, sp, sp
1852
        jmp     [r31]
1853
 
1854
        /* Place the offsets of the start of these routines into the call table.  */
1855
        .call_table_data
1856
 
1857
        .global __callt_save_r2_r31
1858
        .type   __callt_save_r2_r31,@function
1859
__callt_save_r2_r31:    .short ctoff(.L_save_r2_r31)
1860
 
1861
        .global __callt_return_r2_r31
1862
        .type   __callt_return_r2_r31,@function
1863
__callt_return_r2_r31:  .short ctoff(.L_return_r2_r31)
1864
 
1865
#endif /* L_callt_save_r2_r31 */
1866
 
1867
 
1868
#ifdef L_callt_save_r6_r9
1869
        /* Put these functions into the call table area.  */
1870
        .call_table_text
1871
 
1872
        /* Save registers r6 - r9 onto the stack in the space reserved for them.
1873
           Use by variable argument functions.
1874
           Called via:  callt ctoff(__callt_save_r6_r9).  */
1875
        .align  2
1876
.L_save_r6_r9:
1877
#ifdef __EP__
1878
        mov     ep,r1
1879
        mov     sp,ep
1880
        sst.w   r6,0[ep]
1881
        sst.w   r7,4[ep]
1882
        sst.w   r8,8[ep]
1883
        sst.w   r9,12[ep]
1884
        mov     r1,ep
1885
#else
1886
        st.w    r6,0[sp]
1887
        st.w    r7,4[sp]
1888
        st.w    r8,8[sp]
1889
        st.w    r9,12[sp]
1890
#endif
1891
        ctret
1892
 
1893
        /* Place the offsets of the start of this routines into the call table.  */
1894
        .call_table_data
1895
 
1896
        .global __callt_save_r6_r9
1897
        .type   __callt_save_r6_r9,@function
1898
__callt_save_r6_r9:     .short ctoff(.L_save_r6_r9)
1899
#endif /* L_callt_save_r6_r9 */
1900
 
1901
 
1902
#ifdef  L_callt_save_interrupt
1903
        /* Put these functions into the call table area.  */
1904
        .call_table_text
1905
 
1906
        /* Save registers r1, ep, gp, r10 on stack and load up with expected values.  */
1907
        /* Called via:  callt ctoff(__callt_save_interrupt).  */
1908
        .align  2
1909
.L_save_interrupt:
1910
        /* SP has already been moved before callt ctoff(_save_interrupt).  */
1911
        /* addi -24, sp, sp  */
1912
        st.w    ep,  0[sp]
1913
        st.w    gp,  4[sp]
1914
        st.w    r1,  8[sp]
1915
        /* R10 has already been saved before callt ctoff(_save_interrupt).  */
1916
        /* st.w    r10, 12[sp]  */
1917
        mov     hilo(__ep),ep
1918
        mov     hilo(__gp),gp
1919
        ctret
1920
 
1921
        /* Restore saved registers, deallocate stack and return from the interrupt.  */
1922
        /* Called via:  callt ctoff(__callt_restore_interrupt).  */
1923
        .align  2
1924
        .globl  __return_interrupt
1925
        .type   __return_interrupt,@function
1926
.L_return_interrupt:
1927
        ld.w    20[sp], r1
1928
        ldsr    r1,     ctpsw
1929
        ld.w    16[sp], r1
1930
        ldsr    r1,     ctpc
1931
        ld.w    12[sp], r10
1932
        ld.w     8[sp], r1
1933
        ld.w     4[sp], gp
1934
        ld.w     0[sp], ep
1935
        addi    24, sp, sp
1936
        reti
1937
 
1938
        /* Place the offsets of the start of these routines into the call table.  */
1939
        .call_table_data
1940
 
1941
        .global __callt_save_interrupt
1942
        .type   __callt_save_interrupt,@function
1943
__callt_save_interrupt:         .short ctoff(.L_save_interrupt)
1944
 
1945
        .global __callt_return_interrupt
1946
        .type   __callt_return_interrupt,@function
1947
__callt_return_interrupt:       .short ctoff(.L_return_interrupt)
1948
 
1949
#endif /* L_callt_save_interrupt */
1950
 
1951
#ifdef L_callt_save_all_interrupt
1952
        /* Put these functions into the call table area.  */
1953
        .call_table_text
1954
 
1955
        /* Save all registers except for those saved in __save_interrupt.  */
1956
        /* Allocate enough stack for all of the registers & 16 bytes of space.  */
1957
        /* Called via:  callt ctoff(__callt_save_all_interrupt).  */
1958
        .align  2
1959
.L_save_all_interrupt:
1960
        addi    -60, sp, sp
1961
#ifdef __EP__
1962
        mov     ep,  r1
1963
        mov     sp,  ep
1964
        sst.w   r2,  56[ep]
1965
        sst.w   r5,  52[ep]
1966
        sst.w   r6,  48[ep]
1967
        sst.w   r7,  44[ep]
1968
        sst.w   r8,  40[ep]
1969
        sst.w   r9,  36[ep]
1970
        sst.w   r11, 32[ep]
1971
        sst.w   r12, 28[ep]
1972
        sst.w   r13, 24[ep]
1973
        sst.w   r14, 20[ep]
1974
        sst.w   r15, 16[ep]
1975
        sst.w   r16, 12[ep]
1976
        sst.w   r17, 8[ep]
1977
        sst.w   r18, 4[ep]
1978
        sst.w   r19, 0[ep]
1979
        mov     r1,  ep
1980
#else
1981
        st.w    r2,  56[sp]
1982
        st.w    r5,  52[sp]
1983
        st.w    r6,  48[sp]
1984
        st.w    r7,  44[sp]
1985
        st.w    r8,  40[sp]
1986
        st.w    r9,  36[sp]
1987
        st.w    r11, 32[sp]
1988
        st.w    r12, 28[sp]
1989
        st.w    r13, 24[sp]
1990
        st.w    r14, 20[sp]
1991
        st.w    r15, 16[sp]
1992
        st.w    r16, 12[sp]
1993
        st.w    r17, 8[sp]
1994
        st.w    r18, 4[sp]
1995
        st.w    r19, 0[sp]
1996
#endif
1997
        prepare {r20 - r29, r31}, 4
1998
        ctret
1999
 
2000
        /* Restore all registers saved in __save_all_interrupt
2001
           deallocate the stack space.  */
2002
        /* Called via:  callt ctoff(__callt_restore_all_interrupt).  */
2003
        .align 2
2004
.L_restore_all_interrupt:
2005
        dispose 4, {r20 - r29, r31}
2006
#ifdef __EP__
2007
        mov     ep, r1
2008
        mov     sp, ep
2009
        sld.w   0 [ep], r19
2010
        sld.w   4 [ep], r18
2011
        sld.w   8 [ep], r17
2012
        sld.w   12[ep], r16
2013
        sld.w   16[ep], r15
2014
        sld.w   20[ep], r14
2015
        sld.w   24[ep], r13
2016
        sld.w   28[ep], r12
2017
        sld.w   32[ep], r11
2018
        sld.w   36[ep], r9
2019
        sld.w   40[ep], r8
2020
        sld.w   44[ep], r7
2021
        sld.w   48[ep], r6
2022
        sld.w   52[ep], r5
2023
        sld.w   56[ep], r2
2024
        mov     r1, ep
2025
#else
2026
        ld.w    0 [sp], r19
2027
        ld.w    4 [sp], r18
2028
        ld.w    8 [sp], r17
2029
        ld.w    12[sp], r16
2030
        ld.w    16[sp], r15
2031
        ld.w    20[sp], r14
2032
        ld.w    24[sp], r13
2033
        ld.w    28[sp], r12
2034
        ld.w    32[sp], r11
2035
        ld.w    36[sp], r9
2036
        ld.w    40[sp], r8
2037
        ld.w    44[sp], r7
2038
        ld.w    48[sp], r6
2039
        ld.w    52[sp], r5
2040
        ld.w    56[sp], r2
2041
#endif
2042
        addi    60, sp, sp
2043
        ctret
2044
 
2045
        /* Place the offsets of the start of these routines into the call table.  */
2046
        .call_table_data
2047
 
2048
        .global __callt_save_all_interrupt
2049
        .type   __callt_save_all_interrupt,@function
2050
__callt_save_all_interrupt:     .short ctoff(.L_save_all_interrupt)
2051
 
2052
        .global __callt_restore_all_interrupt
2053
        .type   __callt_restore_all_interrupt,@function
2054
__callt_restore_all_interrupt:  .short ctoff(.L_restore_all_interrupt)
2055
 
2056
#endif /* L_callt_save_all_interrupt */
2057
 
2058
 
2059
#define MAKE_CALLT_FUNCS( START )                                               \
2060
        .call_table_text                                                        ;\
2061
        .align  2                                                               ;\
2062
        /* Allocate space and save registers START .. r29 on the stack.  */     ;\
2063
        /* Called via:  callt ctoff(__callt_save_START_r29).  */                ;\
2064
.L_save_##START##_r29:                                                          ;\
2065
        prepare { START - r29 }, 0                                              ;\
2066
        ctret                                                                   ;\
2067
                                                                                ;\
2068
        /* Restore saved registers, deallocate stack and return.  */            ;\
2069
        /* Called via:  callt ctoff(__return_START_r29) */                      ;\
2070
        .align  2                                                               ;\
2071
.L_return_##START##_r29:                                                        ;\
2072
        dispose 0, { START - r29 }, r31                                         ;\
2073
                                                                                ;\
2074
        /* Place the offsets of the start of these funcs into the call table.  */;\
2075
        .call_table_data                                                        ;\
2076
                                                                                ;\
2077
        .global __callt_save_##START##_r29                                      ;\
2078
        .type   __callt_save_##START##_r29,@function                            ;\
2079
__callt_save_##START##_r29:     .short ctoff(.L_save_##START##_r29 )            ;\
2080
                                                                                ;\
2081
        .global __callt_return_##START##_r29                                    ;\
2082
        .type   __callt_return_##START##_r29,@function                          ;\
2083
__callt_return_##START##_r29:   .short ctoff(.L_return_##START##_r29 )
2084
 
2085
 
2086
#define MAKE_CALLT_CFUNCS( START )                                              \
2087
        .call_table_text                                                        ;\
2088
        .align  2                                                               ;\
2089
        /* Allocate space and save registers START .. r31 on the stack.  */     ;\
2090
        /* Called via:  callt ctoff(__callt_save_START_r31c).  */               ;\
2091
.L_save_##START##_r31c:                                                         ;\
2092
        prepare { START - r29, r31}, 4                                          ;\
2093
        ctret                                                                   ;\
2094
                                                                                ;\
2095
        /* Restore saved registers, deallocate stack and return.  */            ;\
2096
        /* Called via:  callt ctoff(__return_START_r31c).  */                   ;\
2097
        .align  2                                                               ;\
2098
.L_return_##START##_r31c:                                                       ;\
2099
        dispose 4, { START - r29, r31}, r31                                     ;\
2100
                                                                                ;\
2101
        /* Place the offsets of the start of these funcs into the call table.  */;\
2102
        .call_table_data                                                        ;\
2103
                                                                                ;\
2104
        .global __callt_save_##START##_r31c                                     ;\
2105
        .type   __callt_save_##START##_r31c,@function                           ;\
2106
__callt_save_##START##_r31c:    .short ctoff(.L_save_##START##_r31c )           ;\
2107
                                                                                ;\
2108
        .global __callt_return_##START##_r31c                                   ;\
2109
        .type   __callt_return_##START##_r31c,@function                         ;\
2110
__callt_return_##START##_r31c:  .short ctoff(.L_return_##START##_r31c )
2111
 
2112
 
2113
#ifdef  L_callt_save_20
2114
        MAKE_CALLT_FUNCS (r20)
2115
#endif
2116
#ifdef  L_callt_save_21
2117
        MAKE_CALLT_FUNCS (r21)
2118
#endif
2119
#ifdef  L_callt_save_22
2120
        MAKE_CALLT_FUNCS (r22)
2121
#endif
2122
#ifdef  L_callt_save_23
2123
        MAKE_CALLT_FUNCS (r23)
2124
#endif
2125
#ifdef  L_callt_save_24
2126
        MAKE_CALLT_FUNCS (r24)
2127
#endif
2128
#ifdef  L_callt_save_25
2129
        MAKE_CALLT_FUNCS (r25)
2130
#endif
2131
#ifdef  L_callt_save_26
2132
        MAKE_CALLT_FUNCS (r26)
2133
#endif
2134
#ifdef  L_callt_save_27
2135
        MAKE_CALLT_FUNCS (r27)
2136
#endif
2137
#ifdef  L_callt_save_28
2138
        MAKE_CALLT_FUNCS (r28)
2139
#endif
2140
#ifdef  L_callt_save_29
2141
        MAKE_CALLT_FUNCS (r29)
2142
#endif
2143
 
2144
#ifdef  L_callt_save_20c
2145
        MAKE_CALLT_CFUNCS (r20)
2146
#endif
2147
#ifdef  L_callt_save_21c
2148
        MAKE_CALLT_CFUNCS (r21)
2149
#endif
2150
#ifdef  L_callt_save_22c
2151
        MAKE_CALLT_CFUNCS (r22)
2152
#endif
2153
#ifdef  L_callt_save_23c
2154
        MAKE_CALLT_CFUNCS (r23)
2155
#endif
2156
#ifdef  L_callt_save_24c
2157
        MAKE_CALLT_CFUNCS (r24)
2158
#endif
2159
#ifdef  L_callt_save_25c
2160
        MAKE_CALLT_CFUNCS (r25)
2161
#endif
2162
#ifdef  L_callt_save_26c
2163
        MAKE_CALLT_CFUNCS (r26)
2164
#endif
2165
#ifdef  L_callt_save_27c
2166
        MAKE_CALLT_CFUNCS (r27)
2167
#endif
2168
#ifdef  L_callt_save_28c
2169
        MAKE_CALLT_CFUNCS (r28)
2170
#endif
2171
#ifdef  L_callt_save_29c
2172
        MAKE_CALLT_CFUNCS (r29)
2173
#endif
2174
 
2175
 
2176
#ifdef  L_callt_save_31c
2177
        .call_table_text
2178
        .align  2
2179
        /* Allocate space and save register r31 on the stack.  */
2180
        /* Called via:  callt ctoff(__callt_save_r31c).  */
2181
.L_callt_save_r31c:
2182
        prepare {r31}, 4
2183
        ctret
2184
 
2185
        /* Restore saved registers, deallocate stack and return.  */
2186
        /* Called via:  callt ctoff(__return_r31c).  */
2187
        .align  2
2188
.L_callt_return_r31c:
2189
        dispose 4, {r31}, r31
2190
 
2191
        /* Place the offsets of the start of these funcs into the call table.  */
2192
        .call_table_data
2193
 
2194
        .global __callt_save_r31c
2195
        .type   __callt_save_r31c,@function
2196
__callt_save_r31c:      .short ctoff(.L_callt_save_r31c)
2197
 
2198
        .global __callt_return_r31c
2199
        .type   __callt_return_r31c,@function
2200
__callt_return_r31c:    .short ctoff(.L_callt_return_r31c)
2201
#endif
2202
 
2203
#endif /* __v850e__ */
2204
 
2205
/*  libgcc2 routines for NEC V850.  */
2206
/*  Double Integer Arithmetical Operation.  */
2207
 
2208
#ifdef L_negdi2
2209
        .text
2210
        .global ___negdi2
2211
        .type   ___negdi2, @function
2212
___negdi2:
2213
        not     r6, r10
2214
        add     1,  r10
2215
        setf    l,  r6
2216
        not     r7, r11
2217
        add     r6, r11
2218
        jmp     [lp]
2219
 
2220
        .size ___negdi2,.-___negdi2
2221
#endif
2222
 
2223
#ifdef L_cmpdi2
2224
        .text
2225
        .global ___cmpdi2
2226
        .type   ___cmpdi2,@function
2227
___cmpdi2:
2228
        # Signed comparison bitween each high word.
2229
        cmp     r9, r7
2230
        be      .L_cmpdi_cmp_low
2231
        setf    ge, r10
2232
        setf    gt, r6
2233
        add     r6, r10
2234
        jmp     [lp]
2235
.L_cmpdi_cmp_low:
2236
        # Unsigned comparigon bitween each low word.
2237
        cmp     r8, r6
2238
        setf    nl, r10
2239
        setf    h,  r6
2240
        add     r6, r10
2241
        jmp     [lp]
2242
        .size ___cmpdi2, . - ___cmpdi2
2243
#endif
2244
 
2245
#ifdef L_ucmpdi2
2246
        .text
2247
        .global ___ucmpdi2
2248
        .type   ___ucmpdi2,@function
2249
___ucmpdi2:
2250
        cmp     r9, r7  # Check if each high word are same.
2251
        bne     .L_ucmpdi_check_psw
2252
        cmp     r8, r6  # Compare the word.
2253
.L_ucmpdi_check_psw:
2254
        setf    nl, r10 #
2255
        setf    h,  r6  #
2256
        add     r6, r10 # Add the result of comparison NL and comparison H.
2257
        jmp     [lp]
2258
        .size ___ucmpdi2, . - ___ucmpdi2
2259
#endif
2260
 
2261
#ifdef L_muldi3
2262
        .text
2263
        .global ___muldi3
2264
        .type   ___muldi3,@function
2265
___muldi3:
2266
#ifdef __v850__
2267
        jarl  __save_r26_r31, r10
2268
        addi  16,  sp, sp
2269
        mov   r6,  r28
2270
        shr   15,  r28
2271
        movea lo(32767), r0, r14
2272
        and   r14, r28
2273
        mov   r8,  r10
2274
        shr   15,  r10
2275
        and   r14, r10
2276
        mov   r6,  r19
2277
        shr   30,  r19
2278
        mov   r7,  r12
2279
        shl   2,   r12
2280
        or    r12, r19
2281
        and   r14, r19
2282
        mov   r8,  r13
2283
        shr   30,  r13
2284
        mov   r9,  r12
2285
        shl   2,   r12
2286
        or    r12, r13
2287
        and   r14, r13
2288
        mov   r7,  r11
2289
        shr   13,  r11
2290
        and   r14, r11
2291
        mov   r9,  r31
2292
        shr   13,  r31
2293
        and   r14, r31
2294
        mov   r7,  r29
2295
        shr   28,  r29
2296
        and   r14, r29
2297
        mov   r9,  r12
2298
        shr   28,  r12
2299
        and   r14, r12
2300
        and   r14, r6
2301
        and   r14, r8
2302
        mov   r6,  r14
2303
        mulh  r8,  r14
2304
        mov   r6,  r16
2305
        mulh  r10, r16
2306
        mov   r6,  r18
2307
        mulh  r13, r18
2308
        mov   r6,  r15
2309
        mulh  r31, r15
2310
        mulh  r12, r6
2311
        mov   r28,  r17
2312
        mulh  r10, r17
2313
        add   -16, sp
2314
        mov   r28,  r12
2315
        mulh  r8,  r12
2316
        add   r17, r18
2317
        mov   r28,  r17
2318
        mulh  r31, r17
2319
        add   r12, r16
2320
        mov   r28,  r12
2321
        mulh  r13, r12
2322
        add   r17, r6
2323
        mov   r19, r17
2324
        add   r12, r15
2325
        mov   r19, r12
2326
        mulh  r8,  r12
2327
        mulh  r10, r17
2328
        add   r12, r18
2329
        mov   r19, r12
2330
        mulh  r13, r12
2331
        add   r17, r15
2332
        mov   r11, r13
2333
        mulh  r8,  r13
2334
        add   r12, r6
2335
        mov   r11, r12
2336
        mulh  r10, r12
2337
        add   r13, r15
2338
        mulh  r29, r8
2339
        add   r12, r6
2340
        mov   r16, r13
2341
        shl   15,  r13
2342
        add   r14, r13
2343
        mov   r18, r12
2344
        shl   30,  r12
2345
        mov   r13, r26
2346
        add   r12, r26
2347
        shr   15,  r14
2348
        movhi hi(131071), r0,  r12
2349
        movea lo(131071), r12, r13
2350
        and   r13, r14
2351
        mov   r16, r12
2352
        and   r13, r12
2353
        add   r12, r14
2354
        mov   r18, r12
2355
        shl   15,  r12
2356
        and   r13, r12
2357
        add   r12, r14
2358
        shr   17,  r14
2359
        shr   17,  r16
2360
        add   r14, r16
2361
        shl   13,  r15
2362
        shr   2,   r18
2363
        add   r18, r15
2364
        add   r15, r16
2365
        mov   r16, r27
2366
        add   r8,  r6
2367
        shl   28,  r6
2368
        add   r6,  r27
2369
        mov   r26, r10
2370
        mov   r27, r11
2371
        jr    __return_r26_r31
2372
#endif /* __v850__ */
2373
#if defined(__v850e__) || defined(__v850ea__)
2374
        /*  (Ahi << 32 + Alo) * (Bhi << 32 + Blo) */
2375
        /*   r7           r6      r9         r8   */
2376
        mov  r8, r10
2377
        mulu r7, r8,  r0                /* Ahi * Blo */
2378
        mulu r6, r9,  r0                /* Alo * Bhi */
2379
        mulu r6, r10, r11               /* Alo * Blo */
2380
        add  r8, r11
2381
        add  r9, r11
2382
        jmp  [r31]
2383
 
2384
#endif /* defined(__v850e__)  || defined(__v850ea__) */
2385
        .size ___muldi3, . - ___muldi3
2386
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.