]>
Commit | Line | Data |
---|---|---|
ae180d84 JL |
1 | /* libgcc1 routines for NEC V850. |
2 | Copyright (C) 1996, 1997 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GNU CC. | |
5 | ||
6 | GNU CC 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 with other programs, and to distribute | |
14 | those programs without any restriction coming from the use of this | |
15 | file. (The General Public License restrictions do apply in other | |
16 | respects; for example, they cover modification of the file, and | |
17 | distribution when not linked into another program.) | |
18 | ||
19 | This file is distributed in the hope that it will be useful, but | |
20 | WITHOUT ANY WARRANTY; without even the implied warranty of | |
21 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
22 | General Public License for more details. | |
23 | ||
24 | You should have received a copy of the GNU General Public License | |
25 | along with this program; see the file COPYING. If not, write to | |
26 | the Free Software Foundation, 59 Temple Place - Suite 330, | |
27 | Boston, MA 02111-1307, USA. */ | |
28 | ||
29 | /* As a special exception, if you link this library with files | |
30 | compiled with GCC to produce an executable, this does not cause | |
31 | the resulting executable to be covered by the GNU General Public License. | |
32 | This exception does not however invalidate any other reasons why | |
33 | the executable file might be covered by the GNU General Public License. */ | |
34 | ||
35 | #ifdef L_mulsi3 | |
36 | .text | |
37 | .globl ___mulsi3 | |
38 | .type ___mulsi3,@function | |
39 | ||
40 | /* | |
41 | * In order to not deal with negative numbers (mulh is a signed multiply | |
42 | * and we want an unsigned multiply, code the multiplication as a series | |
43 | * of 7 bit multiplies). | |
44 | * | |
45 | * int __mulsi3 (unsigned a, unsigned b) | |
46 | * { | |
47 | * int i, j; | |
48 | * int ret = 0; | |
49 | * | |
50 | * for (i = 0; i < 32; i += 7) | |
51 | * { | |
52 | * short a_part = a & 0x7f; | |
53 | * unsigned b_tmp = b; | |
54 | * a >>= 7; | |
55 | * | |
56 | * for (j = 0; (i+j) < 32; j += 7) | |
57 | * { | |
58 | * short b_part = b_tmp & 0x7f; | |
59 | * ret += (((int)a_part) * ((int)b_part)) << (i+j); | |
60 | * b_tmp >>= 7; | |
61 | * } | |
62 | * } | |
63 | * | |
64 | * return ret; | |
65 | * } | |
66 | */ | |
67 | ||
68 | ___mulsi3: | |
69 | mov 0,r10 /* total */ | |
70 | mov 0,r14 /* i = 0, index for multiply a's part */ | |
71 | movea lo(31),r0,r16 /* upper bounds for loop */ | |
72 | .L5: | |
73 | mov r7,r13 /* b_tmp = b */ | |
74 | andi 0x7f,r6,r15 /* a_part = (a & 127) */ | |
75 | shr 7,r6 /* a >>= 7 */ | |
76 | mov r14,r12 /* i+j = i */ | |
77 | .L9: | |
78 | andi 0x7f,r13,r11 /* b_part = (b_tmp & 127) */ | |
79 | mulh r15,r11 /* ((int)a_part) * ((int)b_part) */ | |
80 | shr 7,r13 /* b_tmp >>= 7 */ | |
81 | shl r12,r11 /* (((int)a_part) * ((int)b_part)) << (i+j) */ | |
82 | add r11,r10 /* ret += (((int)a_part) * ((int)b_part)) << (i+j) */ | |
83 | add 7,r12 /* i+j += 7 */ | |
84 | cmp r16,r12 /* i+j < 32 */ | |
85 | ble .L9 | |
86 | ||
87 | add 7,r14 /* i += 7 */ | |
88 | cmp r16,r14 /* i < 32 */ | |
89 | ble .L5 | |
90 | ||
91 | jmp [r31] /* return */ | |
f122eb7a | 92 | .size ___mulsi3,.-___mulsi3 |
ae180d84 JL |
93 | #endif |
94 | ||
95 | #ifdef L_udivsi3 | |
f122eb7a | 96 | .text |
ae180d84 JL |
97 | .global ___udivsi3 |
98 | ___udivsi3: | |
99 | mov 1,r12 | |
100 | mov 0,r10 | |
101 | cmp r6,r7 | |
102 | bnl .L12 | |
103 | movhi hi(-2147483648),r0,r13 | |
104 | cmp r0,r7 | |
105 | blt .L12 | |
106 | .L4: | |
107 | shl 1,r7 | |
108 | shl 1,r12 | |
109 | cmp r6,r7 | |
110 | bnl .L12 | |
111 | cmp r0,r12 | |
112 | be .L8 | |
113 | mov r7,r5 | |
114 | and r13,r5 | |
115 | be .L4 | |
116 | br .L12 | |
117 | .L9: | |
118 | cmp r7,r6 | |
119 | bl .L10 | |
120 | sub r7,r6 | |
121 | or r12,r10 | |
122 | .L10: | |
123 | shr 1,r12 | |
124 | shr 1,r7 | |
125 | .L12: | |
126 | cmp r0,r12 | |
127 | bne .L9 | |
128 | .L8: | |
129 | jmp [r31] | |
f122eb7a | 130 | .size ___udivsi3,.-___udivsi3 |
ae180d84 JL |
131 | #endif |
132 | ||
133 | #ifdef L_divsi3 | |
134 | .text | |
135 | .globl ___divsi3 | |
136 | .type ___divsi3,@function | |
137 | ___divsi3: | |
138 | add -8,sp | |
139 | st.w r31,4[sp] | |
140 | st.w r22,0[sp] | |
141 | mov 1,r22 | |
142 | tst r7,r7 | |
143 | bp .L3 | |
144 | subr r0,r7 | |
145 | subr r0,r22 | |
146 | .L3: | |
147 | tst r6,r6 | |
148 | bp .L4 | |
149 | subr r0,r6 | |
150 | subr r0,r22 | |
151 | .L4: | |
152 | jarl ___udivsi3,r31 | |
153 | cmp r0,r22 | |
154 | bp .L7 | |
155 | subr r0,r10 | |
156 | .L7: | |
157 | ld.w 0[sp],r22 | |
158 | ld.w 4[sp],r31 | |
159 | add 8,sp | |
160 | jmp [r31] | |
f122eb7a | 161 | .size ___divsi3,.-___divsi3 |
ae180d84 JL |
162 | #endif |
163 | ||
164 | #ifdef L_umodsi3 | |
165 | .text | |
166 | .globl ___umodsi3 | |
167 | .type ___umodsi3,@function | |
168 | ___umodsi3: | |
169 | add -12,sp | |
170 | st.w r31,8[sp] | |
171 | st.w r7,4[sp] | |
172 | st.w r6,0[sp] | |
173 | jarl ___udivsi3,r31 | |
174 | ld.w 4[sp],r7 | |
175 | mov r10,r6 | |
176 | jarl ___mulsi3,r31 | |
177 | ld.w 0[sp],r6 | |
178 | subr r6,r10 | |
179 | ld.w 8[sp],r31 | |
180 | add 12,sp | |
181 | jmp [r31] | |
f122eb7a | 182 | .size ___umodsi3,.-___umodsi3 |
ae180d84 JL |
183 | #endif /* L_umodsi3 */ |
184 | ||
185 | #ifdef L_modsi3 | |
186 | .text | |
187 | .globl ___modsi3 | |
188 | .type ___modsi3,@function | |
189 | ___modsi3: | |
190 | add -12,sp | |
191 | st.w r31,8[sp] | |
192 | st.w r7,4[sp] | |
193 | st.w r6,0[sp] | |
194 | jarl ___divsi3,r31 | |
195 | ld.w 4[sp],r7 | |
196 | mov r10,r6 | |
197 | jarl ___mulsi3,r31 | |
198 | ld.w 0[sp],r6 | |
199 | subr r6,r10 | |
200 | ld.w 8[sp],r31 | |
201 | add 12,sp | |
202 | jmp [r31] | |
f122eb7a | 203 | .size ___modsi3,.-___modsi3 |
ae180d84 JL |
204 | #endif /* L_modsi3 */ |
205 | ||
206 | #ifdef L_save_2 | |
207 | .text | |
208 | .align 2 | |
209 | .globl __save_r2_r29 | |
210 | .type __save_r2_r29,@function | |
211 | /* Allocate space and save registers 2, 20 .. 29 on the stack */ | |
212 | /* Called via: jalr __save_r2_r29,r10 */ | |
213 | __save_r2_r29: | |
214 | mov ep,r1 | |
215 | addi -44,sp,sp | |
216 | mov sp,ep | |
217 | sst.w r29,0[ep] | |
218 | sst.w r28,4[ep] | |
219 | sst.w r27,8[ep] | |
220 | sst.w r26,12[ep] | |
221 | sst.w r25,16[ep] | |
222 | sst.w r24,20[ep] | |
223 | sst.w r23,24[ep] | |
224 | sst.w r22,28[ep] | |
225 | sst.w r21,32[ep] | |
226 | sst.w r20,36[ep] | |
227 | sst.w r2,40[ep] | |
228 | mov r1,ep | |
229 | jmp [r10] | |
230 | .size __save_r2_r29,.-__save_r2_r29 | |
231 | ||
232 | /* Restore saved registers, deallocate stack and return to the user */ | |
233 | /* Called via: jr __return_r2_r29 */ | |
234 | .align 2 | |
235 | .globl __return_r2_r29 | |
236 | .type __return_r2_r29,@function | |
237 | __return_r2_r29: | |
238 | mov ep,r1 | |
239 | mov sp,ep | |
240 | sld.w 0[ep],r29 | |
241 | sld.w 4[ep],r28 | |
242 | sld.w 8[ep],r27 | |
243 | sld.w 12[ep],r26 | |
244 | sld.w 16[ep],r25 | |
245 | sld.w 20[ep],r24 | |
246 | sld.w 24[ep],r23 | |
247 | sld.w 28[ep],r22 | |
248 | sld.w 32[ep],r21 | |
249 | sld.w 36[ep],r20 | |
250 | sld.w 40[ep],r2 | |
251 | addi 44,sp,sp | |
252 | mov r1,ep | |
253 | jmp [r31] | |
254 | .size __return_r2_r29,.-__return_r2_r29 | |
255 | #endif /* L_save_2 */ | |
256 | ||
257 | #ifdef L_save_20 | |
258 | .text | |
259 | .align 2 | |
260 | .globl __save_r20_r29 | |
261 | .type __save_r20_r29,@function | |
262 | /* Allocate space and save registers 20 .. 29 on the stack */ | |
263 | /* Called via: jalr __save_r20_r29,r10 */ | |
264 | __save_r20_r29: | |
265 | mov ep,r1 | |
266 | addi -40,sp,sp | |
267 | mov sp,ep | |
268 | sst.w r29,0[ep] | |
269 | sst.w r28,4[ep] | |
270 | sst.w r27,8[ep] | |
271 | sst.w r26,12[ep] | |
272 | sst.w r25,16[ep] | |
273 | sst.w r24,20[ep] | |
274 | sst.w r23,24[ep] | |
275 | sst.w r22,28[ep] | |
276 | sst.w r21,32[ep] | |
277 | sst.w r20,36[ep] | |
278 | mov r1,ep | |
279 | jmp [r10] | |
280 | .size __save_r20_r29,.-__save_r20_r29 | |
281 | ||
282 | /* Restore saved registers, deallocate stack and return to the user */ | |
283 | /* Called via: jr __return_r20_r29 */ | |
284 | .align 2 | |
285 | .globl __return_r20_r29 | |
286 | .type __return_r20_r29,@function | |
287 | __return_r20_r29: | |
288 | mov ep,r1 | |
289 | mov sp,ep | |
290 | sld.w 0[ep],r29 | |
291 | sld.w 4[ep],r28 | |
292 | sld.w 8[ep],r27 | |
293 | sld.w 12[ep],r26 | |
294 | sld.w 16[ep],r25 | |
295 | sld.w 20[ep],r24 | |
296 | sld.w 24[ep],r23 | |
297 | sld.w 28[ep],r22 | |
298 | sld.w 32[ep],r21 | |
299 | sld.w 36[ep],r20 | |
300 | addi 40,sp,sp | |
301 | mov r1,ep | |
302 | jmp [r31] | |
303 | .size __return_r20_r29,.-__return_r20_r29 | |
304 | #endif /* L_save_20 */ | |
305 | ||
306 | #ifdef L_save_21 | |
307 | .text | |
308 | .align 2 | |
309 | .globl __save_r21_r29 | |
310 | .type __save_r21_r29,@function | |
311 | /* Allocate space and save registers 21 .. 29 on the stack */ | |
312 | /* Called via: jalr __save_r21_r29,r10 */ | |
313 | __save_r21_r29: | |
314 | mov ep,r1 | |
315 | addi -36,sp,sp | |
316 | mov sp,ep | |
317 | sst.w r29,0[ep] | |
318 | sst.w r28,4[ep] | |
319 | sst.w r27,8[ep] | |
320 | sst.w r26,12[ep] | |
321 | sst.w r25,16[ep] | |
322 | sst.w r24,20[ep] | |
323 | sst.w r23,24[ep] | |
324 | sst.w r22,28[ep] | |
325 | sst.w r21,32[ep] | |
326 | mov r1,ep | |
327 | jmp [r10] | |
328 | .size __save_r21_r29,.-__save_r21_r29 | |
329 | ||
330 | /* Restore saved registers, deallocate stack and return to the user */ | |
331 | /* Called via: jr __return_r21_r29 */ | |
332 | .align 2 | |
333 | .globl __return_r21_r29 | |
334 | .type __return_r21_r29,@function | |
335 | __return_r21_r29: | |
336 | mov ep,r1 | |
337 | mov sp,ep | |
338 | sld.w 0[ep],r29 | |
339 | sld.w 4[ep],r28 | |
340 | sld.w 8[ep],r27 | |
341 | sld.w 12[ep],r26 | |
342 | sld.w 16[ep],r25 | |
343 | sld.w 20[ep],r24 | |
344 | sld.w 24[ep],r23 | |
345 | sld.w 28[ep],r22 | |
346 | sld.w 32[ep],r21 | |
347 | addi 36,sp,sp | |
348 | mov r1,ep | |
349 | jmp [r31] | |
350 | .size __return_r21_r29,.-__return_r21_r29 | |
351 | #endif /* L_save_21 */ | |
352 | ||
353 | #ifdef L_save_22 | |
354 | .text | |
355 | .align 2 | |
356 | .globl __save_r22_r29 | |
357 | .type __save_r22_r29,@function | |
358 | /* Allocate space and save registers 22 .. 29 on the stack */ | |
359 | /* Called via: jalr __save_r22_r29,r10 */ | |
360 | __save_r22_r29: | |
361 | mov ep,r1 | |
362 | addi -32,sp,sp | |
363 | mov sp,ep | |
364 | sst.w r29,0[ep] | |
365 | sst.w r28,4[ep] | |
366 | sst.w r27,8[ep] | |
367 | sst.w r26,12[ep] | |
368 | sst.w r25,16[ep] | |
369 | sst.w r24,20[ep] | |
370 | sst.w r23,24[ep] | |
371 | sst.w r22,28[ep] | |
372 | mov r1,ep | |
373 | jmp [r10] | |
374 | .size __save_r22_r29,.-__save_r22_r29 | |
375 | ||
376 | /* Restore saved registers, deallocate stack and return to the user */ | |
377 | /* Called via: jr __return_r22_r29 */ | |
378 | .align 2 | |
379 | .globl __return_r22_r29 | |
380 | .type __return_r22_r29,@function | |
381 | __return_r22_r29: | |
382 | mov ep,r1 | |
383 | mov sp,ep | |
384 | sld.w 0[ep],r29 | |
385 | sld.w 4[ep],r28 | |
386 | sld.w 8[ep],r27 | |
387 | sld.w 12[ep],r26 | |
388 | sld.w 16[ep],r25 | |
389 | sld.w 20[ep],r24 | |
390 | sld.w 24[ep],r23 | |
391 | sld.w 28[ep],r22 | |
392 | addi 32,sp,sp | |
393 | mov r1,ep | |
394 | jmp [r31] | |
395 | .size __return_r22_r29,.-__return_r22_r29 | |
396 | #endif /* L_save_22 */ | |
397 | ||
398 | #ifdef L_save_23 | |
399 | .text | |
400 | .align 2 | |
401 | .globl __save_r23_r29 | |
402 | .type __save_r23_r29,@function | |
403 | /* Allocate space and save registers 23 .. 29 on the stack */ | |
404 | /* Called via: jalr __save_r23_r29,r10 */ | |
405 | __save_r23_r29: | |
406 | mov ep,r1 | |
407 | addi -28,sp,sp | |
408 | mov sp,ep | |
409 | sst.w r29,0[ep] | |
410 | sst.w r28,4[ep] | |
411 | sst.w r27,8[ep] | |
412 | sst.w r26,12[ep] | |
413 | sst.w r25,16[ep] | |
414 | sst.w r24,20[ep] | |
415 | sst.w r23,24[ep] | |
416 | mov r1,ep | |
417 | jmp [r10] | |
418 | .size __save_r23_r29,.-__save_r23_r29 | |
419 | ||
420 | /* Restore saved registers, deallocate stack and return to the user */ | |
421 | /* Called via: jr __return_r23_r29 */ | |
422 | .align 2 | |
423 | .globl __return_r23_r29 | |
424 | .type __return_r23_r29,@function | |
425 | __return_r23_r29: | |
426 | mov ep,r1 | |
427 | mov sp,ep | |
428 | sld.w 0[ep],r29 | |
429 | sld.w 4[ep],r28 | |
430 | sld.w 8[ep],r27 | |
431 | sld.w 12[ep],r26 | |
432 | sld.w 16[ep],r25 | |
433 | sld.w 20[ep],r24 | |
434 | sld.w 24[ep],r23 | |
435 | addi 28,sp,sp | |
436 | mov r1,ep | |
437 | jmp [r31] | |
438 | .size __return_r23_r29,.-__return_r23_r29 | |
439 | #endif /* L_save_23 */ | |
440 | ||
441 | #ifdef L_save_24 | |
442 | .text | |
443 | .align 2 | |
444 | .globl __save_r24_r29 | |
445 | .type __save_r24_r29,@function | |
446 | /* Allocate space and save registers 24 .. 29 on the stack */ | |
447 | /* Called via: jalr __save_r24_r29,r10 */ | |
448 | __save_r24_r29: | |
449 | mov ep,r1 | |
450 | addi -24,sp,sp | |
451 | mov sp,ep | |
452 | sst.w r29,0[ep] | |
453 | sst.w r28,4[ep] | |
454 | sst.w r27,8[ep] | |
455 | sst.w r26,12[ep] | |
456 | sst.w r25,16[ep] | |
457 | sst.w r24,20[ep] | |
458 | mov r1,ep | |
459 | jmp [r10] | |
460 | .size __save_r24_r29,.-__save_r24_r29 | |
461 | ||
462 | /* Restore saved registers, deallocate stack and return to the user */ | |
463 | /* Called via: jr __return_r24_r29 */ | |
464 | .align 2 | |
465 | .globl __return_r24_r29 | |
466 | .type __return_r24_r29,@function | |
467 | __return_r24_r29: | |
468 | mov ep,r1 | |
469 | mov sp,ep | |
470 | sld.w 0[ep],r29 | |
471 | sld.w 4[ep],r28 | |
472 | sld.w 8[ep],r27 | |
473 | sld.w 12[ep],r26 | |
474 | sld.w 16[ep],r25 | |
475 | sld.w 20[ep],r24 | |
476 | addi 24,sp,sp | |
477 | mov r1,ep | |
478 | jmp [r31] | |
479 | .size __return_r24_r29,.-__return_r24_r29 | |
480 | #endif /* L_save_24 */ | |
481 | ||
482 | #ifdef L_save_25 | |
483 | .text | |
484 | .align 2 | |
485 | .globl __save_r25_r29 | |
486 | .type __save_r25_r29,@function | |
487 | /* Allocate space and save registers 25 .. 29 on the stack */ | |
488 | /* Called via: jalr __save_r25_r29,r10 */ | |
489 | __save_r25_r29: | |
490 | mov ep,r1 | |
491 | addi -20,sp,sp | |
492 | mov sp,ep | |
493 | sst.w r29,0[ep] | |
494 | sst.w r28,4[ep] | |
495 | sst.w r27,8[ep] | |
496 | sst.w r26,12[ep] | |
497 | sst.w r25,16[ep] | |
498 | mov r1,ep | |
499 | jmp [r10] | |
500 | .size __save_r25_r29,.-__save_r25_r29 | |
501 | ||
502 | /* Restore saved registers, deallocate stack and return to the user */ | |
503 | /* Called via: jr __return_r25_r29 */ | |
504 | .align 2 | |
505 | .globl __return_r25_r29 | |
506 | .type __return_r25_r29,@function | |
507 | __return_r25_r29: | |
508 | mov ep,r1 | |
509 | mov sp,ep | |
510 | sld.w 0[ep],r29 | |
511 | sld.w 4[ep],r28 | |
512 | sld.w 8[ep],r27 | |
513 | sld.w 12[ep],r26 | |
514 | sld.w 16[ep],r25 | |
515 | addi 20,sp,sp | |
516 | mov r1,ep | |
517 | jmp [r31] | |
518 | .size __return_r25_r29,.-__return_r25_r29 | |
519 | #endif /* L_save_25 */ | |
520 | ||
521 | #ifdef L_save_26 | |
522 | .text | |
523 | .align 2 | |
524 | .globl __save_r26_r29 | |
525 | .type __save_r26_r29,@function | |
526 | /* Allocate space and save registers 26 .. 29 on the stack */ | |
527 | /* Called via: jalr __save_r26_r29,r10 */ | |
528 | __save_r26_r29: | |
529 | mov ep,r1 | |
530 | add -16,sp | |
531 | mov sp,ep | |
532 | sst.w r29,0[ep] | |
533 | sst.w r28,4[ep] | |
534 | sst.w r27,8[ep] | |
535 | sst.w r26,12[ep] | |
536 | mov r1,ep | |
537 | jmp [r10] | |
538 | .size __save_r26_r29,.-__save_r26_r29 | |
539 | ||
540 | /* Restore saved registers, deallocate stack and return to the user */ | |
541 | /* Called via: jr __return_r26_r29 */ | |
542 | .align 2 | |
543 | .globl __return_r26_r29 | |
544 | .type __return_r26_r29,@function | |
545 | __return_r26_r29: | |
546 | mov ep,r1 | |
547 | mov sp,ep | |
548 | sld.w 0[ep],r29 | |
549 | sld.w 4[ep],r28 | |
550 | sld.w 8[ep],r27 | |
551 | sld.w 12[ep],r26 | |
552 | addi 16,sp,sp | |
553 | mov r1,ep | |
554 | jmp [r31] | |
555 | .size __return_r26_r29,.-__return_r26_r29 | |
556 | #endif /* L_save_26 */ | |
557 | ||
558 | #ifdef L_save_27 | |
559 | .text | |
560 | .align 2 | |
561 | .globl __save_r27_r29 | |
562 | .type __save_r27_r29,@function | |
563 | /* Allocate space and save registers 27 .. 29 on the stack */ | |
564 | /* Called via: jalr __save_r27_r29,r10 */ | |
565 | __save_r27_r29: | |
566 | add -12,sp | |
567 | st.w r29,0[sp] | |
568 | st.w r28,4[sp] | |
569 | st.w r27,8[sp] | |
570 | jmp [r10] | |
571 | .size __save_r27_r29,.-__save_r27_r29 | |
572 | ||
573 | /* Restore saved registers, deallocate stack and return to the user */ | |
574 | /* Called via: jr __return_r27_r29 */ | |
575 | .align 2 | |
576 | .globl __return_r27_r29 | |
577 | .type __return_r27_r29,@function | |
578 | __return_r27_r29: | |
579 | ld.w 0[sp],r29 | |
580 | ld.w 4[sp],r28 | |
581 | ld.w 8[sp],r27 | |
582 | add 12,sp | |
583 | jmp [r31] | |
584 | .size __return_r27_r29,.-__return_r27_r29 | |
585 | #endif /* L_save_27 */ | |
586 | ||
587 | #ifdef L_save_28 | |
588 | .text | |
589 | .align 2 | |
590 | .globl __save_r28_r29 | |
591 | .type __save_r28_r29,@function | |
592 | /* Allocate space and save registers 28,29 on the stack */ | |
593 | /* Called via: jalr __save_r28_r29,r10 */ | |
594 | __save_r28_r29: | |
595 | add -8,sp | |
596 | st.w r29,0[sp] | |
597 | st.w r28,4[sp] | |
598 | jmp [r10] | |
599 | .size __save_r28_r29,.-__save_r28_r29 | |
600 | ||
601 | /* Restore saved registers, deallocate stack and return to the user */ | |
602 | /* Called via: jr __return_r28_r29 */ | |
603 | .align 2 | |
604 | .globl __return_r28_r29 | |
605 | .type __return_r28_r29,@function | |
606 | __return_r28_r29: | |
607 | ld.w 0[sp],r29 | |
608 | ld.w 4[sp],r28 | |
609 | add 8,sp | |
610 | jmp [r31] | |
611 | .size __return_r28_r29,.-__return_r28_r29 | |
612 | #endif /* L_save_28 */ | |
613 | ||
614 | #ifdef L_save_29 | |
615 | .text | |
616 | .align 2 | |
617 | .globl __save_r29 | |
618 | .type __save_r29,@function | |
619 | /* Allocate space and save register 29 on the stack */ | |
620 | /* Called via: jalr __save_r29,r10 */ | |
621 | __save_r29: | |
622 | add -4,sp | |
623 | st.w r29,0[sp] | |
624 | jmp [r10] | |
625 | .size __save_r29,.-__save_r29 | |
626 | ||
627 | /* Restore saved register 29, deallocate stack and return to the user */ | |
628 | /* Called via: jr __return_r29 */ | |
629 | .align 2 | |
630 | .globl __return_r29 | |
631 | .type __return_r29,@function | |
632 | __return_r29: | |
633 | ld.w 0[sp],r29 | |
634 | add 4,sp | |
635 | jmp [r31] | |
636 | .size __return_r29,.-__return_r29 | |
637 | #endif /* L_save_28 */ | |
638 | ||
639 | #ifdef L_save_2c | |
640 | .text | |
641 | .align 2 | |
642 | .globl __save_r2_r31 | |
643 | .type __save_r2_r31,@function | |
644 | /* Allocate space and save registers 20 .. 29, 31 on the stack */ | |
645 | /* Also allocate space for the argument save area */ | |
646 | /* Called via: jalr __save_r2_r31,r10 */ | |
647 | __save_r2_r31: | |
648 | mov ep,r1 | |
649 | addi -64,sp,sp | |
650 | mov sp,ep | |
651 | sst.w r29,16[ep] | |
652 | sst.w r28,20[ep] | |
653 | sst.w r27,24[ep] | |
654 | sst.w r26,28[ep] | |
655 | sst.w r25,32[ep] | |
656 | sst.w r24,36[ep] | |
657 | sst.w r23,40[ep] | |
658 | sst.w r22,44[ep] | |
659 | sst.w r21,48[ep] | |
660 | sst.w r20,52[ep] | |
661 | sst.w r2,56[ep] | |
662 | sst.w r31,60[ep] | |
663 | mov r1,ep | |
664 | jmp [r10] | |
665 | .size __save_r2_r31,.-__save_r2_r31 | |
666 | ||
667 | /* Restore saved registers, deallocate stack and return to the user */ | |
668 | /* Called via: jr __return_r20_r31 */ | |
669 | .align 2 | |
670 | .globl __return_r2_r31 | |
671 | .type __return_r2_r31,@function | |
672 | __return_r2_r31: | |
673 | mov ep,r1 | |
674 | mov sp,ep | |
675 | sld.w 16[ep],r29 | |
676 | sld.w 20[ep],r28 | |
677 | sld.w 24[ep],r27 | |
678 | sld.w 28[ep],r26 | |
679 | sld.w 32[ep],r25 | |
680 | sld.w 36[ep],r24 | |
681 | sld.w 40[ep],r23 | |
682 | sld.w 44[ep],r22 | |
683 | sld.w 48[ep],r21 | |
684 | sld.w 52[ep],r20 | |
685 | sld.w 56[ep],r2 | |
686 | sld.w 60[ep],r31 | |
687 | addi 64,sp,sp | |
688 | mov r1,ep | |
689 | jmp [r31] | |
690 | .size __return_r2_r31,.-__return_r2_r31 | |
691 | #endif /* L_save_2c */ | |
692 | ||
693 | #ifdef L_save_20c | |
694 | .text | |
695 | .align 2 | |
696 | .globl __save_r20_r31 | |
697 | .type __save_r20_r31,@function | |
698 | /* Allocate space and save registers 20 .. 29, 31 on the stack */ | |
699 | /* Also allocate space for the argument save area */ | |
700 | /* Called via: jalr __save_r20_r31,r10 */ | |
701 | __save_r20_r31: | |
702 | mov ep,r1 | |
703 | addi -60,sp,sp | |
704 | mov sp,ep | |
705 | sst.w r29,16[ep] | |
706 | sst.w r28,20[ep] | |
707 | sst.w r27,24[ep] | |
708 | sst.w r26,28[ep] | |
709 | sst.w r25,32[ep] | |
710 | sst.w r24,36[ep] | |
711 | sst.w r23,40[ep] | |
712 | sst.w r22,44[ep] | |
713 | sst.w r21,48[ep] | |
714 | sst.w r20,52[ep] | |
715 | sst.w r31,56[ep] | |
716 | mov r1,ep | |
717 | jmp [r10] | |
718 | .size __save_r20_r31,.-__save_r20_r31 | |
719 | ||
720 | /* Restore saved registers, deallocate stack and return to the user */ | |
721 | /* Called via: jr __return_r20_r31 */ | |
722 | .align 2 | |
723 | .globl __return_r20_r31 | |
724 | .type __return_r20_r31,@function | |
725 | __return_r20_r31: | |
726 | mov ep,r1 | |
727 | mov sp,ep | |
728 | sld.w 16[ep],r29 | |
729 | sld.w 20[ep],r28 | |
730 | sld.w 24[ep],r27 | |
731 | sld.w 28[ep],r26 | |
732 | sld.w 32[ep],r25 | |
733 | sld.w 36[ep],r24 | |
734 | sld.w 40[ep],r23 | |
735 | sld.w 44[ep],r22 | |
736 | sld.w 48[ep],r21 | |
737 | sld.w 52[ep],r20 | |
738 | sld.w 56[ep],r31 | |
739 | addi 60,sp,sp | |
740 | mov r1,ep | |
741 | jmp [r31] | |
742 | .size __return_r20_r31,.-__return_r20_r31 | |
743 | #endif /* L_save_20c */ | |
744 | ||
745 | #ifdef L_save_21c | |
746 | .text | |
747 | .align 2 | |
748 | .globl __save_r21_r31 | |
749 | .type __save_r21_r31,@function | |
750 | /* Allocate space and save registers 21 .. 29, 31 on the stack */ | |
751 | /* Also allocate space for the argument save area */ | |
752 | /* Called via: jalr __save_r21_r31,r10 */ | |
753 | __save_r21_r31: | |
754 | mov ep,r1 | |
755 | addi -56,sp,sp | |
756 | mov sp,ep | |
757 | sst.w r29,16[ep] | |
758 | sst.w r28,20[ep] | |
759 | sst.w r27,24[ep] | |
760 | sst.w r26,28[ep] | |
761 | sst.w r25,32[ep] | |
762 | sst.w r24,36[ep] | |
763 | sst.w r23,40[ep] | |
764 | sst.w r22,44[ep] | |
765 | sst.w r21,48[ep] | |
766 | sst.w r31,52[ep] | |
767 | mov r1,ep | |
768 | jmp [r10] | |
769 | .size __save_r21_r31,.-__save_r21_r31 | |
770 | ||
771 | /* Restore saved registers, deallocate stack and return to the user */ | |
772 | /* Called via: jr __return_r21_r31 */ | |
773 | .align 2 | |
774 | .globl __return_r21_r31 | |
775 | .type __return_r21_r31,@function | |
776 | __return_r21_r31: | |
777 | mov ep,r1 | |
778 | mov sp,ep | |
779 | sld.w 16[ep],r29 | |
780 | sld.w 20[ep],r28 | |
781 | sld.w 24[ep],r27 | |
782 | sld.w 28[ep],r26 | |
783 | sld.w 32[ep],r25 | |
784 | sld.w 36[ep],r24 | |
785 | sld.w 40[ep],r23 | |
786 | sld.w 44[ep],r22 | |
787 | sld.w 48[ep],r21 | |
788 | sld.w 52[ep],r31 | |
789 | addi 56,sp,sp | |
790 | mov r1,ep | |
791 | jmp [r31] | |
792 | .size __return_r21_r31,.-__return_r21_r31 | |
793 | #endif /* L_save_21c */ | |
794 | ||
795 | #ifdef L_save_22c | |
796 | .text | |
797 | .align 2 | |
798 | .globl __save_r22_r31 | |
799 | .type __save_r22_r31,@function | |
800 | /* Allocate space and save registers 22 .. 29, 31 on the stack */ | |
801 | /* Also allocate space for the argument save area */ | |
802 | /* Called via: jalr __save_r22_r31,r10 */ | |
803 | __save_r22_r31: | |
804 | mov ep,r1 | |
805 | addi -52,sp,sp | |
806 | mov sp,ep | |
807 | sst.w r29,16[ep] | |
808 | sst.w r28,20[ep] | |
809 | sst.w r27,24[ep] | |
810 | sst.w r26,28[ep] | |
811 | sst.w r25,32[ep] | |
812 | sst.w r24,36[ep] | |
813 | sst.w r23,40[ep] | |
814 | sst.w r22,44[ep] | |
815 | sst.w r31,48[ep] | |
816 | mov r1,ep | |
817 | jmp [r10] | |
818 | .size __save_r22_r31,.-__save_r22_r31 | |
819 | ||
820 | /* Restore saved registers, deallocate stack and return to the user */ | |
821 | /* Called via: jr __return_r22_r31 */ | |
822 | .align 2 | |
823 | .globl __return_r22_r31 | |
824 | .type __return_r22_r31,@function | |
825 | __return_r22_r31: | |
826 | mov ep,r1 | |
827 | mov sp,ep | |
828 | sld.w 16[ep],r29 | |
829 | sld.w 20[ep],r28 | |
830 | sld.w 24[ep],r27 | |
831 | sld.w 28[ep],r26 | |
832 | sld.w 32[ep],r25 | |
833 | sld.w 36[ep],r24 | |
834 | sld.w 40[ep],r23 | |
835 | sld.w 44[ep],r22 | |
836 | sld.w 48[ep],r31 | |
837 | addi 52,sp,sp | |
838 | mov r1,ep | |
839 | jmp [r31] | |
840 | .size __return_r22_r31,.-__return_r22_r31 | |
841 | #endif /* L_save_22c */ | |
842 | ||
843 | #ifdef L_save_23c | |
844 | .text | |
845 | .align 2 | |
846 | .globl __save_r23_r31 | |
847 | .type __save_r23_r31,@function | |
848 | /* Allocate space and save registers 23 .. 29, 31 on the stack */ | |
849 | /* Also allocate space for the argument save area */ | |
850 | /* Called via: jalr __save_r23_r31,r10 */ | |
851 | __save_r23_r31: | |
852 | mov ep,r1 | |
853 | addi -48,sp,sp | |
854 | mov sp,ep | |
855 | sst.w r29,16[ep] | |
856 | sst.w r28,20[ep] | |
857 | sst.w r27,24[ep] | |
858 | sst.w r26,28[ep] | |
859 | sst.w r25,32[ep] | |
860 | sst.w r24,36[ep] | |
861 | sst.w r23,40[ep] | |
862 | sst.w r31,44[ep] | |
863 | mov r1,ep | |
864 | jmp [r10] | |
865 | .size __save_r23_r31,.-__save_r23_r31 | |
866 | ||
867 | /* Restore saved registers, deallocate stack and return to the user */ | |
868 | /* Called via: jr __return_r23_r31 */ | |
869 | .align 2 | |
870 | .globl __return_r23_r31 | |
871 | .type __return_r23_r31,@function | |
872 | __return_r23_r31: | |
873 | mov ep,r1 | |
874 | mov sp,ep | |
875 | sld.w 16[ep],r29 | |
876 | sld.w 20[ep],r28 | |
877 | sld.w 24[ep],r27 | |
878 | sld.w 28[ep],r26 | |
879 | sld.w 32[ep],r25 | |
880 | sld.w 36[ep],r24 | |
881 | sld.w 40[ep],r23 | |
882 | sld.w 44[ep],r31 | |
883 | addi 48,sp,sp | |
884 | mov r1,ep | |
885 | jmp [r31] | |
886 | .size __return_r23_r31,.-__return_r23_r31 | |
887 | #endif /* L_save_23c */ | |
888 | ||
889 | #ifdef L_save_24c | |
890 | .text | |
891 | .align 2 | |
892 | .globl __save_r24_r31 | |
893 | .type __save_r24_r31,@function | |
894 | /* Allocate space and save registers 24 .. 29, 31 on the stack */ | |
895 | /* Also allocate space for the argument save area */ | |
896 | /* Called via: jalr __save_r24_r31,r10 */ | |
897 | __save_r24_r31: | |
898 | mov ep,r1 | |
899 | addi -44,sp,sp | |
900 | mov sp,ep | |
901 | sst.w r29,16[ep] | |
902 | sst.w r28,20[ep] | |
903 | sst.w r27,24[ep] | |
904 | sst.w r26,28[ep] | |
905 | sst.w r25,32[ep] | |
906 | sst.w r24,36[ep] | |
907 | sst.w r31,40[ep] | |
908 | mov r1,ep | |
909 | jmp [r10] | |
910 | .size __save_r24_r31,.-__save_r24_r31 | |
911 | ||
912 | /* Restore saved registers, deallocate stack and return to the user */ | |
913 | /* Called via: jr __return_r24_r31 */ | |
914 | .align 2 | |
915 | .globl __return_r24_r31 | |
916 | .type __return_r24_r31,@function | |
917 | __return_r24_r31: | |
918 | mov ep,r1 | |
919 | mov sp,ep | |
920 | sld.w 16[ep],r29 | |
921 | sld.w 20[ep],r28 | |
922 | sld.w 24[ep],r27 | |
923 | sld.w 28[ep],r26 | |
924 | sld.w 32[ep],r25 | |
925 | sld.w 36[ep],r24 | |
926 | sld.w 40[ep],r31 | |
927 | addi 44,sp,sp | |
928 | mov r1,ep | |
929 | jmp [r31] | |
930 | .size __return_r24_r31,.-__return_r24_r31 | |
931 | #endif /* L_save_24c */ | |
932 | ||
933 | #ifdef L_save_25c | |
934 | .text | |
935 | .align 2 | |
936 | .globl __save_r25_r31 | |
937 | .type __save_r25_r31,@function | |
938 | /* Allocate space and save registers 25 .. 29, 31 on the stack */ | |
939 | /* Also allocate space for the argument save area */ | |
940 | /* Called via: jalr __save_r25_r31,r10 */ | |
941 | __save_r25_r31: | |
942 | mov ep,r1 | |
943 | addi -40,sp,sp | |
944 | mov sp,ep | |
945 | sst.w r29,16[ep] | |
946 | sst.w r28,20[ep] | |
947 | sst.w r27,24[ep] | |
948 | sst.w r26,28[ep] | |
949 | sst.w r25,32[ep] | |
950 | sst.w r31,36[ep] | |
951 | mov r1,ep | |
952 | jmp [r10] | |
953 | .size __save_r25_r31,.-__save_r25_r31 | |
954 | ||
955 | /* Restore saved registers, deallocate stack and return to the user */ | |
956 | /* Called via: jr __return_r25_r31 */ | |
957 | .align 2 | |
958 | .globl __return_r25_r31 | |
959 | .type __return_r25_r31,@function | |
960 | __return_r25_r31: | |
961 | mov ep,r1 | |
962 | mov sp,ep | |
963 | sld.w 16[ep],r29 | |
964 | sld.w 20[ep],r28 | |
965 | sld.w 24[ep],r27 | |
966 | sld.w 28[ep],r26 | |
967 | sld.w 32[ep],r25 | |
968 | sld.w 36[ep],r31 | |
969 | addi 40,sp,sp | |
970 | mov r1,ep | |
971 | jmp [r31] | |
972 | .size __return_r25_r31,.-__return_r25_r31 | |
973 | #endif /* L_save_25c */ | |
974 | ||
975 | #ifdef L_save_26c | |
976 | .text | |
977 | .align 2 | |
978 | .globl __save_r26_r31 | |
979 | .type __save_r26_r31,@function | |
980 | /* Allocate space and save registers 26 .. 29, 31 on the stack */ | |
981 | /* Also allocate space for the argument save area */ | |
982 | /* Called via: jalr __save_r26_r31,r10 */ | |
983 | __save_r26_r31: | |
984 | mov ep,r1 | |
985 | addi -36,sp,sp | |
986 | mov sp,ep | |
987 | sst.w r29,16[ep] | |
988 | sst.w r28,20[ep] | |
989 | sst.w r27,24[ep] | |
990 | sst.w r26,28[ep] | |
991 | sst.w r31,32[ep] | |
992 | mov r1,ep | |
993 | jmp [r10] | |
994 | .size __save_r26_r31,.-__save_r26_r31 | |
995 | ||
996 | /* Restore saved registers, deallocate stack and return to the user */ | |
997 | /* Called via: jr __return_r26_r31 */ | |
998 | .align 2 | |
999 | .globl __return_r26_r31 | |
1000 | .type __return_r26_r31,@function | |
1001 | __return_r26_r31: | |
1002 | mov ep,r1 | |
1003 | mov sp,ep | |
1004 | sld.w 16[ep],r29 | |
1005 | sld.w 20[ep],r28 | |
1006 | sld.w 24[ep],r27 | |
1007 | sld.w 28[ep],r26 | |
1008 | sld.w 32[ep],r31 | |
1009 | addi 36,sp,sp | |
1010 | mov r1,ep | |
1011 | jmp [r31] | |
1012 | .size __return_r26_r31,.-__return_r26_r31 | |
1013 | #endif /* L_save_26c */ | |
1014 | ||
1015 | #ifdef L_save_27c | |
1016 | .text | |
1017 | .align 2 | |
1018 | .globl __save_r27_r31 | |
1019 | .type __save_r27_r31,@function | |
1020 | /* Allocate space and save registers 27 .. 29, 31 on the stack */ | |
1021 | /* Also allocate space for the argument save area */ | |
1022 | /* Called via: jalr __save_r27_r31,r10 */ | |
1023 | __save_r27_r31: | |
1024 | mov ep,r1 | |
1025 | addi -32,sp,sp | |
1026 | mov sp,ep | |
1027 | sst.w r29,16[ep] | |
1028 | sst.w r28,20[ep] | |
1029 | sst.w r27,24[ep] | |
1030 | sst.w r31,28[ep] | |
1031 | mov r1,ep | |
1032 | jmp [r10] | |
1033 | .size __save_r27_r31,.-__save_r27_r31 | |
1034 | ||
1035 | /* Restore saved registers, deallocate stack and return to the user */ | |
1036 | /* Called via: jr __return_r27_r31 */ | |
1037 | .align 2 | |
1038 | .globl __return_r27_r31 | |
1039 | .type __return_r27_r31,@function | |
1040 | __return_r27_r31: | |
1041 | mov ep,r1 | |
1042 | mov sp,ep | |
1043 | sld.w 16[ep],r29 | |
1044 | sld.w 20[ep],r28 | |
1045 | sld.w 24[ep],r27 | |
1046 | sld.w 28[ep],r31 | |
1047 | addi 32,sp,sp | |
1048 | mov r1,ep | |
1049 | jmp [r31] | |
1050 | .size __return_r27_r31,.-__return_r27_r31 | |
1051 | #endif /* L_save_27c */ | |
1052 | ||
1053 | #ifdef L_save_28c | |
1054 | .text | |
1055 | .align 2 | |
1056 | .globl __save_r28_r31 | |
1057 | .type __save_r28_r31,@function | |
1058 | /* Allocate space and save registers 28 .. 29, 31 on the stack */ | |
1059 | /* Also allocate space for the argument save area */ | |
1060 | /* Called via: jalr __save_r28_r31,r10 */ | |
1061 | __save_r28_r31: | |
1062 | addi -28,sp,sp | |
1063 | st.w r29,16[sp] | |
1064 | st.w r28,20[sp] | |
1065 | st.w r31,24[sp] | |
1066 | jmp [r10] | |
1067 | .size __save_r28_r31,.-__save_r28_r31 | |
1068 | ||
1069 | /* Restore saved registers, deallocate stack and return to the user */ | |
1070 | /* Called via: jr __return_r28_r31 */ | |
1071 | .align 2 | |
1072 | .globl __return_r28_r31 | |
1073 | .type __return_r28_r31,@function | |
1074 | __return_r28_r31: | |
1075 | ld.w 16[sp],r29 | |
1076 | ld.w 20[sp],r28 | |
1077 | ld.w 24[sp],r31 | |
1078 | addi 28,sp,sp | |
1079 | jmp [r31] | |
1080 | .size __return_r28_r31,.-__return_r28_r31 | |
1081 | #endif /* L_save_28c */ | |
1082 | ||
1083 | #ifdef L_save_29c | |
1084 | .text | |
1085 | .align 2 | |
1086 | .globl __save_r29_r31 | |
1087 | .type __save_r29_r31,@function | |
1088 | /* Allocate space and save registers 29 & 31 on the stack */ | |
1089 | /* Also allocate space for the argument save area */ | |
1090 | /* Called via: jalr __save_r29_r31,r10 */ | |
1091 | __save_r29_r31: | |
1092 | addi -24,sp,sp | |
1093 | st.w r29,16[sp] | |
1094 | st.w r31,20[sp] | |
1095 | jmp [r10] | |
1096 | .size __save_r29_r31,.-__save_r29_r31 | |
1097 | ||
1098 | /* Restore saved registers, deallocate stack and return to the user */ | |
1099 | /* Called via: jr __return_r29_r31 */ | |
1100 | .align 2 | |
1101 | .globl __return_r29_r31 | |
1102 | .type __return_r29_r31,@function | |
1103 | __return_r29_r31: | |
1104 | ld.w 16[sp],r29 | |
1105 | ld.w 20[sp],r31 | |
1106 | addi 24,sp,sp | |
1107 | jmp [r31] | |
1108 | .size __return_r29_r31,.-__return_r29_r31 | |
1109 | #endif /* L_save_29c */ | |
1110 | ||
1111 | #ifdef L_save_31c | |
1112 | .text | |
1113 | .align 2 | |
1114 | .globl __save_r31 | |
1115 | .type __save_r31,@function | |
1116 | /* Allocate space and save register 31 on the stack */ | |
1117 | /* Also allocate space for the argument save area */ | |
1118 | /* Called via: jalr __save_r29_r31,r10 */ | |
1119 | __save_r31: | |
1120 | addi -20,sp,sp | |
1121 | st.w r31,16[sp] | |
1122 | jmp [r10] | |
1123 | .size __save_r31,.-__save_r31 | |
1124 | ||
1125 | /* Restore saved registers, deallocate stack and return to the user */ | |
1126 | /* Called via: jr __return_r31 */ | |
1127 | .align 2 | |
1128 | .globl __return_r31 | |
1129 | .type __return_r31,@function | |
1130 | __return_r31: | |
1131 | ld.w 16[sp],r31 | |
1132 | addi 20,sp,sp | |
1133 | jmp [r31] | |
1134 | .size __return_r29_r31,.-__return_r29_r31 | |
1135 | #endif /* L_save_31c */ | |
1136 | ||
1137 | #ifdef L_save_varargs | |
1138 | .text | |
1139 | .align 2 | |
1140 | .globl __save_r6_r9 | |
1141 | .type __save_r6_r9,@function | |
1142 | /* Save registers 6 .. 9 on the stack for variable argument functions */ | |
1143 | /* Called via: jalr __save_r6_r9,r10 */ | |
1144 | __save_r6_r9: | |
1145 | mov ep,r1 | |
1146 | mov sp,ep | |
1147 | sst.w r6,0[ep] | |
1148 | sst.w r7,4[ep] | |
1149 | sst.w r8,8[ep] | |
1150 | sst.w r9,12[ep] | |
1151 | mov r1,ep | |
1152 | jmp [r10] | |
1153 | .size __save_r6_r9,.-__save_r6_r9 | |
1154 | #endif /* L_save_varargs */ | |
1155 | ||
1156 | #ifdef L_save_interrupt | |
1157 | .text | |
1158 | .align 2 | |
1159 | .globl __save_interrupt | |
1160 | .type __save_interrupt,@function | |
b24bcfb3 | 1161 | /* Save registers r1, r4 on stack and load up with expected values */ |
ae180d84 JL |
1162 | /* Note, 12 bytes of stack have already been allocated. */ |
1163 | /* Called via: jalr __save_interrupt,r10 */ | |
1164 | __save_interrupt: | |
1165 | st.w ep,0[sp] | |
1166 | st.w gp,4[sp] | |
1167 | st.w r1,8[sp] | |
1168 | movhi hi(__ep),r0,ep | |
1169 | movea lo(__ep),ep,ep | |
1170 | movhi hi(__gp),r0,gp | |
1171 | movea lo(__gp),gp,gp | |
1172 | jmp [r10] | |
1173 | .size __save_interrupt,.-__save_interrupt | |
1174 | ||
1175 | /* Restore saved registers, deallocate stack and return from the interrupt */ | |
956d6950 | 1176 | /* Called via: jr __return_interrupt */ |
ae180d84 JL |
1177 | .align 2 |
1178 | .globl __return_interrupt | |
1179 | .type __return_interrupt,@function | |
1180 | __return_interrupt: | |
1181 | ld.w 0[sp],ep | |
1182 | ld.w 4[sp],gp | |
b24bcfb3 | 1183 | ld.w 8[sp],r1 |
5a75af62 | 1184 | ld.w 12[sp],r10 |
f1be41ad | 1185 | addi 16,sp,sp |
ae180d84 JL |
1186 | reti |
1187 | .size __return_interrupt,.-__return_interrupt | |
1188 | #endif /* L_save_interrupt */ | |
1189 | ||
1190 | #ifdef L_save_all_interrupt | |
1191 | .text | |
1192 | .align 2 | |
1193 | .globl __save_all_interrupt | |
1194 | .type __save_all_interrupt,@function | |
1195 | /* Save all registers except for those saved in __save_interrupt */ | |
1196 | /* allocate enough stack for all of the registers & 16 bytes of space */ | |
1197 | /* Called via: jalr __save_all_interrupt,r10 */ | |
1198 | __save_all_interrupt: | |
1199 | addi -120,sp,sp | |
1200 | mov ep,r1 | |
1201 | mov sp,ep | |
1202 | sst.w r31,116[ep] | |
1203 | sst.w r2,112[ep] | |
1204 | sst.w gp,108[ep] | |
1205 | sst.w r6,104[ep] | |
1206 | sst.w r7,100[ep] | |
1207 | sst.w r8,96[ep] | |
1208 | sst.w r9,92[ep] | |
1209 | sst.w r11,88[ep] | |
1210 | sst.w r12,84[ep] | |
1211 | sst.w r13,80[ep] | |
1212 | sst.w r14,76[ep] | |
1213 | sst.w r15,72[ep] | |
1214 | sst.w r16,68[ep] | |
1215 | sst.w r17,64[ep] | |
1216 | sst.w r18,60[ep] | |
1217 | sst.w r19,56[ep] | |
1218 | sst.w r20,52[ep] | |
1219 | sst.w r21,48[ep] | |
1220 | sst.w r22,44[ep] | |
1221 | sst.w r23,40[ep] | |
1222 | sst.w r24,36[ep] | |
1223 | sst.w r25,32[ep] | |
1224 | sst.w r26,28[ep] | |
1225 | sst.w r27,24[ep] | |
1226 | sst.w r28,20[ep] | |
1227 | sst.w r29,16[ep] | |
1228 | mov r1,ep | |
1229 | jmp [r10] | |
1230 | .size __save_all_interrupt,.-__save_all_interrupt | |
1231 | ||
1232 | .globl __restore_all_interrupt | |
1233 | .type __restore_all_interrupt,@function | |
1234 | /* Restore all registers saved in __save_all_interrupt */ | |
1235 | /* & deallocate the stack space */ | |
1236 | /* Called via: jalr __restore_all_interrupt,r10 */ | |
1237 | __restore_all_interrupt: | |
1238 | mov ep,r1 | |
1239 | mov sp,ep | |
1240 | sld.w 116[ep],r31 | |
1241 | sld.w 112[ep],r2 | |
1242 | sld.w 108[ep],gp | |
1243 | sld.w 104[ep],r6 | |
1244 | sld.w 100[ep],r7 | |
1245 | sld.w 96[ep],r8 | |
1246 | sld.w 92[ep],r9 | |
1247 | sld.w 88[ep],r11 | |
1248 | sld.w 84[ep],r12 | |
1249 | sld.w 80[ep],r13 | |
1250 | sld.w 76[ep],r14 | |
1251 | sld.w 72[ep],r15 | |
1252 | sld.w 68[ep],r16 | |
1253 | sld.w 64[ep],r17 | |
1254 | sld.w 60[ep],r18 | |
1255 | sld.w 56[ep],r19 | |
1256 | sld.w 52[ep],r20 | |
1257 | sld.w 48[ep],r21 | |
1258 | sld.w 44[ep],r22 | |
1259 | sld.w 40[ep],r23 | |
1260 | sld.w 36[ep],r24 | |
1261 | sld.w 32[ep],r25 | |
1262 | sld.w 28[ep],r26 | |
1263 | sld.w 24[ep],r27 | |
1264 | sld.w 20[ep],r28 | |
1265 | sld.w 16[ep],r29 | |
1266 | mov r1,ep | |
1267 | addi 120,sp,sp | |
1268 | jmp [r10] | |
1269 | .size __restore_all_interrupt,.-__restore_all_interrupt | |
1270 | #endif /* L_save_all_interrupt */ |