source: mainline/uspace/lib/softfloat/softfloat.c@ ecd991a

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since ecd991a was 2416085, checked in by Martin Decky <martin@…>, 13 years ago

softfloat: move sources to a single directory
implement more ARM EABI bindings
  • Property mode set to 100644
File size: 20.6 KB
Line 
1/*
2 * Copyright (c) 2005 Josef Cejka
3 * Copyright (c) 2011 Petr Koupy
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup softfloat generic
31 * @ingroup sfl
32 * @brief Architecture independent parts of FPU software emulation library.
33 * @{
34 */
35/** @file Softfloat API.
36 */
37
38#include "softfloat.h"
39#include "sftypes.h"
40#include "add.h"
41#include "sub.h"
42#include "mul.h"
43#include "div.h"
44#include "conversion.h"
45#include "comparison.h"
46#include "other.h"
47
48/* Arithmetic functions */
49
50float __addsf3(float a, float b)
51{
52 float_t fa;
53 float_t fb;
54 float_t res;
55
56 fa.val = a;
57 fb.val = b;
58
59 if (fa.data.parts.sign != fb.data.parts.sign) {
60 if (fa.data.parts.sign) {
61 fa.data.parts.sign = 0;
62 res.data = sub_float(fb.data, fa.data);
63
64 return res.val;
65 }
66
67 fb.data.parts.sign = 0;
68 res.data = sub_float(fa.data, fb.data);
69
70 return res.val;
71 }
72
73 res.data = add_float(fa.data, fb.data);
74 return res.val;
75}
76
77double __adddf3(double a, double b)
78{
79 double_t da;
80 double_t db;
81 double_t res;
82
83 da.val = a;
84 db.val = b;
85
86 if (da.data.parts.sign != db.data.parts.sign) {
87 if (da.data.parts.sign) {
88 da.data.parts.sign = 0;
89 res.data = sub_double(db.data, da.data);
90
91 return res.val;
92 }
93
94 db.data.parts.sign = 0;
95 res.data = sub_double(da.data, db.data);
96
97 return res.val;
98 }
99
100 res.data = add_double(da.data, db.data);
101 return res.val;
102}
103
104long double __addtf3(long double a, long double b)
105{
106 long_double_t ta;
107 long_double_t tb;
108 long_double_t res;
109
110 ta.val = a;
111 tb.val = b;
112
113 if (ta.data.parts.sign != tb.data.parts.sign) {
114 if (ta.data.parts.sign) {
115 ta.data.parts.sign = 0;
116 res.data = sub_long_double(tb.data, ta.data);
117
118 return res.val;
119 }
120
121 tb.data.parts.sign = 0;
122 res.data = sub_long_double(ta.data, tb.data);
123
124 return res.val;
125 }
126
127 res.data = add_long_double(ta.data, tb.data);
128 return res.val;
129}
130
131float __subsf3(float a, float b)
132{
133 float_t fa;
134 float_t fb;
135 float_t res;
136
137 fa.val = a;
138 fb.val = b;
139
140 if (fa.data.parts.sign != fb.data.parts.sign) {
141 fb.data.parts.sign = !fb.data.parts.sign;
142 res.data = add_float(fa.data, fb.data);
143
144 return res.val;
145 }
146
147 res.data = sub_float(fa.data, fb.data);
148 return res.val;
149}
150
151double __subdf3(double a, double b)
152{
153 double_t da;
154 double_t db;
155 double_t res;
156
157 da.val = a;
158 db.val = b;
159
160 if (da.data.parts.sign != db.data.parts.sign) {
161 db.data.parts.sign = !db.data.parts.sign;
162 res.data = add_double(da.data, db.data);
163
164 return res.val;
165 }
166
167 res.data = sub_double(da.data, db.data);
168 return res.val;
169}
170
171long double __subtf3(long double a, long double b)
172{
173 long_double_t ta;
174 long_double_t tb;
175 long_double_t res;
176
177 ta.val = a;
178 tb.val = b;
179
180 if (ta.data.parts.sign != tb.data.parts.sign) {
181 tb.data.parts.sign = !tb.data.parts.sign;
182 res.data = add_long_double(ta.data, tb.data);
183
184 return res.val;
185 }
186
187 res.data = sub_long_double(ta.data, tb.data);
188 return res.val;
189}
190
191float __mulsf3(float a, float b)
192{
193 float_t fa;
194 float_t fb;
195 float_t res;
196
197 fa.val = a;
198 fb.val = b;
199
200 res.data = mul_float(fa.data, fb.data);
201 return res.val;
202}
203
204double __muldf3(double a, double b)
205{
206 double_t da;
207 double_t db;
208 double_t res;
209
210 da.val = a;
211 db.val = b;
212
213 res.data = mul_double(da.data, db.data);
214 return res.val;
215}
216
217long double __multf3(long double a, long double b)
218{
219 long_double_t ta;
220 long_double_t tb;
221 long_double_t res;
222
223 ta.val = a;
224 tb.val = b;
225
226 res.data = mul_long_double(ta.data, tb.data);
227 return res.val;
228}
229
230float __divsf3(float a, float b)
231{
232 float_t fa;
233 float_t fb;
234 float_t res;
235
236 fa.val = a;
237 fb.val = b;
238
239 res.data = div_float(fa.data, fb.data);
240 return res.val;
241}
242
243double __divdf3(double a, double b)
244{
245 double_t da;
246 double_t db;
247 double_t res;
248
249 da.val = a;
250 db.val = b;
251
252 res.data = div_double(da.data, db.data);
253 return res.val;
254}
255
256long double __divtf3(long double a, long double b)
257{
258 long_double_t ta;
259 long_double_t tb;
260 long_double_t res;
261
262 ta.val = a;
263 tb.val = b;
264
265 res.data = div_long_double(ta.data, tb.data);
266 return res.val;
267}
268
269float __negsf2(float a)
270{
271 float_t fa;
272
273 fa.val = a;
274 fa.data.parts.sign = !fa.data.parts.sign;
275
276 return fa.val;
277}
278
279double __negdf2(double a)
280{
281 double_t da;
282
283 da.val = a;
284 da.data.parts.sign = !da.data.parts.sign;
285
286 return da.val;
287}
288
289long double __negtf2(long double a)
290{
291 long_double_t ta;
292
293 ta.val = a;
294 ta.data.parts.sign = !ta.data.parts.sign;
295
296 return ta.val;
297}
298
299/* Conversion functions */
300
301double __extendsfdf2(float a)
302{
303 float_t fa;
304 double_t res;
305
306 fa.val = a;
307 res.data = float_to_double(fa.data);
308
309 return res.val;
310}
311
312long double __extendsftf2(float a)
313{
314 float_t fa;
315 long_double_t res;
316
317 fa.val = a;
318 res.data = float_to_long_double(fa.data);
319
320 return res.val;
321}
322
323long double __extenddftf2(double a)
324{
325 double_t da;
326 long_double_t res;
327
328 da.val = a;
329 res.data = double_to_long_double(da.data);
330
331 return res.val;
332}
333
334float __truncdfsf2(double a)
335{
336 double_t da;
337 float_t res;
338
339 da.val = a;
340 res.data = double_to_float(da.data);
341
342 return res.val;
343}
344
345float __trunctfsf2(long double a)
346{
347 long_double_t ta;
348 float_t res;
349
350 ta.val = a;
351 res.data = long_double_to_float(ta.data);
352
353 return res.val;
354}
355
356double __trunctfdf2(long double a)
357{
358 long_double_t ta;
359 double_t res;
360
361 ta.val = a;
362 res.data = long_double_to_double(ta.data);
363
364 return res.val;
365}
366
367int __fixsfsi(float a)
368{
369 float_t fa;
370
371 fa.val = a;
372 return float_to_int(fa.data);
373}
374
375int __fixdfsi(double a)
376{
377 double_t da;
378
379 da.val = a;
380 return double_to_int(da.data);
381}
382
383int __fixtfsi(long double a)
384{
385 long_double_t ta;
386
387 ta.val = a;
388 return long_double_to_int(ta.data);
389}
390
391long __fixsfdi(float a)
392{
393 float_t fa;
394
395 fa.val = a;
396 return float_to_long(fa.data);
397}
398
399long __fixdfdi(double a)
400{
401 double_t da;
402
403 da.val = a;
404 return double_to_long(da.data);
405}
406
407long __fixtfdi(long double a)
408{
409 long_double_t ta;
410
411 ta.val = a;
412 return long_double_to_long(ta.data);
413}
414
415long long __fixsfti(float a)
416{
417 float_t fa;
418
419 fa.val = a;
420 return float_to_llong(fa.data);
421}
422
423long long __fixdfti(double a)
424{
425 double_t da;
426
427 da.val = a;
428 return double_to_llong(da.data);
429}
430
431long long __fixtfti(long double a)
432{
433 long_double_t ta;
434
435 ta.val = a;
436 return long_double_to_llong(ta.data);
437}
438
439unsigned int __fixunssfsi(float a)
440{
441 float_t fa;
442
443 fa.val = a;
444 return float_to_uint(fa.data);
445}
446
447unsigned int __fixunsdfsi(double a)
448{
449 double_t da;
450
451 da.val = a;
452 return double_to_uint(da.data);
453}
454
455unsigned int __fixunstfsi(long double a)
456{
457 long_double_t ta;
458
459 ta.val = a;
460 return long_double_to_uint(ta.data);
461}
462
463unsigned long __fixunssfdi(float a)
464{
465 float_t fa;
466
467 fa.val = a;
468 return float_to_ulong(fa.data);
469}
470
471unsigned long __fixunsdfdi(double a)
472{
473 double_t da;
474
475 da.val = a;
476 return double_to_ulong(da.data);
477}
478
479unsigned long __fixunstfdi(long double a)
480{
481 long_double_t ta;
482
483 ta.val = a;
484 return long_double_to_ulong(ta.data);
485}
486
487unsigned long long __fixunssfti(float a)
488{
489 float_t fa;
490
491 fa.val = a;
492 return float_to_ullong(fa.data);
493}
494
495unsigned long long __fixunsdfti(double a)
496{
497 double_t da;
498
499 da.val = a;
500 return double_to_ullong(da.data);
501}
502
503unsigned long long __fixunstfti(long double a)
504{
505 long_double_t ta;
506
507 ta.val = a;
508 return long_double_to_ullong(ta.data);
509}
510
511float __floatsisf(int i)
512{
513 float_t res;
514
515 res.data = int_to_float(i);
516 return res.val;
517}
518
519double __floatsidf(int i)
520{
521 double_t res;
522
523 res.data = int_to_double(i);
524 return res.val;
525}
526
527long double __floatsitf(int i)
528{
529 long_double_t res;
530
531 res.data = int_to_long_double(i);
532 return res.val;
533}
534
535float __floatdisf(long i)
536{
537 float_t res;
538
539 res.data = long_to_float(i);
540 return res.val;
541}
542
543double __floatdidf(long i)
544{
545 double_t res;
546
547 res.data = long_to_double(i);
548 return res.val;
549}
550
551long double __floatditf(long i)
552{
553 long_double_t res;
554
555 res.data = long_to_long_double(i);
556 return res.val;
557}
558
559float __floattisf(long long i)
560{
561 float_t res;
562
563 res.data = llong_to_float(i);
564 return res.val;
565}
566
567double __floattidf(long long i)
568{
569 double_t res;
570
571 res.data = llong_to_double(i);
572 return res.val;
573}
574
575long double __floattitf(long long i)
576{
577 long_double_t res;
578
579 res.data = llong_to_long_double(i);
580 return res.val;
581}
582
583float __floatunsisf(unsigned int i)
584{
585 float_t res;
586
587 res.data = uint_to_float(i);
588 return res.val;
589}
590
591double __floatunsidf(unsigned int i)
592{
593 double_t res;
594
595 res.data = uint_to_double(i);
596 return res.val;
597}
598
599long double __floatunsitf(unsigned int i)
600{
601 long_double_t res;
602
603 res.data = uint_to_long_double(i);
604 return res.val;
605}
606
607float __floatundisf(unsigned long i)
608{
609 float_t res;
610
611 res.data = ulong_to_float(i);
612 return res.val;
613}
614
615double __floatundidf(unsigned long i)
616{
617 double_t res;
618
619 res.data = ulong_to_double(i);
620 return res.val;
621}
622
623long double __floatunditf(unsigned long i)
624{
625 long_double_t res;
626
627 res.data = ulong_to_long_double(i);
628 return res.val;
629}
630
631float __floatuntisf(unsigned long long i)
632{
633 float_t res;
634
635 res.data = ullong_to_float(i);
636 return res.val;
637}
638
639double __floatuntidf(unsigned long long i)
640{
641 double_t res;
642
643 res.data = ullong_to_double(i);
644 return res.val;
645}
646
647long double __floatuntitf(unsigned long long i)
648{
649 long_double_t res;
650
651 res.data = ullong_to_long_double(i);
652 return res.val;
653}
654
655/* Comparison functions */
656
657int __cmpsf2(float a, float b)
658{
659 float_t fa;
660 float_t fb;
661
662 fa.val = a;
663 fb.val = b;
664
665 if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
666 /* no special constant for unordered - maybe signaled? */
667 return 1;
668 }
669
670 if (is_float_eq(fa.data, fb.data))
671 return 0;
672
673 if (is_float_lt(fa.data, fb.data))
674 return -1;
675
676 return 1;
677}
678
679int __cmpdf2(double a, double b)
680{
681 double_t da;
682 double_t db;
683
684 da.val = a;
685 db.val = b;
686
687 if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
688 /* no special constant for unordered - maybe signaled? */
689 return 1;
690 }
691
692 if (is_double_eq(da.data, db.data))
693 return 0;
694
695 if (is_double_lt(da.data, db.data))
696 return -1;
697
698 return 1;
699}
700
701int __cmptf2(long double a, long double b)
702{
703 long_double_t ta;
704 long_double_t tb;
705
706 ta.val = a;
707 tb.val = b;
708
709 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
710 /* no special constant for unordered - maybe signaled? */
711 return 1;
712 }
713
714 if (is_long_double_eq(ta.data, tb.data))
715 return 0;
716
717 if (is_long_double_lt(ta.data, tb.data))
718 return -1;
719
720 return 1;
721}
722
723int __unordsf2(float a, float b)
724{
725 float_t fa;
726 float_t fb;
727
728 fa.val = a;
729 fb.val = b;
730
731 return ((is_float_nan(fa.data)) || (is_float_nan(fb.data)));
732}
733
734int __unorddf2(double a, double b)
735{
736 double_t da;
737 double_t db;
738
739 da.val = a;
740 db.val = b;
741
742 return ((is_double_nan(da.data)) || (is_double_nan(db.data)));
743}
744
745int __unordtf2(long double a, long double b)
746{
747 long_double_t ta;
748 long_double_t tb;
749
750 ta.val = a;
751 tb.val = b;
752
753 return ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)));
754}
755
756int __eqsf2(float a, float b)
757{
758 float_t fa;
759 float_t fb;
760
761 fa.val = a;
762 fb.val = b;
763
764 if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
765 // TODO: sigNaNs
766 return 1;
767 }
768
769 return is_float_eq(fa.data, fb.data) - 1;
770}
771
772int __eqdf2(double a, double b)
773{
774 double_t da;
775 double_t db;
776
777 da.val = a;
778 db.val = b;
779
780 if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
781 // TODO: sigNaNs
782 return 1;
783 }
784
785 return is_double_eq(da.data, db.data) - 1;
786}
787
788int __eqtf2(long double a, long double b)
789{
790 long_double_t ta;
791 long_double_t tb;
792
793 ta.val = a;
794 tb.val = b;
795
796 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
797 // TODO: sigNaNs
798 return 1;
799 }
800
801 return is_long_double_eq(ta.data, tb.data) - 1;
802}
803
804int __nesf2(float a, float b)
805{
806 /* strange behavior, but it was in gcc documentation */
807 return __eqsf2(a, b);
808}
809
810int __nedf2(double a, double b)
811{
812 /* strange behavior, but it was in gcc documentation */
813 return __eqdf2(a, b);
814}
815
816int __netf2(long double a, long double b)
817{
818 /* strange behavior, but it was in gcc documentation */
819 return __eqtf2(a, b);
820}
821
822int __gesf2(float a, float b)
823{
824 float_t fa;
825 float_t fb;
826
827 fa.val = a;
828 fb.val = b;
829
830 if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
831 // TODO: sigNaNs
832 return -1;
833 }
834
835 if (is_float_eq(fa.data, fb.data))
836 return 0;
837
838 if (is_float_gt(fa.data, fb.data))
839 return 1;
840
841 return -1;
842}
843
844int __gedf2(double a, double b)
845{
846 double_t da;
847 double_t db;
848
849 da.val = a;
850 db.val = b;
851
852 if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
853 // TODO: sigNaNs
854 return -1;
855 }
856
857 if (is_double_eq(da.data, db.data))
858 return 0;
859
860 if (is_double_gt(da.data, db.data))
861 return 1;
862
863 return -1;
864}
865
866int __getf2(long double a, long double b)
867{
868 long_double_t ta;
869 long_double_t tb;
870
871 ta.val = a;
872 tb.val = b;
873
874 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
875 // TODO: sigNaNs
876 return -1;
877 }
878
879 if (is_long_double_eq(ta.data, tb.data))
880 return 0;
881
882 if (is_long_double_gt(ta.data, tb.data))
883 return 1;
884
885 return -1;
886}
887
888int __ltsf2(float a, float b)
889{
890 float_t fa;
891 float_t fb;
892
893 fa.val = a;
894 fb.val = b;
895
896 if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
897 // TODO: sigNaNs
898 return 1;
899 }
900
901 if (is_float_lt(fa.data, fb.data))
902 return -1;
903
904 return 0;
905}
906
907int __ltdf2(double a, double b)
908{
909 double_t da;
910 double_t db;
911
912 da.val = a;
913 db.val = b;
914
915 if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
916 // TODO: sigNaNs
917 return 1;
918 }
919
920 if (is_double_lt(da.data, db.data))
921 return -1;
922
923 return 0;
924}
925
926int __lttf2(long double a, long double b)
927{
928 long_double_t ta;
929 long_double_t tb;
930
931 ta.val = a;
932 tb.val = b;
933
934 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
935 // TODO: sigNaNs
936 return 1;
937 }
938
939 if (is_long_double_lt(ta.data, tb.data))
940 return -1;
941
942 return 0;
943}
944
945int __lesf2(float a, float b)
946{
947 float_t fa;
948 float_t fb;
949
950 fa.val = a;
951 fb.val = b;
952
953 if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
954 // TODO: sigNaNs
955 return 1;
956 }
957
958 if (is_float_eq(fa.data, fb.data))
959 return 0;
960
961 if (is_float_lt(fa.data, fb.data))
962 return -1;
963
964 return 1;
965}
966
967int __ledf2(double a, double b)
968{
969 double_t da;
970 double_t db;
971
972 da.val = a;
973 db.val = b;
974
975 if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
976 // TODO: sigNaNs
977 return 1;
978 }
979
980 if (is_double_eq(da.data, db.data))
981 return 0;
982
983 if (is_double_lt(da.data, db.data))
984 return -1;
985
986 return 1;
987}
988
989int __letf2(long double a, long double b)
990{
991 long_double_t ta;
992 long_double_t tb;
993
994 ta.val = a;
995 tb.val = b;
996
997 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
998 // TODO: sigNaNs
999 return 1;
1000 }
1001
1002 if (is_long_double_eq(ta.data, tb.data))
1003 return 0;
1004
1005 if (is_long_double_lt(ta.data, tb.data))
1006 return -1;
1007
1008 return 1;
1009}
1010
1011int __gtsf2(float a, float b)
1012{
1013 float_t fa;
1014 float_t fb;
1015
1016 fa.val = a;
1017 fb.val = b;
1018
1019 if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) {
1020 // TODO: sigNaNs
1021 return -1;
1022 }
1023
1024 if (is_float_gt(fa.data, fb.data))
1025 return 1;
1026
1027 return 0;
1028}
1029
1030int __gtdf2(double a, double b)
1031{
1032 double_t da;
1033 double_t db;
1034
1035 da.val = a;
1036 db.val = b;
1037
1038 if ((is_double_nan(da.data)) || (is_double_nan(db.data))) {
1039 // TODO: sigNaNs
1040 return -1;
1041 }
1042
1043 if (is_double_gt(da.data, db.data))
1044 return 1;
1045
1046 return 0;
1047}
1048
1049int __gttf2(long double a, long double b)
1050{
1051 long_double_t ta;
1052 long_double_t tb;
1053
1054 ta.val = a;
1055 tb.val = b;
1056
1057 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) {
1058 // TODO: sigNaNs
1059 return -1;
1060 }
1061
1062 if (is_long_double_gt(ta.data, tb.data))
1063 return 1;
1064
1065 return 0;
1066}
1067
1068/* SPARC quadruple-precision wrappers */
1069
1070void _Qp_add(long double *c, long double *a, long double *b)
1071{
1072 *c = __addtf3(*a, *b);
1073}
1074
1075void _Qp_sub(long double *c, long double *a, long double *b)
1076{
1077 *c = __subtf3(*a, *b);
1078}
1079
1080void _Qp_mul(long double *c, long double *a, long double *b)
1081{
1082 *c = __multf3(*a, *b);
1083}
1084
1085void _Qp_div(long double *c, long double *a, long double *b)
1086{
1087 *c = __divtf3(*a, *b);
1088}
1089
1090void _Qp_neg(long double *c, long double *a)
1091{
1092 *c = __negtf2(*a);
1093}
1094
1095void _Qp_stoq(long double *c, float a)
1096{
1097 *c = __extendsftf2(a);
1098}
1099
1100void _Qp_dtoq(long double *c, double a)
1101{
1102 *c = __extenddftf2(a);
1103}
1104
1105float _Qp_qtos(long double *a)
1106{
1107 return __trunctfsf2(*a);
1108}
1109
1110double _Qp_qtod(long double *a)
1111{
1112 return __trunctfdf2(*a);
1113}
1114
1115int _Qp_qtoi(long double *a)
1116{
1117 return __fixtfsi(*a);
1118}
1119
1120unsigned int _Qp_qtoui(long double *a)
1121{
1122 return __fixunstfsi(*a);
1123}
1124
1125long _Qp_qtox(long double *a)
1126{
1127 return __fixtfdi(*a);
1128}
1129
1130unsigned long _Qp_qtoux(long double *a)
1131{
1132 return __fixunstfdi(*a);
1133}
1134
1135void _Qp_itoq(long double *c, int a)
1136{
1137 *c = __floatsitf(a);
1138}
1139
1140void _Qp_uitoq(long double *c, unsigned int a)
1141{
1142 *c = __floatunsitf(a);
1143}
1144
1145void _Qp_xtoq(long double *c, long a)
1146{
1147 *c = __floatditf(a);
1148}
1149
1150void _Qp_uxtoq(long double *c, unsigned long a)
1151{
1152 *c = __floatunditf(a);
1153}
1154
1155int _Qp_cmp(long double *a, long double *b)
1156{
1157 long_double_t ta;
1158 long_double_t tb;
1159
1160 ta.val = *a;
1161 tb.val = *b;
1162
1163 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1164 return 3;
1165
1166 if (is_long_double_eq(ta.data, tb.data))
1167 return 0;
1168
1169 if (is_long_double_lt(ta.data, tb.data))
1170 return 1;
1171
1172 return 2;
1173}
1174
1175int _Qp_cmpe(long double *a, long double *b)
1176{
1177 /* strange, but is defined this way in SPARC Compliance Definition */
1178 return _Qp_cmp(a, b);
1179}
1180
1181int _Qp_feq(long double *a, long double *b)
1182{
1183 long_double_t ta;
1184 long_double_t tb;
1185
1186 ta.val = *a;
1187 tb.val = *b;
1188
1189 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1190 return 0;
1191
1192 return is_long_double_eq(ta.data, tb.data);
1193}
1194
1195int _Qp_fge(long double *a, long double *b)
1196{
1197 long_double_t ta;
1198 long_double_t tb;
1199
1200 ta.val = *a;
1201 tb.val = *b;
1202
1203 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1204 return 0;
1205
1206 return is_long_double_eq(ta.data, tb.data) ||
1207 is_long_double_gt(ta.data, tb.data);
1208}
1209
1210int _Qp_fgt(long double *a, long double *b)
1211{
1212 long_double_t ta;
1213 long_double_t tb;
1214
1215 ta.val = *a;
1216 tb.val = *b;
1217
1218 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1219 return 0;
1220
1221 return is_long_double_gt(ta.data, tb.data);
1222}
1223
1224int _Qp_fle(long double*a, long double *b)
1225{
1226 long_double_t ta;
1227 long_double_t tb;
1228
1229 ta.val = *a;
1230 tb.val = *b;
1231
1232 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1233 return 0;
1234
1235 return is_long_double_eq(ta.data, tb.data) ||
1236 is_long_double_lt(ta.data, tb.data);
1237}
1238
1239int _Qp_flt(long double *a, long double *b)
1240{
1241 long_double_t ta;
1242 long_double_t tb;
1243
1244 ta.val = *a;
1245 tb.val = *b;
1246
1247 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1248 return 0;
1249
1250 return is_long_double_lt(ta.data, tb.data);
1251}
1252
1253int _Qp_fne(long double *a, long double *b)
1254{
1255 long_double_t ta;
1256 long_double_t tb;
1257
1258 ta.val = *a;
1259 tb.val = *b;
1260
1261 if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data)))
1262 return 0;
1263
1264 return !is_long_double_eq(ta.data, tb.data);
1265}
1266
1267double __aeabi_i2d(int i)
1268{
1269 return __floatsidf(i);
1270}
1271
1272double __aeabi_ui2d(unsigned int i)
1273{
1274 return __floatunsidf(i);
1275}
1276
1277int __aeabi_f2iz(float a)
1278{
1279 return __fixsfsi(a);
1280}
1281
1282int __aeabi_d2iz(double a)
1283{
1284 return __fixdfsi(a);
1285}
1286
1287unsigned int __aeabi_d2uiz(double a)
1288{
1289 return __fixunsdfsi(a);
1290}
1291
1292int __aeabi_dcmpge(double a, double b)
1293{
1294 return __gedf2(a, b);
1295}
1296
1297int __aeabi_dcmpgt(double a, double b)
1298{
1299 return __gtdf2(a, b);
1300}
1301
1302int __aeabi_dcmplt(double a, double b)
1303{
1304 return __ltdf2(a, b);
1305}
1306
1307int __aeabi_dcmpeq(double a, double b)
1308{
1309 return __eqdf2(a, b);
1310}
1311
1312float __aeabi_fadd(float a, float b)
1313{
1314 return __addsf3(a, b);
1315}
1316
1317float __aeabi_fsub(float a, float b)
1318{
1319 return __subsf3(a, b);
1320}
1321
1322float __aeabi_fmul(float a, float b)
1323{
1324 return __mulsf3(a, b);
1325}
1326
1327float __aeabi_fdiv(float a, float b)
1328{
1329 return __divsf3(a, b);
1330}
1331
1332double __aeabi_dadd(double a, double b)
1333{
1334 return __adddf3(a, b);
1335}
1336
1337double __aeabi_dsub(double a, double b)
1338{
1339 return __subdf3(a, b);
1340}
1341
1342double __aeabi_dmul(double a, double b)
1343{
1344 return __muldf3(a, b);
1345}
1346
1347double __aeabi_ddiv(double a, double b)
1348{
1349 return __divdf3(a, b);
1350}
1351
1352/** @}
1353 */
Note: See TracBrowser for help on using the repository browser.