Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/generic/softfloat.c

    rc67aff2 r750636a  
    11/*
    22 * Copyright (c) 2005 Josef Cejka
    3  * Copyright (c) 2011 Petr Koupy
    43 * All rights reserved.
    54 *
    … …  
    3332 * @{
    3433 */
    35 /** @file Softfloat API.
     34/** @file
    3635 */
    3736
    … …  
    8281        }
    8382        return addFloat64(da, db).d;
    84 }
    85 
    86 long double __addtf3(long double a, long double b)
    87 {
    88         float128 ta, tb;
    89         ta.ld = a;
    90         tb.ld = b;
    91         if (ta.parts.sign != tb.parts.sign) {
    92                 if (ta.parts.sign) {
    93                         ta.parts.sign = 0;
    94                         return subFloat128(tb, ta).ld;
    95                 };
    96                 tb.parts.sign = 0;
    97                 return subFloat128(ta, tb).ld;
    98         }
    99         return addFloat128(ta, tb).ld;
    10083}
    10184
    … …  
    124107}
    125108
    126 long double __subtf3(long double a, long double b)
    127 {
    128         float128 ta, tb;
    129         ta.ld = a;
    130         tb.ld = b;
    131         if (ta.parts.sign != tb.parts.sign) {
    132                 tb.parts.sign = !tb.parts.sign;
    133                 return addFloat128(ta, tb).ld;
    134         }
    135         return subFloat128(ta, tb).ld;
    136 }
    137 
    138109float __mulsf3(float a, float b)
    139110{
    … …  
    152123}
    153124
    154 long double __multf3(long double a, long double b)
    155 {
    156         float128 ta, tb;
    157         ta.ld = a;
    158         tb.ld = b;
    159         return  mulFloat128(ta, tb).ld;
    160 }
    161 
    162125float __divsf3(float a, float b)
    163126{
    … …  
    176139}
    177140
    178 long double __divtf3(long double a, long double b)
    179 {
    180         float128 ta, tb;
    181         ta.ld = a;
    182         tb.ld = b;
    183         return  divFloat128(ta, tb).ld;
    184 }
    185 
    186141float __negsf2(float a)
    187142{
    … …  
    194149double __negdf2(double a)
    195150{
    196         float64 da;
    197         da.d = a;
    198         da.parts.sign = !da.parts.sign;
    199         return da.d;
    200 }
    201 
    202 long double __negtf2(long double a)
    203 {
    204         float128 ta;
    205         ta.ld = a;
    206         ta.parts.sign = !ta.parts.sign;
    207         return ta.ld;
     151        float64 fa;
     152        fa.d = a;
     153        fa.parts.sign = !fa.parts.sign;
     154        return fa.d;
    208155}
    209156
    … …  
    217164}
    218165
    219 long double __extendsftf2(float a)
    220 {
    221         float32 fa;
    222         fa.f = a;
    223         return convertFloat32ToFloat128(fa).ld;
    224 }
    225 
    226 long double __extenddftf2(double a)
    227 {
    228         float64 da;
    229         da.d = a;
    230         return convertFloat64ToFloat128(da).ld;
    231 }
    232 
    233166float __truncdfsf2(double a)
    234167{
    … …  
    238171}
    239172
    240 float __trunctfsf2(long double a)
    241 {
    242         float128 ta;
    243         ta.ld = a;
    244         return convertFloat128ToFloat32(ta).f;
    245 }
    246 
    247 double __trunctfdf2(long double a)
    248 {
    249         float128 ta;
    250         ta.ld = a;
    251         return convertFloat128ToFloat64(ta).d;
    252 }
    253 
    254173int __fixsfsi(float a)
    255174{
    … …  
    259178        return float32_to_int(fa);
    260179}
    261 
    262180int __fixdfsi(double a)
    263181{
    … …  
    267185        return float64_to_int(da);
    268186}
    269 
    270 int __fixtfsi(long double a)
    271 {
    272         float128 ta;
    273         ta.ld = a;
    274 
    275         return float128_to_int(ta);
    276 }
    277187 
    278188long __fixsfdi(float a)
    … …  
    283193        return float32_to_long(fa);
    284194}
    285 
    286195long __fixdfdi(double a)
    287196{
    … …  
    291200        return float64_to_long(da);
    292201}
    293 
    294 long __fixtfdi(long double a)
    295 {
    296         float128 ta;
    297         ta.ld = a;
    298 
    299         return float128_to_long(ta);
    300 }
    301202 
    302203long long __fixsfti(float a)
    … …  
    307208        return float32_to_longlong(fa);
    308209}
    309 
    310210long long __fixdfti(double a)
    311211{
    … …  
    316216}
    317217
    318 long long __fixtfti(long double a)
    319 {
    320         float128 ta;
    321         ta.ld = a;
    322 
    323         return float128_to_longlong(ta);
    324 }
    325 
    326218unsigned int __fixunssfsi(float a)
    327219{
    … …  
    331223        return float32_to_uint(fa);
    332224}
    333 
    334225unsigned int __fixunsdfsi(double a)
    335226{
    … …  
    339230        return float64_to_uint(da);
    340231}
    341 
    342 unsigned int __fixunstfsi(long double a)
    343 {
    344         float128 ta;
    345         ta.ld = a;
    346 
    347         return float128_to_uint(ta);
    348 }
    349232 
    350233unsigned long __fixunssfdi(float a)
    … …  
    355238        return float32_to_ulong(fa);
    356239}
    357 
    358240unsigned long __fixunsdfdi(double a)
    359241{
    … …  
    363245        return float64_to_ulong(da);
    364246}
    365 
    366 unsigned long __fixunstfdi(long double a)
    367 {
    368         float128 ta;
    369         ta.ld = a;
    370 
    371         return float128_to_ulong(ta);
    372 }
    373247 
    374248unsigned long long __fixunssfti(float a)
    … …  
    379253        return float32_to_ulonglong(fa);
    380254}
    381 
    382255unsigned long long __fixunsdfti(double a)
    383256{
    … …  
    387260        return float64_to_ulonglong(da);
    388261}
    389 
    390 unsigned long long __fixunstfti(long double a)
    391 {
    392         float128 ta;
    393         ta.ld = a;
    394 
    395         return float128_to_ulonglong(ta);
    396 }
    397262 
    398263float __floatsisf(int i)
    … …  
    403268        return fa.f;
    404269}
    405 
    406270double __floatsidf(int i)
    407271{
    … …  
    411275        return da.d;
    412276}
    413 
    414 long double __floatsitf(int i)
    415 {
    416         float128 ta;
    417 
    418         ta = int_to_float128(i);
    419         return ta.ld;
    420 }
    421277 
    422278float __floatdisf(long i)
    … …  
    427283        return fa.f;
    428284}
    429 
    430285double __floatdidf(long i)
    431286{
    … …  
    435290        return da.d;
    436291}
    437 
    438 long double __floatditf(long i)
    439 {
    440         float128 ta;
    441 
    442         ta = long_to_float128(i);
    443         return ta.ld;
    444 }
    445292 
    446293float __floattisf(long long i)
    … …  
    451298        return fa.f;
    452299}
    453 
    454300double __floattidf(long long i)
    455301{
    … …  
    460306}
    461307
    462 long double __floattitf(long long i)
    463 {
    464         float128 ta;
    465 
    466         ta = longlong_to_float128(i);
    467         return ta.ld;
    468 }
    469 
    470308float __floatunsisf(unsigned int i)
    471309{
    … …  
    475313        return fa.f;
    476314}
    477 
    478315double __floatunsidf(unsigned int i)
    479316{
    … …  
    483320        return da.d;
    484321}
    485 
    486 long double __floatunsitf(unsigned int i)
    487 {
    488         float128 ta;
    489 
    490         ta = uint_to_float128(i);
    491         return ta.ld;
    492 }
    493322 
    494323float __floatundisf(unsigned long i)
    … …  
    499328        return fa.f;
    500329}
    501 
    502330double __floatundidf(unsigned long i)
    503331{
    … …  
    507335        return da.d;
    508336}
    509 
    510 long double __floatunditf(unsigned long i)
    511 {
    512         float128 ta;
    513 
    514         ta = ulong_to_float128(i);
    515         return ta.ld;
    516 }
    517337 
    518338float __floatuntisf(unsigned long long i)
    … …  
    523343        return fa.f;
    524344}
    525 
    526345double __floatuntidf(unsigned long long i)
    527346{
    … …  
    532351}
    533352
    534 long double __floatuntitf(unsigned long long i)
    535 {
    536         float128 ta;
    537 
    538         ta = ulonglong_to_float128(i);
    539         return ta.ld;
    540 }
    541 
    542353/* Comparison functions */
     354/* Comparison functions */
     355
     356/* a<b .. -1
     357 * a=b ..  0
     358 * a>b ..  1
     359 * */
    543360
    544361int __cmpsf2(float a, float b)
    … …  
    547364        fa.f = a;
    548365        fb.f = b;
    549 
    550         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
     366        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    551367                return 1; /* no special constant for unordered - maybe signaled? */
    552         }
     368        };
     369
    553370       
    554371        if (isFloat32eq(fa, fb)) {
    555372                return 0;
    556         }
     373        };
    557374       
    558375        if (isFloat32lt(fa, fb)) {
    559376                return -1;
    560         }
    561 
     377                };
    562378        return 1;
    563379}
    564380
    565 int __cmpdf2(double a, double b)
    566 {
    567         float64 da, db;
    568         da.d = a;
    569         db.d = b;
    570 
    571         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    572                 return 1; /* no special constant for unordered - maybe signaled? */
    573         }
    574 
    575         if (isFloat64eq(da, db)) {
    576                 return 0;
    577         }
    578 
    579         if (isFloat64lt(da, db)) {
     381int __unordsf2(float a, float b)
     382{
     383        float32 fa, fb;
     384        fa.f = a;
     385        fb.f = b;
     386        return ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) );
     387}
     388
     389/**
     390 * @return zero, if neither argument is a NaN and are equal
     391 * */
     392int __eqsf2(float a, float b)
     393{
     394        float32 fa, fb;
     395        fa.f = a;
     396        fb.f = b;
     397        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     398                /* TODO: sigNaNs*/
     399                return 1;
     400                };
     401        return isFloat32eq(fa, fb) - 1;
     402}
     403
     404/* strange behavior, but it was in gcc documentation */
     405int __nesf2(float a, float b)
     406{
     407        return __eqsf2(a, b);
     408}
     409
     410/* return value >= 0 if a>=b and neither is NaN */
     411int __gesf2(float a, float b)
     412{
     413        float32 fa, fb;
     414        fa.f = a;
     415        fb.f = b;
     416        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     417                /* TODO: sigNaNs*/
    580418                return -1;
    581         }
    582 
    583         return 1;
    584 }
    585 
    586 int __cmptf2(long double a, long double b)
    587 {
    588         float128 ta, tb;
    589         ta.ld = a;
    590         tb.ld = b;
    591 
    592         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    593                 return 1; /* no special constant for unordered - maybe signaled? */
    594         }
    595 
    596         if (isFloat128eq(ta, tb)) {
    597                 return 0;
    598         }
    599 
    600         if (isFloat128lt(ta, tb)) {
    601                 return -1;
    602         }
    603 
    604         return 1;
    605 }
    606 
    607 int __unordsf2(float a, float b)
    608 {
    609         float32 fa, fb;
    610         fa.f = a;
    611         fb.f = b;
    612         return ((isFloat32NaN(fa)) || (isFloat32NaN(fb)));
    613 }
    614 
    615 int __unorddf2(double a, double b)
    616 {
    617         float64 da, db;
    618         da.d = a;
    619         db.d = b;
    620         return ((isFloat64NaN(da)) || (isFloat64NaN(db)));
    621 }
    622 
    623 int __unordtf2(long double a, long double b)
    624 {
    625         float128 ta, tb;
    626         ta.ld = a;
    627         tb.ld = b;
    628         return ((isFloat128NaN(ta)) || (isFloat128NaN(tb)));
    629 }
    630 
    631 int __eqsf2(float a, float b)
    632 {
    633         float32 fa, fb;
    634         fa.f = a;
    635         fb.f = b;
    636         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    637                 /* TODO: sigNaNs */
    638                 return 1;
    639         }
    640         return isFloat32eq(fa, fb) - 1;
    641 }
    642 
    643 int __eqdf2(double a, double b)
    644 {
    645         float64 da, db;
    646         da.d = a;
    647         db.d = b;
    648         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    649                 /* TODO: sigNaNs */
    650                 return 1;
    651         }
    652         return isFloat64eq(da, db) - 1;
    653 }
    654 
    655 int __eqtf2(long double a, long double b)
    656 {
    657         float128 ta, tb;
    658         ta.ld = a;
    659         tb.ld = b;
    660         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    661                 /* TODO: sigNaNs */
    662                 return 1;
    663         }
    664         return isFloat128eq(ta, tb) - 1;
    665 }
    666 
    667 int __nesf2(float a, float b)
    668 {
    669         /* strange behavior, but it was in gcc documentation */
    670         return __eqsf2(a, b);
    671 }
    672 
    673 int __nedf2(double a, double b)
    674 {
    675         /* strange behavior, but it was in gcc documentation */
    676         return __eqdf2(a, b);
    677 }
    678 
    679 int __netf2(long double a, long double b)
    680 {
    681         /* strange behavior, but it was in gcc documentation */
    682         return __eqtf2(a, b);
    683 }
    684 
    685 int __gesf2(float a, float b)
    686 {
    687         float32 fa, fb;
    688         fa.f = a;
    689         fb.f = b;
    690 
    691         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    692                 /* TODO: sigNaNs */
    693                 return -1;
    694         }
     419                };
    695420       
    696421        if (isFloat32eq(fa, fb)) {
    697422                return 0;
    698         }
     423        };
    699424       
    700425        if (isFloat32gt(fa, fb)) {
    701426                return 1;
    702         }
     427                };
    703428       
    704429        return -1;
    705430}
    706431
    707 int __gedf2(double a, double b)
    708 {
    709         float64 da, db;
    710         da.d = a;
    711         db.d = b;
    712 
    713         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    714                 /* TODO: sigNaNs */
    715                 return -1;
    716         }
    717 
    718         if (isFloat64eq(da, db)) {
    719                 return 0;
    720         }
    721 
    722         if (isFloat64gt(da, db)) {
     432/** Return negative value, if a<b and neither is NaN*/
     433int __ltsf2(float a, float b)
     434{
     435        float32 fa, fb;
     436        fa.f = a;
     437        fb.f = b;
     438        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     439                /* TODO: sigNaNs*/
    723440                return 1;
    724         }
    725 
    726         return -1;
    727 }
    728 
    729 int __getf2(long double a, long double b)
    730 {
    731         float128 ta, tb;
    732         ta.ld = a;
    733         tb.ld = b;
    734 
    735         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    736                 /* TODO: sigNaNs */
    737                 return -1;
    738         }
    739 
    740         if (isFloat128eq(ta, tb)) {
    741                 return 0;
    742         }
    743 
    744         if (isFloat128gt(ta, tb)) {
    745                 return 1;
    746         }
    747 
    748         return -1;
    749 }
    750 
    751 int __ltsf2(float a, float b)
    752 {
    753         float32 fa, fb;
    754         fa.f = a;
    755         fb.f = b;
    756 
    757         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    758                 /* TODO: sigNaNs */
    759                 return 1;
    760         }
    761 
     441                };
    762442        if (isFloat32lt(fa, fb)) {
    763443                return -1;
    764         }
    765 
     444                };
    766445        return 0;
    767446}
    768447
    769 int __ltdf2(double a, double b)
    770 {
    771         float64 da, db;
    772         da.d = a;
    773         db.d = b;
    774 
    775         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    776                 /* TODO: sigNaNs */
     448/* return value <= 0 if a<=b and neither is NaN */
     449int __lesf2(float a, float b)
     450{
     451        float32 fa, fb;
     452        fa.f = a;
     453        fb.f = b;
     454        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     455                /* TODO: sigNaNs*/
    777456                return 1;
    778         }
    779 
    780         if (isFloat64lt(da, db)) {
    781                 return -1;
    782         }
    783 
    784         return 0;
    785 }
    786 
    787 int __lttf2(long double a, long double b)
    788 {
    789         float128 ta, tb;
    790         ta.ld = a;
    791         tb.ld = b;
    792 
    793         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    794                 /* TODO: sigNaNs */
    795                 return 1;
    796         }
    797 
    798         if (isFloat128lt(ta, tb)) {
    799                 return -1;
    800         }
    801 
    802         return 0;
    803 }
    804 
    805 int __lesf2(float a, float b)
    806 {
    807         float32 fa, fb;
    808         fa.f = a;
    809         fb.f = b;
    810 
    811         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    812                 /* TODO: sigNaNs */
    813                 return 1;
    814         }
     457                };
    815458       
    816459        if (isFloat32eq(fa, fb)) {
    817460                return 0;
    818         }
     461        };
    819462       
    820463        if (isFloat32lt(fa, fb)) {
    821464                return -1;
    822         }
     465                };
    823466       
    824467        return 1;
    825468}
    826469
    827 int __ledf2(double a, double b)
    828 {
    829         float64 da, db;
    830         da.d = a;
    831         db.d = b;
    832 
    833         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    834                 /* TODO: sigNaNs */
    835                 return 1;
    836         }
    837 
    838         if (isFloat64eq(da, db)) {
    839                 return 0;
    840         }
    841 
    842         if (isFloat64lt(da, db)) {
     470/** Return positive value, if a>b and neither is NaN*/
     471int __gtsf2(float a, float b)
     472{
     473        float32 fa, fb;
     474        fa.f = a;
     475        fb.f = b;
     476        if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     477                /* TODO: sigNaNs*/
    843478                return -1;
    844         }
    845 
    846         return 1;
    847 }
    848 
    849 int __letf2(long double a, long double b)
    850 {
    851         float128 ta, tb;
    852         ta.ld = a;
    853         tb.ld = b;
    854 
    855         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    856                 /* TODO: sigNaNs */
    857                 return 1;
    858         }
    859 
    860         if (isFloat128eq(ta, tb)) {
    861                 return 0;
    862         }
    863 
    864         if (isFloat128lt(ta, tb)) {
    865                 return -1;
    866         }
    867 
    868         return 1;
    869 }
    870 
    871 int __gtsf2(float a, float b)
    872 {
    873         float32 fa, fb;
    874         fa.f = a;
    875         fb.f = b;
    876 
    877         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    878                 /* TODO: sigNaNs */
    879                 return -1;
    880         }
    881 
     479                };
    882480        if (isFloat32gt(fa, fb)) {
    883481                return 1;
    884         }
    885 
     482                };
    886483        return 0;
    887484}
    888485
    889 int __gtdf2(double a, double b)
    890 {
    891         float64 da, db;
    892         da.d = a;
    893         db.d = b;
    894 
    895         if ((isFloat64NaN(da)) || (isFloat64NaN(db))) {
    896                 /* TODO: sigNaNs */
    897                 return -1;
    898         }
    899 
    900         if (isFloat64gt(da, db)) {
    901                 return 1;
    902         }
    903 
    904         return 0;
    905 }
    906 
    907 int __gttf2(long double a, long double b)
    908 {
    909         float128 ta, tb;
    910         ta.ld = a;
    911         tb.ld = b;
    912 
    913         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    914                 /* TODO: sigNaNs */
    915                 return -1;
    916         }
    917 
    918         if (isFloat128gt(ta, tb)) {
    919                 return 1;
    920         }
    921 
    922         return 0;
    923 }
    924 
    925 
    926 
    927 #ifdef SPARC_SOFTFLOAT
    928 
    929 /* SPARC quadruple-precision wrappers */
    930 
    931 void _Qp_add(long double *c, long double *a, long double *b)
    932 {
    933         *c = __addtf3(*a, *b);
    934 }
    935 
    936 void _Qp_sub(long double *c, long double *a, long double *b)
    937 {
    938         *c = __subtf3(*a, *b);
    939 }
    940 
    941 void _Qp_mul(long double *c, long double *a, long double *b)
    942 {
    943         *c = __multf3(*a, *b);
    944 }
    945 
    946 void _Qp_div(long double *c, long double *a, long double *b)
    947 {
    948         *c = __divtf3(*a, *b);
    949 }
    950 
    951 void _Qp_neg(long double *c, long double *a)
    952 {
    953         *c = __negtf2(*a);
    954 }
    955 
    956 void _Qp_stoq(long double *c, float a)
    957 {
    958         *c = __extendsftf2(a);
    959 }
    960 
    961 void _Qp_dtoq(long double *c, double a)
    962 {
    963         *c = __extenddftf2(a);
    964 }
    965 
    966 float _Qp_qtos(long double *a)
    967 {
    968         return __trunctfsf2(*a);
    969 }
    970 
    971 double _Qp_qtod(long double *a)
    972 {
    973         return __trunctfdf2(*a);
    974 }
    975 
    976 int _Qp_qtoi(long double *a)
    977 {
    978         return __fixtfsi(*a);
    979 }
    980 
    981 unsigned int _Qp_qtoui(long double *a)
    982 {
    983         return __fixunstfsi(*a);
    984 }
    985 
    986 long _Qp_qtox(long double *a)
    987 {
    988         return __fixtfdi(*a);
    989 }
    990 
    991 unsigned long _Qp_qtoux(long double *a)
    992 {
    993         return __fixunstfdi(*a);
    994 }
    995 
    996 void _Qp_itoq(long double *c, int a)
    997 {
    998         *c = __floatsitf(a);
    999 }
    1000 
    1001 void _Qp_uitoq(long double *c, unsigned int a)
    1002 {
    1003         *c = __floatunsitf(a);
    1004 }
    1005 
    1006 void _Qp_xtoq(long double *c, long a)
    1007 {
    1008         *c = __floatditf(a);
    1009 }
    1010 
    1011 void _Qp_uxtoq(long double *c, unsigned long a)
    1012 {
    1013         *c = __floatunditf(a);
    1014 }
    1015 
    1016 int _Qp_cmp(long double *a, long double *b)
    1017 {
    1018         float128 ta, tb;
    1019         ta.ld = *a;
    1020         tb.ld = *b;
    1021 
    1022         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1023                 return 3;
    1024         }
    1025 
    1026         if (isFloat128eq(ta, tb)) {
    1027                 return 0;
    1028         }
    1029 
    1030         if (isFloat128lt(ta, tb)) {
    1031                 return 1;
    1032         }
    1033 
    1034         return 2;
    1035 }
    1036 
    1037 int _Qp_cmpe(long double *a, long double *b)
    1038 {
    1039         /* strange, but is defined this way in SPARC Compliance Definition */
    1040         return _Qp_cmp(a, b);
    1041 }
    1042 
    1043 int _Qp_feq(long double *a, long double *b)
    1044 {
    1045         float128 ta, tb;
    1046         ta.ld = *a;
    1047         tb.ld = *b;
    1048 
    1049         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1050                 return 0;
    1051         }
    1052 
    1053         return isFloat128eq(ta, tb);
    1054 }
    1055 
    1056 int _Qp_fge(long double *a, long double *b)
    1057 {
    1058         float128 ta, tb;
    1059         ta.ld = *a;
    1060         tb.ld = *b;
    1061 
    1062         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1063                 return 0;
    1064         }
    1065 
    1066         return isFloat128eq(ta, tb) || isFloat128gt(ta, tb);
    1067 }
    1068 
    1069 int _Qp_fgt(long double *a, long double *b)
    1070 {
    1071         float128 ta, tb;
    1072         ta.ld = *a;
    1073         tb.ld = *b;
    1074 
    1075         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1076                 return 0;
    1077         }
    1078 
    1079         return isFloat128gt(ta, tb);
    1080 }
    1081 
    1082 int _Qp_fle(long double*a, long double *b)
    1083 {
    1084         float128 ta, tb;
    1085         ta.ld = *a;
    1086         tb.ld = *b;
    1087 
    1088         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1089                 return 0;
    1090         }
    1091 
    1092         return isFloat128eq(ta, tb) || isFloat128lt(ta, tb);
    1093 }
    1094 
    1095 int _Qp_flt(long double *a, long double *b)
    1096 {
    1097         float128 ta, tb;
    1098         ta.ld = *a;
    1099         tb.ld = *b;
    1100 
    1101         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1102                 return 0;
    1103         }
    1104 
    1105         return isFloat128lt(ta, tb);
    1106 }
    1107 
    1108 int _Qp_fne(long double *a, long double *b)
    1109 {
    1110         float128 ta, tb;
    1111         ta.ld = *a;
    1112         tb.ld = *b;
    1113 
    1114         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    1115                 return 1;
    1116         }
    1117 
    1118         return !isFloat128eq(ta, tb);
    1119 }
    1120 
    1121 #endif
     486/* Other functions */
     487
     488float __powisf2(float a, int b)
     489{
     490/* TODO: */
     491        float32 fa;
     492        fa.binary = FLOAT32_NAN;
     493        return fa.f;
     494}
    1122495
    1123496/** @}
Note: See TracChangeset for help on using the changeset viewer.