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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [config/] [mips/] [mips16.S] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* mips16 floating point support code
2
   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
3
   Contributed by Cygnus Support
4
 
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.
9
 
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.)
17
 
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.
22
 
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.  */
27
 
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.  */
34
 
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.  */
40
 
41
/* This file contains 32 bit assembly code.  */
42
        .set nomips16
43
 
44
/* Start a function.  */
45
 
46
#define STARTFN(NAME) .globl NAME; .ent NAME; NAME:
47
 
48
/* Finish a function.  */
49
 
50
#define ENDFN(NAME) .end NAME
51
 
52
/* Single precision math.  */
53
 
54
/* This macro defines a function which loads two single precision
55
   values, performs an operation, and returns the single precision
56
   result.  */
57
 
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)
70
 
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
83
 
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)
95
 
96
#ifdef L_m16negsf2
97
SFOP2(__mips16_negsf2, neg.s)
98
#endif
99
#ifdef L_m16abssf2
100
SFOP2(__mips16_abssf2, abs.s)
101
#endif
102
 
103
/* Single precision comparisons.  */
104
 
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.  */
109
 
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)
121
 
122
/* This macro is like SFCMP, but it reverses the comparison.  */
123
 
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)
135
 
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
154
 
155
/* Single precision conversions.  */
156
 
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
169
 
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
182
 
183
#if !defined(__mips_single_float) && !defined(__SINGLE_FLOAT)
184
 
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.  */
190
 
191
/* Load the first double precision operand.  */
192
 
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
202
 
203
/* Load the second double precision operand.  */
204
 
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
215
 
216
/* Move the double precision return value to the right place.  */
217
 
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
227
 
228
/* Double precision math.  */
229
 
230
/* This macro defines a function which loads two double precision
231
   values, performs an operation, and returns the double precision
232
   result.  */
233
 
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)
246
 
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
259
 
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)
271
 
272
#ifdef L_m16negdf2
273
DFOP2(__mips16_negdf2, neg.d)
274
#endif
275
#ifdef L_m16absdf2
276
DFOP2(__mips16_absdf2, abs.d)
277
#endif
278
 
279
 
280
/* Conversions between single and double precision.  */
281
 
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
294
 
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
307
 
308
/* Double precision comparisons.  */
309
 
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.  */
314
 
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)
326
 
327
/* This macro is like DFCMP, but it reverses the comparison.  */
328
 
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)
340
 
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
359
 
360
/* Double precision conversions.  */
361
 
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
374
 
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 */
388
 
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.  */
393
 
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
402
 
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 */
427
 
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.  */
434
 
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
445
 
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
457
 
458
#if !defined(__mips_single_float) && !defined(__SINGLE_FLOAT)
459
 
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
470
 
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
482
 
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
494
 
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 */
507
 
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.
512
 
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.  */
519
 
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
533
 
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
548
 
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
564
 
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
580
 
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
596
 
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
612
 
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
628
 
629
/* Now we have the same set of functions again, except that this time
630
   the function being called returns an DFmode value.  */
631
 
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
645
 
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
660
 
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
675
 
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
691
 
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
707
 
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
723
 
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 */

powered by: WebSVN 2.1.0

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