Dead
[official-gcc.git] / gomp-20050608-branch / gcc / config / mips / mips16.S
bloba6afa0c0544791cd997ba8aab30cb289d4cde381
1 /* mips16 floating point support code
2    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
3    Contributed by Cygnus Support
5 This file is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
8 later version.
10 In addition to the permissions in the GNU General Public License, the
11 Free Software Foundation gives you unlimited permission to link the
12 compiled version of this file with other programs, and to distribute
13 those programs without any restriction coming from the use of this
14 file.  (The General Public License restrictions do apply in other
15 respects; for example, they cover modification of the file, and
16 distribution when not linked into another program.)
18 This file is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; see the file COPYING.  If not, write to
25 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
26 Boston, MA 02110-1301, USA.  */
28 /* As a special exception, if you link this library with other files,
29    some of which are compiled with GCC, to produce an executable,
30    this library does not by itself cause the resulting executable
31    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.  */
35 /* This file contains mips16 floating point support functions.  These
36    functions are called by mips16 code to handle floating point when
37    -msoft-float is not used.  They accept the arguments and return
38    values using the soft-float calling convention, but do the actual
39    operation using the hard floating point instructions.  */
41 /* This file contains 32 bit assembly code.  */
42         .set nomips16
44 /* Start a function.  */
46 #define STARTFN(NAME) .globl NAME; .ent NAME; NAME:
48 /* Finish a function.  */
50 #define ENDFN(NAME) .end NAME
52 /* Single precision math.  */
54 /* This macro defines a function which loads two single precision
55    values, performs an operation, and returns the single precision
56    result.  */
58 #define SFOP(NAME, OPCODE)      \
59 STARTFN (NAME);                 \
60         .set    noreorder;      \
61         mtc1    $4,$f0;         \
62         mtc1    $5,$f2;         \
63         nop;                    \
64         OPCODE  $f0,$f0,$f2;    \
65         mfc1    $2,$f0;         \
66         j       $31;            \
67         nop;                    \
68         .set    reorder;        \
69         ENDFN (NAME)
71 #ifdef L_m16addsf3
72 SFOP(__mips16_addsf3, add.s)
73 #endif
74 #ifdef L_m16subsf3
75 SFOP(__mips16_subsf3, sub.s)
76 #endif
77 #ifdef L_m16mulsf3
78 SFOP(__mips16_mulsf3, mul.s)
79 #endif
80 #ifdef L_m16divsf3
81 SFOP(__mips16_divsf3, div.s)
82 #endif
84 #define SFOP2(NAME, OPCODE)     \
85 STARTFN (NAME);                 \
86         .set    noreorder;      \
87         mtc1    $4,$f0;         \
88         nop;                    \
89         OPCODE  $f0,$f0;        \
90         mfc1    $2,$f0;         \
91         j       $31;            \
92         nop;                    \
93         .set    reorder;        \
94         ENDFN (NAME)
96 #ifdef L_m16negsf2
97 SFOP2(__mips16_negsf2, neg.s)
98 #endif
99 #ifdef L_m16abssf2
100 SFOP2(__mips16_abssf2, abs.s)
101 #endif
103 /* Single precision comparisons.  */
105 /* This macro defines a function which loads two single precision
106    values, performs a floating point comparison, and returns the
107    specified values according to whether the comparison is true or
108    false.  */
110 #define SFCMP(NAME, OPCODE, TRUE, FALSE)        \
111 STARTFN (NAME);                                 \
112         mtc1    $4,$f0;                         \
113         mtc1    $5,$f2;                         \
114         OPCODE  $f0,$f2;                        \
115         li      $2,TRUE;                        \
116         bc1t    1f;                             \
117         li      $2,FALSE;                       \
118 1:;                                             \
119         j       $31;                            \
120         ENDFN (NAME)
122 /* This macro is like SFCMP, but it reverses the comparison.  */
124 #define SFREVCMP(NAME, OPCODE, TRUE, FALSE)     \
125 STARTFN (NAME);                                 \
126         mtc1    $4,$f0;                         \
127         mtc1    $5,$f2;                         \
128         OPCODE  $f2,$f0;                        \
129         li      $2,TRUE;                        \
130         bc1t    1f;                             \
131         li      $2,FALSE;                       \
132 1:;                                             \
133         j       $31;                            \
134         ENDFN (NAME)
136 #ifdef L_m16eqsf2
137 SFCMP(__mips16_eqsf2, c.eq.s, 0, 1)
138 #endif
139 #ifdef L_m16nesf2
140 SFCMP(__mips16_nesf2, c.eq.s, 0, 1)
141 #endif
142 #ifdef L_m16gtsf2
143 SFREVCMP(__mips16_gtsf2, c.lt.s, 1, 0)
144 #endif
145 #ifdef L_m16gesf2
146 SFREVCMP(__mips16_gesf2, c.le.s, 0, -1)
147 #endif
148 #ifdef L_m16lesf2
149 SFCMP(__mips16_lesf2, c.le.s, 0, 1)
150 #endif
151 #ifdef L_m16ltsf2
152 SFCMP(__mips16_ltsf2, c.lt.s, -1, 0)
153 #endif
155 /* Single precision conversions.  */
157 #ifdef L_m16fltsisf
158 STARTFN (__mips16_floatsisf)
159         .set    noreorder
160         mtc1    $4,$f0
161         nop
162         cvt.s.w $f0,$f0
163         mfc1    $2,$f0
164         j       $31
165         nop
166         .set    reorder
167         ENDFN (__mips16_floatsisf)
168 #endif
170 #ifdef L_m16fix_truncsfsi
171 STARTFN (__mips16_fix_truncsfsi)
172         .set    noreorder
173         mtc1    $4,$f0
174         nop
175         trunc.w.s $f0,$f0,$4
176         mfc1    $2,$f0
177         j       $31
178         nop
179         .set    reorder
180         ENDFN (__mips16_fix_truncsfsi)
181 #endif
183 #if !defined(__mips_single_float) && !defined(__SINGLE_FLOAT)
185 /* The double precision operations.  We need to use different code
186    based on the preprocessor symbol __mips64, because the way in which
187    double precision values will change.  Without __mips64, the value
188    is passed in two 32 bit registers.  With __mips64, the value is
189    passed in a single 64 bit register.  */
191 /* Load the first double precision operand.  */
193 #if defined(__mips64)
194 #define LDDBL1 dmtc1 $4,$f12
195 #elif defined(__mipsfp64)
196 #define LDDBL1 sw $4,0($29); sw $5,4($29); l.d $f12,0($29)
197 #elif defined(__MIPSEB__)
198 #define LDDBL1 mtc1 $4,$f13; mtc1 $5,$f12
199 #else
200 #define LDDBL1 mtc1 $4,$f12; mtc1 $5,$f13
201 #endif
203 /* Load the second double precision operand.  */
205 #if defined(__mips64)
206 /* XXX this should be $6 for Algo arg passing model */
207 #define LDDBL2 dmtc1 $5,$f14
208 #elif defined(__mipsfp64)
209 #define LDDBL2 sw $6,8($29); sw $7,12($29); l.d $f14,8($29)
210 #elif defined(__MIPSEB__)
211 #define LDDBL2 mtc1 $6,$f15; mtc1 $7,$f14
212 #else
213 #define LDDBL2 mtc1 $6,$f14; mtc1 $7,$f15
214 #endif
216 /* Move the double precision return value to the right place.  */
218 #if defined(__mips64)
219 #define RETDBL dmfc1 $2,$f0
220 #elif defined(__mipsfp64)
221 #define RETDBL s.d $f0,0($29); lw $2,0($29); lw $3,4($29)
222 #elif defined(__MIPSEB__)
223 #define RETDBL mfc1 $2,$f1; mfc1 $3,$f0
224 #else
225 #define RETDBL mfc1 $2,$f0; mfc1 $3,$f1
226 #endif
228 /* Double precision math.  */
230 /* This macro defines a function which loads two double precision
231    values, performs an operation, and returns the double precision
232    result.  */
234 #define DFOP(NAME, OPCODE)      \
235 STARTFN (NAME);                 \
236         .set    noreorder;      \
237         LDDBL1;                 \
238         LDDBL2;                 \
239         nop;                    \
240         OPCODE  $f0,$f12,$f14;  \
241         RETDBL;                 \
242         j       $31;            \
243         nop;                    \
244         .set    reorder;        \
245         ENDFN (NAME)
247 #ifdef L_m16adddf3
248 DFOP(__mips16_adddf3, add.d)
249 #endif
250 #ifdef L_m16subdf3
251 DFOP(__mips16_subdf3, sub.d)
252 #endif
253 #ifdef L_m16muldf3
254 DFOP(__mips16_muldf3, mul.d)
255 #endif
256 #ifdef L_m16divdf3
257 DFOP(__mips16_divdf3, div.d)
258 #endif
260 #define DFOP2(NAME, OPCODE)     \
261 STARTFN (NAME);                 \
262         .set    noreorder;      \
263         LDDBL1;                 \
264         nop;                    \
265         OPCODE  $f0,$f12;       \
266         RETDBL;                 \
267         j       $31;            \
268         nop;                    \
269         .set    reorder;        \
270         ENDFN (NAME)
272 #ifdef L_m16negdf2
273 DFOP2(__mips16_negdf2, neg.d)
274 #endif
275 #ifdef L_m16absdf2
276 DFOP2(__mips16_absdf2, abs.d)
277 #endif
280 /* Conversions between single and double precision.  */
282 #ifdef L_m16extsfdf2
283 STARTFN (__mips16_extendsfdf2)
284         .set    noreorder
285         mtc1    $4,$f12
286         nop
287         cvt.d.s $f0,$f12
288         RETDBL
289         j       $31
290         nop
291         .set    reorder
292         ENDFN (__mips16_extendsfdf2)
293 #endif
295 #ifdef L_m16trdfsf2
296 STARTFN (__mips16_truncdfsf2)
297         .set    noreorder
298         LDDBL1
299         nop
300         cvt.s.d $f0,$f12
301         mfc1    $2,$f0
302         j       $31
303         nop
304         .set    reorder
305         ENDFN (__mips16_truncdfsf2)
306 #endif
308 /* Double precision comparisons.  */
310 /* This macro defines a function which loads two double precision
311    values, performs a floating point comparison, and returns the
312    specified values according to whether the comparison is true or
313    false.  */
315 #define DFCMP(NAME, OPCODE, TRUE, FALSE)        \
316 STARTFN (NAME);                                 \
317         LDDBL1;                                 \
318         LDDBL2;                                 \
319         OPCODE  $f12,$f14;                      \
320         li      $2,TRUE;                        \
321         bc1t    1f;                             \
322         li      $2,FALSE;                       \
323 1:;                                             \
324         j       $31;                            \
325         ENDFN (NAME)
327 /* This macro is like DFCMP, but it reverses the comparison.  */
329 #define DFREVCMP(NAME, OPCODE, TRUE, FALSE)     \
330 STARTFN (NAME);                                 \
331         LDDBL1;                                 \
332         LDDBL2;                                 \
333         OPCODE  $f14,$f12;                      \
334         li      $2,TRUE;                        \
335         bc1t    1f;                             \
336         li      $2,FALSE;                       \
337 1:;                                             \
338         j       $31;                            \
339         ENDFN (NAME)
341 #ifdef L_m16eqdf2
342 DFCMP(__mips16_eqdf2, c.eq.d, 0, 1)
343 #endif
344 #ifdef L_m16nedf2
345 DFCMP(__mips16_nedf2, c.eq.d, 0, 1)
346 #endif
347 #ifdef L_m16gtdf2
348 DFREVCMP(__mips16_gtdf2, c.lt.d, 1, 0)
349 #endif
350 #ifdef L_m16gedf2
351 DFREVCMP(__mips16_gedf2, c.le.d, 0, -1)
352 #endif
353 #ifdef L_m16ledf2
354 DFCMP(__mips16_ledf2, c.le.d, 0, 1)
355 #endif
356 #ifdef L_m16ltdf2
357 DFCMP(__mips16_ltdf2, c.lt.d, -1, 0)
358 #endif
360 /* Double precision conversions.  */
362 #ifdef L_m16fltsidf
363 STARTFN (__mips16_floatsidf)
364         .set    noreorder
365         mtc1    $4,$f12
366         nop
367         cvt.d.w $f0,$f12
368         RETDBL
369         j       $31
370         nop
371         .set    reorder
372         ENDFN (__mips16_floatsidf)
373 #endif
375 #ifdef L_m16fix_truncdfsi
376 STARTFN (__mips16_fix_truncdfsi)
377         .set    noreorder
378         LDDBL1
379         nop
380         trunc.w.d $f0,$f12,$4
381         mfc1    $2,$f0
382         j       $31
383         nop
384         .set    reorder
385         ENDFN (__mips16_fix_truncdfsi)
386 #endif
387 #endif /* !__mips_single_float */
389 /* These functions are used to return floating point values from
390    mips16 functions.  In this case we can put mtc1 in a jump delay slot,
391    because we know that the next instruction will not refer to a floating
392    point register.  */
394 #ifdef L_m16retsf
395 STARTFN (__mips16_ret_sf)
396         .set    noreorder
397         j       $31
398         mtc1    $2,$f0
399         .set    reorder
400         ENDFN (__mips16_ret_sf)
401 #endif
403 #if !defined(__mips_single_float) && !defined(__SINGLE_FLOAT)
404 #ifdef L_m16retdf
405 STARTFN (__mips16_ret_df)
406         .set    noreorder
407 #if defined(__mips64)
408         j       $31
409         dmtc1   $2,$f0
410 #elif defined(__mipsfp64)
411         sw      $2,0($29)
412         sw      $3,4($29)
413         l.d     $f0,0($29)
414 #elif defined(__MIPSEB__)
415         mtc1    $2,$f1
416         j       $31
417         mtc1    $3,$f0
418 #else
419         mtc1    $2,$f0
420         j       $31
421         mtc1    $3,$f1
422 #endif
423         .set    reorder
424         ENDFN (__mips16_ret_df)
425 #endif
426 #endif /* !__mips_single_float */
428 /* These functions are used by 16 bit code when calling via a function
429    pointer.  They must copy the floating point arguments from the gp
430    regs into the fp regs.  The function to call will be in $2.  The
431    exact set of floating point arguments to copy is encoded in the
432    function name; the final number is an fp_code, as described in
433    mips.h in the comment about CUMULATIVE_ARGS.  */
435 #ifdef L_m16stub1
436 /* (float) */
437 STARTFN (__mips16_call_stub_1)
438         .set    noreorder
439         mtc1    $4,$f12
440         j       $2
441         nop
442         .set    reorder
443         ENDFN (__mips16_call_stub_1)
444 #endif
446 #ifdef L_m16stub5
447 /* (float, float) */
448 STARTFN (__mips16_call_stub_5)
449         .set    noreorder
450         mtc1    $4,$f12
451         mtc1    $5,$f14
452         j       $2
453         nop
454         .set    reorder
455         ENDFN (__mips16_call_stub_5)
456 #endif
458 #if !defined(__mips_single_float) && !defined(__SINGLE_FLOAT)
460 #ifdef L_m16stub2
461 /* (double) */
462 STARTFN (__mips16_call_stub_2)
463         .set    noreorder
464         LDDBL1
465         j       $2
466         nop
467         .set    reorder
468         ENDFN (__mips16_call_stub_2)
469 #endif
471 #ifdef L_m16stub6
472 /* (double, float) */
473 STARTFN (__mips16_call_stub_6)
474         .set    noreorder
475         LDDBL1
476         mtc1    $6,$f14
477         j       $2
478         nop
479         .set    reorder
480         ENDFN (__mips16_call_stub_6)
481 #endif
483 #ifdef L_m16stub9
484 /* (float, double) */
485 STARTFN (__mips16_call_stub_9)
486         .set    noreorder
487         mtc1    $4,$f12
488         LDDBL2
489         j       $2
490         nop
491         .set    reorder
492         ENDFN (__mips16_call_stub_9)
493 #endif
495 #ifdef L_m16stub10
496 /* (double, double) */
497 STARTFN (__mips16_call_stub_10)
498         .set    noreorder
499         LDDBL1
500         LDDBL2
501         j       $2
502         nop
503         .set    reorder
504         ENDFN (__mips16_call_stub_10)
505 #endif
506 #endif /* !__mips_single_float */
508 /* Now we have the same set of functions, except that this time the
509    function being called returns an SFmode value.  The calling
510    function will arrange to preserve $18, so these functions are free
511    to use it to hold the return address.
513    Note that we do not know whether the function we are calling is 16
514    bit or 32 bit.  However, it does not matter, because 16 bit
515    functions always return floating point values in both the gp and
516    the fp regs.  It would be possible to check whether the function
517    being called is 16 bits, in which case the copy is unnecessary;
518    however, it's faster to always do the copy.  */
520 #ifdef L_m16stubsf0
521 /* () */
522 STARTFN (__mips16_call_stub_sf_0)
523         .set    noreorder
524         move    $18,$31
525         jal     $2
526         nop
527         mfc1    $2,$f0
528         j       $18
529         nop
530         .set    reorder
531         ENDFN (__mips16_call_stub_sf_0)
532 #endif
534 #ifdef L_m16stubsf1
535 /* (float) */
536 STARTFN (__mips16_call_stub_sf_1)
537         .set    noreorder
538         mtc1    $4,$f12
539         move    $18,$31
540         jal     $2
541         nop
542         mfc1    $2,$f0
543         j       $18
544         nop
545         .set    reorder
546         ENDFN (__mips16_call_stub_sf_1)
547 #endif
549 #ifdef L_m16stubsf5
550 /* (float, float) */
551 STARTFN (__mips16_call_stub_sf_5)
552         .set    noreorder
553         mtc1    $4,$f12
554         mtc1    $5,$f14
555         move    $18,$31
556         jal     $2
557         nop
558         mfc1    $2,$f0
559         j       $18
560         nop
561         .set    reorder
562         ENDFN (__mips16_call_stub_sf_5)
563 #endif
565 #if !defined(__mips_single_float) && !defined(__SINGLE_FLOAT)
566 #ifdef L_m16stubsf2
567 /* (double) */
568 STARTFN (__mips16_call_stub_sf_2)
569         .set    noreorder
570         LDDBL1
571         move    $18,$31
572         jal     $2
573         nop
574         mfc1    $2,$f0
575         j       $18
576         nop
577         .set    reorder
578         ENDFN (__mips16_call_stub_sf_2)
579 #endif
581 #ifdef L_m16stubsf6
582 /* (double, float) */
583 STARTFN (__mips16_call_stub_sf_6)
584         .set    noreorder
585         LDDBL1
586         mtc1    $6,$f14
587         move    $18,$31
588         jal     $2
589         nop
590         mfc1    $2,$f0
591         j       $18
592         nop
593         .set    reorder
594         ENDFN (__mips16_call_stub_sf_6)
595 #endif
597 #ifdef L_m16stubsf9
598 /* (float, double) */
599 STARTFN (__mips16_call_stub_sf_9)
600         .set    noreorder
601         mtc1    $4,$f12
602         LDDBL2
603         move    $18,$31
604         jal     $2
605         nop
606         mfc1    $2,$f0
607         j       $18
608         nop
609         .set    reorder
610         ENDFN (__mips16_call_stub_sf_9)
611 #endif
613 #ifdef L_m16stubsf10
614 /* (double, double) */
615 STARTFN (__mips16_call_stub_sf_10)
616         .set    noreorder
617         LDDBL1
618         LDDBL2
619         move    $18,$31
620         jal     $2
621         nop
622         mfc1    $2,$f0
623         j       $18
624         nop
625         .set    reorder
626         ENDFN (__mips16_call_stub_sf_10)
627 #endif
629 /* Now we have the same set of functions again, except that this time
630    the function being called returns an DFmode value.  */
632 #ifdef L_m16stubdf0
633 /* () */
634 STARTFN (__mips16_call_stub_df_0)
635         .set    noreorder
636         move    $18,$31
637         jal     $2
638         nop
639         RETDBL
640         j       $18
641         nop
642         .set    reorder
643         ENDFN (__mips16_call_stub_df_0)
644 #endif
646 #ifdef L_m16stubdf1
647 /* (float) */
648 STARTFN (__mips16_call_stub_df_1)
649         .set    noreorder
650         mtc1    $4,$f12
651         move    $18,$31
652         jal     $2
653         nop
654         RETDBL
655         j       $18
656         nop
657         .set    reorder
658         ENDFN (__mips16_call_stub_df_1)
659 #endif
661 #ifdef L_m16stubdf2
662 /* (double) */
663 STARTFN (__mips16_call_stub_df_2)
664         .set    noreorder
665         LDDBL1
666         move    $18,$31
667         jal     $2
668         nop
669         RETDBL
670         j       $18
671         nop
672         .set    reorder
673         ENDFN (__mips16_call_stub_df_2)
674 #endif
676 #ifdef L_m16stubdf5
677 /* (float, float) */
678 STARTFN (__mips16_call_stub_df_5)
679         .set    noreorder
680         mtc1    $4,$f12
681         mtc1    $5,$f14
682         move    $18,$31
683         jal     $2
684         nop
685         RETDBL
686         j       $18
687         nop
688         .set    reorder
689         ENDFN (__mips16_call_stub_df_5)
690 #endif
692 #ifdef L_m16stubdf6
693 /* (double, float) */
694 STARTFN (__mips16_call_stub_df_6)
695         .set    noreorder
696         LDDBL1
697         mtc1    $6,$f14
698         move    $18,$31
699         jal     $2
700         nop
701         RETDBL
702         j       $18
703         nop
704         .set    reorder
705         ENDFN (__mips16_call_stub_df_6)
706 #endif
708 #ifdef L_m16stubdf9
709 /* (float, double) */
710 STARTFN (__mips16_call_stub_df_9)
711         .set    noreorder
712         mtc1    $4,$f12
713         LDDBL2
714         move    $18,$31
715         jal     $2
716         nop
717         RETDBL
718         j       $18
719         nop
720         .set    reorder
721         ENDFN (__mips16_call_stub_df_9)
722 #endif
724 #ifdef L_m16stubdf10
725 /* (double, double) */
726 STARTFN (__mips16_call_stub_df_10)
727         .set    noreorder
728         LDDBL1
729         LDDBL2
730         move    $18,$31
731         jal     $2
732         nop
733         RETDBL
734         j       $18
735         nop
736         .set    reorder
737         ENDFN (__mips16_call_stub_df_10)
738 #endif
739 #endif /* !__mips_single_float */