source: mainline/uspace/lib/softfloat/generic/softfloat.c@ 2902e1bb

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

softfloat redesign

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