source: mainline/uspace/lib/softfloat/softfloat.c@ 101e3050

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

refactor floating point support

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