Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/softfloat/generic/softfloat.c

    r750636a rc67aff2  
    11/*
    22 * Copyright (c) 2005 Josef Cejka
     3 * Copyright (c) 2011 Petr Koupy
    34 * All rights reserved.
    45 *
     
    3233 * @{
    3334 */
    34 /** @file
     35/** @file Softfloat API.
    3536 */
    3637
     
    8384}
    8485
     86long 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;
     100}
     101
    85102float __subsf3(float a, float b)
    86103{
     
    107124}
    108125
     126long 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
    109138float __mulsf3(float a, float b)
    110139{
     
    123152}
    124153
     154long 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
    125162float __divsf3(float a, float b)
    126163{
     
    139176}
    140177
     178long 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
    141186float __negsf2(float a)
    142187{
     
    149194double __negdf2(double a)
    150195{
    151         float64 fa;
    152         fa.d = a;
    153         fa.parts.sign = !fa.parts.sign;
    154         return fa.d;
     196        float64 da;
     197        da.d = a;
     198        da.parts.sign = !da.parts.sign;
     199        return da.d;
     200}
     201
     202long double __negtf2(long double a)
     203{
     204        float128 ta;
     205        ta.ld = a;
     206        ta.parts.sign = !ta.parts.sign;
     207        return ta.ld;
    155208}
    156209
     
    164217}
    165218
     219long double __extendsftf2(float a)
     220{
     221        float32 fa;
     222        fa.f = a;
     223        return convertFloat32ToFloat128(fa).ld;
     224}
     225
     226long double __extenddftf2(double a)
     227{
     228        float64 da;
     229        da.d = a;
     230        return convertFloat64ToFloat128(da).ld;
     231}
     232
    166233float __truncdfsf2(double a)
    167234{
     
    171238}
    172239
     240float __trunctfsf2(long double a)
     241{
     242        float128 ta;
     243        ta.ld = a;
     244        return convertFloat128ToFloat32(ta).f;
     245}
     246
     247double __trunctfdf2(long double a)
     248{
     249        float128 ta;
     250        ta.ld = a;
     251        return convertFloat128ToFloat64(ta).d;
     252}
     253
    173254int __fixsfsi(float a)
    174255{
     
    178259        return float32_to_int(fa);
    179260}
     261
    180262int __fixdfsi(double a)
    181263{
     
    184266       
    185267        return float64_to_int(da);
     268}
     269
     270int __fixtfsi(long double a)
     271{
     272        float128 ta;
     273        ta.ld = a;
     274
     275        return float128_to_int(ta);
    186276}
    187277 
     
    193283        return float32_to_long(fa);
    194284}
     285
    195286long __fixdfdi(double a)
    196287{
     
    199290       
    200291        return float64_to_long(da);
     292}
     293
     294long __fixtfdi(long double a)
     295{
     296        float128 ta;
     297        ta.ld = a;
     298
     299        return float128_to_long(ta);
    201300}
    202301 
     
    208307        return float32_to_longlong(fa);
    209308}
     309
    210310long long __fixdfti(double a)
    211311{
     
    216316}
    217317
     318long long __fixtfti(long double a)
     319{
     320        float128 ta;
     321        ta.ld = a;
     322
     323        return float128_to_longlong(ta);
     324}
     325
    218326unsigned int __fixunssfsi(float a)
    219327{
     
    223331        return float32_to_uint(fa);
    224332}
     333
    225334unsigned int __fixunsdfsi(double a)
    226335{
     
    229338       
    230339        return float64_to_uint(da);
     340}
     341
     342unsigned int __fixunstfsi(long double a)
     343{
     344        float128 ta;
     345        ta.ld = a;
     346
     347        return float128_to_uint(ta);
    231348}
    232349 
     
    238355        return float32_to_ulong(fa);
    239356}
     357
    240358unsigned long __fixunsdfdi(double a)
    241359{
     
    244362       
    245363        return float64_to_ulong(da);
     364}
     365
     366unsigned long __fixunstfdi(long double a)
     367{
     368        float128 ta;
     369        ta.ld = a;
     370
     371        return float128_to_ulong(ta);
    246372}
    247373 
     
    253379        return float32_to_ulonglong(fa);
    254380}
     381
    255382unsigned long long __fixunsdfti(double a)
    256383{
     
    259386       
    260387        return float64_to_ulonglong(da);
     388}
     389
     390unsigned long long __fixunstfti(long double a)
     391{
     392        float128 ta;
     393        ta.ld = a;
     394
     395        return float128_to_ulonglong(ta);
    261396}
    262397 
     
    268403        return fa.f;
    269404}
     405
    270406double __floatsidf(int i)
    271407{
     
    275411        return da.d;
    276412}
     413
     414long double __floatsitf(int i)
     415{
     416        float128 ta;
     417
     418        ta = int_to_float128(i);
     419        return ta.ld;
     420}
    277421 
    278422float __floatdisf(long i)
     
    283427        return fa.f;
    284428}
     429
    285430double __floatdidf(long i)
    286431{
     
    290435        return da.d;
    291436}
     437
     438long double __floatditf(long i)
     439{
     440        float128 ta;
     441
     442        ta = long_to_float128(i);
     443        return ta.ld;
     444}
    292445 
    293446float __floattisf(long long i)
     
    298451        return fa.f;
    299452}
     453
    300454double __floattidf(long long i)
    301455{
     
    306460}
    307461
     462long double __floattitf(long long i)
     463{
     464        float128 ta;
     465
     466        ta = longlong_to_float128(i);
     467        return ta.ld;
     468}
     469
    308470float __floatunsisf(unsigned int i)
    309471{
     
    313475        return fa.f;
    314476}
     477
    315478double __floatunsidf(unsigned int i)
    316479{
     
    320483        return da.d;
    321484}
     485
     486long double __floatunsitf(unsigned int i)
     487{
     488        float128 ta;
     489
     490        ta = uint_to_float128(i);
     491        return ta.ld;
     492}
    322493 
    323494float __floatundisf(unsigned long i)
     
    328499        return fa.f;
    329500}
     501
    330502double __floatundidf(unsigned long i)
    331503{
     
    335507        return da.d;
    336508}
     509
     510long double __floatunditf(unsigned long i)
     511{
     512        float128 ta;
     513
     514        ta = ulong_to_float128(i);
     515        return ta.ld;
     516}
    337517 
    338518float __floatuntisf(unsigned long long i)
     
    343523        return fa.f;
    344524}
     525
    345526double __floatuntidf(unsigned long long i)
    346527{
     
    351532}
    352533
     534long double __floatuntitf(unsigned long long i)
     535{
     536        float128 ta;
     537
     538        ta = ulonglong_to_float128(i);
     539        return ta.ld;
     540}
     541
    353542/* Comparison functions */
    354 /* Comparison functions */
    355 
    356 /* a<b .. -1
    357  * a=b ..  0
    358  * a>b ..  1
    359  * */
    360543
    361544int __cmpsf2(float a, float b)
     
    364547        fa.f = a;
    365548        fb.f = b;
    366         if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
     549
     550        if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    367551                return 1; /* no special constant for unordered - maybe signaled? */
    368         };
    369 
     552        }
    370553       
    371554        if (isFloat32eq(fa, fb)) {
    372555                return 0;
    373         };
     556        }
    374557       
    375558        if (isFloat32lt(fa, fb)) {
    376559                return -1;
    377                 };
     560        }
     561
    378562        return 1;
    379563}
    380564
     565int __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)) {
     580                return -1;
     581        }
     582
     583        return 1;
     584}
     585
     586int __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
    381607int __unordsf2(float a, float b)
    382608{
     
    384610        fa.f = a;
    385611        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  * */
     612        return ((isFloat32NaN(fa)) || (isFloat32NaN(fb)));
     613}
     614
     615int __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
     623int __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
    392631int __eqsf2(float a, float b)
    393632{
     
    395634        fa.f = a;
    396635        fb.f = b;
    397         if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    398                 /* TODO: sigNaNs*/
    399                 return 1;
    400                 };
     636        if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
     637                /* TODO: sigNaNs */
     638                return 1;
     639        }
    401640        return isFloat32eq(fa, fb) - 1;
    402641}
    403642
    404 /* strange behavior, but it was in gcc documentation */
     643int __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
     655int __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
    405667int __nesf2(float a, float b)
    406668{
     669        /* strange behavior, but it was in gcc documentation */
    407670        return __eqsf2(a, b);
    408671}
    409672
    410 /* return value >= 0 if a>=b and neither is NaN */
     673int __nedf2(double a, double b)
     674{
     675        /* strange behavior, but it was in gcc documentation */
     676        return __eqdf2(a, b);
     677}
     678
     679int __netf2(long double a, long double b)
     680{
     681        /* strange behavior, but it was in gcc documentation */
     682        return __eqtf2(a, b);
     683}
     684
    411685int __gesf2(float a, float b)
    412686{
     
    414688        fa.f = a;
    415689        fb.f = b;
    416         if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    417                 /* TODO: sigNaNs*/
    418                 return -1;
    419                 };
     690
     691        if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
     692                /* TODO: sigNaNs */
     693                return -1;
     694        }
    420695       
    421696        if (isFloat32eq(fa, fb)) {
    422697                return 0;
    423         };
     698        }
    424699       
    425700        if (isFloat32gt(fa, fb)) {
    426701                return 1;
    427                 };
     702        }
    428703       
    429704        return -1;
    430705}
    431706
    432 /** Return negative value, if a<b and neither is NaN*/
     707int __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)) {
     723                return 1;
     724        }
     725
     726        return -1;
     727}
     728
     729int __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
    433751int __ltsf2(float a, float b)
    434752{
     
    436754        fa.f = a;
    437755        fb.f = b;
    438         if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    439                 /* TODO: sigNaNs*/
    440                 return 1;
    441                 };
     756
     757        if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
     758                /* TODO: sigNaNs */
     759                return 1;
     760        }
     761
    442762        if (isFloat32lt(fa, fb)) {
    443763                return -1;
    444                 };
     764        }
     765
    445766        return 0;
    446767}
    447768
    448 /* return value <= 0 if a<=b and neither is NaN */
     769int __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 */
     777                return 1;
     778        }
     779
     780        if (isFloat64lt(da, db)) {
     781                return -1;
     782        }
     783
     784        return 0;
     785}
     786
     787int __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
    449805int __lesf2(float a, float b)
    450806{
     
    452808        fa.f = a;
    453809        fb.f = b;
    454         if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    455                 /* TODO: sigNaNs*/
    456                 return 1;
    457                 };
     810
     811        if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
     812                /* TODO: sigNaNs */
     813                return 1;
     814        }
    458815       
    459816        if (isFloat32eq(fa, fb)) {
    460817                return 0;
    461         };
     818        }
    462819       
    463820        if (isFloat32lt(fa, fb)) {
    464821                return -1;
    465                 };
     822        }
    466823       
    467824        return 1;
    468825}
    469826
    470 /** Return positive value, if a>b and neither is NaN*/
     827int __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)) {
     843                return -1;
     844        }
     845
     846        return 1;
     847}
     848
     849int __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
    471871int __gtsf2(float a, float b)
    472872{
     
    474874        fa.f = a;
    475875        fb.f = b;
    476         if ( (isFloat32NaN(fa)) || (isFloat32NaN(fb)) ) {
    477                 /* TODO: sigNaNs*/
    478                 return -1;
    479                 };
     876
     877        if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
     878                /* TODO: sigNaNs */
     879                return -1;
     880        }
     881
    480882        if (isFloat32gt(fa, fb)) {
    481883                return 1;
    482                 };
     884        }
     885
    483886        return 0;
    484887}
    485888
    486 /* Other functions */
    487 
    488 float __powisf2(float a, int b)
    489 {
    490 /* TODO: */
    491         float32 fa;
    492         fa.binary = FLOAT32_NAN;
    493         return fa.f;
    494 }
     889int __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
     907int __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
     931void _Qp_add(long double *c, long double *a, long double *b)
     932{
     933        *c = __addtf3(*a, *b);
     934}
     935
     936void _Qp_sub(long double *c, long double *a, long double *b)
     937{
     938        *c = __subtf3(*a, *b);
     939}
     940
     941void _Qp_mul(long double *c, long double *a, long double *b)
     942{
     943        *c = __multf3(*a, *b);
     944}
     945
     946void _Qp_div(long double *c, long double *a, long double *b)
     947{
     948        *c = __divtf3(*a, *b);
     949}
     950
     951void _Qp_neg(long double *c, long double *a)
     952{
     953        *c = __negtf2(*a);
     954}
     955
     956void _Qp_stoq(long double *c, float a)
     957{
     958        *c = __extendsftf2(a);
     959}
     960
     961void _Qp_dtoq(long double *c, double a)
     962{
     963        *c = __extenddftf2(a);
     964}
     965
     966float _Qp_qtos(long double *a)
     967{
     968        return __trunctfsf2(*a);
     969}
     970
     971double _Qp_qtod(long double *a)
     972{
     973        return __trunctfdf2(*a);
     974}
     975
     976int _Qp_qtoi(long double *a)
     977{
     978        return __fixtfsi(*a);
     979}
     980
     981unsigned int _Qp_qtoui(long double *a)
     982{
     983        return __fixunstfsi(*a);
     984}
     985
     986long _Qp_qtox(long double *a)
     987{
     988        return __fixtfdi(*a);
     989}
     990
     991unsigned long _Qp_qtoux(long double *a)
     992{
     993        return __fixunstfdi(*a);
     994}
     995
     996void _Qp_itoq(long double *c, int a)
     997{
     998        *c = __floatsitf(a);
     999}
     1000
     1001void _Qp_uitoq(long double *c, unsigned int a)
     1002{
     1003        *c = __floatunsitf(a);
     1004}
     1005
     1006void _Qp_xtoq(long double *c, long a)
     1007{
     1008        *c = __floatditf(a);
     1009}
     1010
     1011void _Qp_uxtoq(long double *c, unsigned long a)
     1012{
     1013        *c = __floatunditf(a);
     1014}
     1015
     1016int _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
     1037int _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
     1043int _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
     1056int _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
     1069int _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
     1082int _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
     1095int _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
     1108int _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
    4951122
    4961123/** @}
Note: See TracChangeset for help on using the changeset viewer.