Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/softfloat/comparison.c

    r1b20da0 ra35b458  
    190190        uint64_t tmp_hi;
    191191        uint64_t tmp_lo;
    192        
     192
    193193        and128(ld.bin.hi, ld.bin.lo,
    194194            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    195        
     195
    196196        return eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    197197}
    … …  
    236236        uint64_t tmp_hi;
    237237        uint64_t tmp_lo;
    238        
     238
    239239        /* both are zeros (with any sign) */
    240240        or128(a.bin.hi, a.bin.lo,
    … …  
    243243            0x7FFFFFFFFFFFFFFFll, 0xFFFFFFFFFFFFFFFFll, &tmp_hi, &tmp_lo);
    244244        int both_zero = eq128(tmp_hi, tmp_lo, 0x0ll, 0x0ll);
    245        
     245
    246246        /* a equals to b */
    247247        int are_equal = eq128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    248        
     248
    249249        return are_equal || both_zero;
    250250}
    … …  
    263263                return 0;
    264264        }
    265        
     265
    266266        if ((a.parts.sign) && (b.parts.sign)) {
    267267                /* if both are negative, smaller is that with greater binary value */
    268268                return (a.bin > b.bin);
    269269        }
    270        
     270
    271271        /*
    272272         * lets negate signs - now will be positive numbers always
    … …  
    292292                return 0;
    293293        }
    294        
     294
    295295        if ((a.parts.sign) && (b.parts.sign)) {
    296296                /* if both are negative, smaller is that with greater binary value */
    297297                return (a.bin > b.bin);
    298298        }
    299        
     299
    300300        /*
    301301         * lets negate signs - now will be positive numbers always
    … …  
    319319        uint64_t tmp_hi;
    320320        uint64_t tmp_lo;
    321        
     321
    322322        or128(a.bin.hi, a.bin.lo,
    323323            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    … …  
    328328                return 0;
    329329        }
    330        
     330
    331331        if ((a.parts.sign) && (b.parts.sign)) {
    332332                /* if both are negative, smaller is that with greater binary value */
    333333                return lt128(b.bin.hi, b.bin.lo, a.bin.hi, a.bin.lo);
    334334        }
    335        
     335
    336336        /*
    337337         * lets negate signs - now will be positive numbers always
    … …  
    357357                return 0;
    358358        }
    359        
     359
    360360        if ((a.parts.sign) && (b.parts.sign)) {
    361361                /* if both are negative, greater is that with smaller binary value */
    362362                return (a.bin < b.bin);
    363363        }
    364        
     364
    365365        /*
    366366         * lets negate signs - now will be positive numbers always
    … …  
    386386                return 0;
    387387        }
    388        
     388
    389389        if ((a.parts.sign) && (b.parts.sign)) {
    390390                /* if both are negative, greater is that with smaller binary value */
    391391                return (a.bin < b.bin);
    392392        }
    393        
     393
    394394        /*
    395395         * lets negate signs - now will be positive numbers always
    … …  
    413413        uint64_t tmp_hi;
    414414        uint64_t tmp_lo;
    415        
     415
    416416        or128(a.bin.hi, a.bin.lo,
    417417            b.bin.hi, b.bin.lo, &tmp_hi, &tmp_lo);
    … …  
    422422                return 0;
    423423        }
    424        
     424
    425425        if ((a.parts.sign) && (b.parts.sign)) {
    426426                /* if both are negative, greater is that with smaller binary value */
    427427                return lt128(a.bin.hi, a.bin.lo, b.bin.hi, b.bin.lo);
    428428        }
    429        
     429
    430430        /*
    431431         * lets negate signs - now will be positive numbers always
    … …  
    444444        float32_u ua;
    445445        ua.val = a;
    446        
     446
    447447        float32_u ub;
    448448        ub.val = b;
    449        
     449
    450450        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    451451                // TODO: sigNaNs
    452452                return -1;
    453453        }
    454        
     454
    455455        if (is_float32_gt(ua.data, ub.data))
    456456                return 1;
    457        
     457
    458458        return 0;
    459459}
    … …  
    463463        float32_u ua;
    464464        ua.val = a;
    465        
     465
    466466        float32_u ub;
    467467        ub.val = b;
    468        
     468
    469469        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    470470                // TODO: sigNaNs
    471471                return -1;
    472472        }
    473        
     473
    474474        if (is_float32_eq(ua.data, ub.data))
    475475                return 0;
    476        
     476
    477477        if (is_float32_gt(ua.data, ub.data))
    478478                return 1;
    479        
     479
    480480        return -1;
    481481}
    … …  
    485485        float32_u ua;
    486486        ua.val = a;
    487        
     487
    488488        float32_u ub;
    489489        ub.val = b;
    490        
     490
    491491        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    492492                // TODO: sigNaNs
    493493                return 1;
    494494        }
    495        
     495
    496496        if (is_float32_lt(ua.data, ub.data))
    497497                return -1;
    498        
     498
    499499        return 0;
    500500}
    … …  
    504504        float32_u ua;
    505505        ua.val = a;
    506        
     506
    507507        float32_u ub;
    508508        ub.val = b;
    509        
     509
    510510        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    511511                // TODO: sigNaNs
    512512                return 1;
    513513        }
    514        
     514
    515515        if (is_float32_eq(ua.data, ub.data))
    516516                return 0;
    517        
     517
    518518        if (is_float32_lt(ua.data, ub.data))
    519519                return -1;
    520        
     520
    521521        return 1;
    522522}
    … …  
    526526        float32_u ua;
    527527        ua.val = a;
    528        
     528
    529529        float32_u ub;
    530530        ub.val = b;
    531        
     531
    532532        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    533533                // TODO: sigNaNs
    534534                return 1;
    535535        }
    536        
     536
    537537        return is_float32_eq(ua.data, ub.data) - 1;
    538538}
    … …  
    548548        float32_u ua;
    549549        ua.val = a;
    550        
     550
    551551        float32_u ub;
    552552        ub.val = b;
    553        
     553
    554554        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    555555                /* No special constant for unordered - maybe signaled? */
    556556                return 1;
    557557        }
    558        
     558
    559559        if (is_float32_eq(ua.data, ub.data))
    560560                return 0;
    561        
     561
    562562        if (is_float32_lt(ua.data, ub.data))
    563563                return -1;
    564        
     564
    565565        return 1;
    566566}
    … …  
    570570        float32_u ua;
    571571        ua.val = a;
    572        
     572
    573573        float32_u ub;
    574574        ub.val = b;
    575        
     575
    576576        return ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data)));
    577577}
    … …  
    581581        float32_u ua;
    582582        ua.val = a;
    583        
     583
    584584        float32_u ub;
    585585        ub.val = b;
    586        
     586
    587587        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    588588                // TODO: sigNaNs
    589589                return -1;
    590590        }
    591        
     591
    592592        if (is_float32_gt(ua.data, ub.data))
    593593                return 1;
    594        
     594
    595595        return 0;
    596596}
    … …  
    600600        float32_u ua;
    601601        ua.val = a;
    602        
     602
    603603        float32_u ub;
    604604        ub.val = b;
    605        
     605
    606606        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    607607                // TODO: sigNaNs
    608608                return 1;
    609609        }
    610        
     610
    611611        if (is_float32_lt(ua.data, ub.data))
    612612                return -1;
    613        
     613
    614614        return 0;
    615615}
    … …  
    619619        float32_u ua;
    620620        ua.val = a;
    621        
     621
    622622        float32_u ub;
    623623        ub.val = b;
    624        
     624
    625625        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    626626                // TODO: sigNaNs
    627627                return -1;
    628628        }
    629        
     629
    630630        if (is_float32_eq(ua.data, ub.data))
    631631                return 0;
    632        
     632
    633633        if (is_float32_gt(ua.data, ub.data))
    634634                return 1;
    635        
     635
    636636        return -1;
    637637}
    … …  
    641641        float32_u ua;
    642642        ua.val = a;
    643        
     643
    644644        float32_u ub;
    645645        ub.val = b;
    646        
     646
    647647        if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) {
    648648                // TODO: sigNaNs
    649649                return 1;
    650650        }
    651        
     651
    652652        return is_float32_eq(ua.data, ub.data) - 1;
    653653}
    … …  
    661661        float64_u ua;
    662662        ua.val = a;
    663        
     663
    664664        float64_u ub;
    665665        ub.val = b;
    666        
     666
    667667        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    668668                // TODO: sigNaNs
    669669                return -1;
    670670        }
    671        
     671
    672672        if (is_float64_gt(ua.data, ub.data))
    673673                return 1;
    674        
     674
    675675        return 0;
    676676}
    … …  
    680680        float64_u ua;
    681681        ua.val = a;
    682        
     682
    683683        float64_u ub;
    684684        ub.val = b;
    685        
     685
    686686        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    687687                // TODO: sigNaNs
    688688                return -1;
    689689        }
    690        
     690
    691691        if (is_float64_eq(ua.data, ub.data))
    692692                return 0;
    693        
     693
    694694        if (is_float64_gt(ua.data, ub.data))
    695695                return 1;
    696        
     696
    697697        return -1;
    698698}
    … …  
    702702        float64_u ua;
    703703        ua.val = a;
    704        
     704
    705705        float64_u ub;
    706706        ub.val = b;
    707        
     707
    708708        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    709709                // TODO: sigNaNs
    710710                return 1;
    711711        }
    712        
     712
    713713        if (is_float64_lt(ua.data, ub.data))
    714714                return -1;
    715        
     715
    716716        return 0;
    717717}
    … …  
    721721        float64_u ua;
    722722        ua.val = a;
    723        
     723
    724724        float64_u ub;
    725725        ub.val = b;
    726        
     726
    727727        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    728728                // TODO: sigNaNs
    729729                return 1;
    730730        }
    731        
     731
    732732        if (is_float64_eq(ua.data, ub.data))
    733733                return 0;
    734        
     734
    735735        if (is_float64_lt(ua.data, ub.data))
    736736                return -1;
    737        
     737
    738738        return 1;
    739739}
    … …  
    743743        float64_u ua;
    744744        ua.val = a;
    745        
     745
    746746        float64_u ub;
    747747        ub.val = b;
    748        
     748
    749749        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    750750                // TODO: sigNaNs
    751751                return 1;
    752752        }
    753        
     753
    754754        return is_float64_eq(ua.data, ub.data) - 1;
    755755}
    … …  
    765765        float64_u ua;
    766766        ua.val = a;
    767        
     767
    768768        float64_u ub;
    769769        ub.val = b;
    770        
     770
    771771        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    772772                /* No special constant for unordered - maybe signaled? */
    773773                return 1;
    774774        }
    775        
     775
    776776        if (is_float64_eq(ua.data, ub.data))
    777777                return 0;
    778        
     778
    779779        if (is_float64_lt(ua.data, ub.data))
    780780                return -1;
    781        
     781
    782782        return 1;
    783783}
    … …  
    787787        float64_u ua;
    788788        ua.val = a;
    789        
     789
    790790        float64_u ub;
    791791        ub.val = b;
    792        
     792
    793793        return ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data)));
    794794}
    … …  
    798798        float64_u ua;
    799799        ua.val = a;
    800        
     800
    801801        float64_u ub;
    802802        ub.val = b;
    803        
     803
    804804        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    805805                // TODO: sigNaNs
    806806                return 1;
    807807        }
    808        
     808
    809809        if (is_float64_lt(ua.data, ub.data))
    810810                return -1;
    811        
     811
    812812        return 0;
    813813}
    … …  
    817817        float64_u ua;
    818818        ua.val = a;
    819        
     819
    820820        float64_u ub;
    821821        ub.val = b;
    822        
     822
    823823        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    824824                // TODO: sigNaNs
    825825                return 1;
    826826        }
    827        
     827
    828828        return is_float64_eq(ua.data, ub.data) - 1;
    829829}
    … …  
    833833        float64_u ua;
    834834        ua.val = a;
    835        
     835
    836836        float64_u ub;
    837837        ub.val = b;
    838        
     838
    839839        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    840840                // TODO: sigNaNs
    841841                return -1;
    842842        }
    843        
     843
    844844        if (is_float64_gt(ua.data, ub.data))
    845845                return 1;
    846        
     846
    847847        return 0;
    848848}
    … …  
    852852        float64_u ua;
    853853        ua.val = a;
    854        
     854
    855855        float64_u ub;
    856856        ub.val = b;
    857        
     857
    858858        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    859859                // TODO: sigNaNs
    860860                return -1;
    861861        }
    862        
     862
    863863        if (is_float64_eq(ua.data, ub.data))
    864864                return 0;
    865        
     865
    866866        if (is_float64_gt(ua.data, ub.data))
    867867                return 1;
    868        
     868
    869869        return -1;
    870870}
    … …  
    874874        float64_u ua;
    875875        ua.val = a;
    876        
     876
    877877        float64_u ub;
    878878        ub.val = b;
    879        
     879
    880880        if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) {
    881881                // TODO: sigNaNs
    882882                return 1;
    883883        }
    884        
     884
    885885        if (is_float64_eq(ua.data, ub.data))
    886886                return 0;
    887        
     887
    888888        if (is_float64_lt(ua.data, ub.data))
    889889                return -1;
    890        
     890
    891891        return 1;
    892892}
    … …  
    900900        float128_u ua;
    901901        ua.val = a;
    902        
    903         float128_u ub;
    904         ub.val = b;
    905        
     902
     903        float128_u ub;
     904        ub.val = b;
     905
    906906        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    907907                // TODO: sigNaNs
    908908                return -1;
    909909        }
    910        
     910
    911911        if (is_float128_gt(ua.data, ub.data))
    912912                return 1;
    913        
     913
    914914        return 0;
    915915}
    … …  
    919919        float128_u ua;
    920920        ua.val = a;
    921        
    922         float128_u ub;
    923         ub.val = b;
    924        
     921
     922        float128_u ub;
     923        ub.val = b;
     924
    925925        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    926926                // TODO: sigNaNs
    927927                return -1;
    928928        }
    929        
     929
    930930        if (is_float128_eq(ua.data, ub.data))
    931931                return 0;
    932        
     932
    933933        if (is_float128_gt(ua.data, ub.data))
    934934                return 1;
    935        
     935
    936936        return -1;
    937937}
    … …  
    941941        float128_u ua;
    942942        ua.val = a;
    943        
    944         float128_u ub;
    945         ub.val = b;
    946        
     943
     944        float128_u ub;
     945        ub.val = b;
     946
    947947        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    948948                // TODO: sigNaNs
    949949                return 1;
    950950        }
    951        
     951
    952952        if (is_float128_lt(ua.data, ub.data))
    953953                return -1;
    954        
     954
    955955        return 0;
    956956}
    … …  
    960960        float128_u ua;
    961961        ua.val = a;
    962        
    963         float128_u ub;
    964         ub.val = b;
    965        
     962
     963        float128_u ub;
     964        ub.val = b;
     965
    966966        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    967967                // TODO: sigNaNs
    968968                return 1;
    969969        }
    970        
     970
    971971        if (is_float128_eq(ua.data, ub.data))
    972972                return 0;
    973        
     973
    974974        if (is_float128_lt(ua.data, ub.data))
    975975                return -1;
    976        
     976
    977977        return 1;
    978978}
    … …  
    982982        float128_u ua;
    983983        ua.val = a;
    984        
    985         float128_u ub;
    986         ub.val = b;
    987        
     984
     985        float128_u ub;
     986        ub.val = b;
     987
    988988        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    989989                // TODO: sigNaNs
    990990                return 1;
    991991        }
    992        
     992
    993993        return is_float128_eq(ua.data, ub.data) - 1;
    994994}
    … …  
    10041004        float128_u ua;
    10051005        ua.val = a;
    1006        
    1007         float128_u ub;
    1008         ub.val = b;
    1009        
     1006
     1007        float128_u ub;
     1008        ub.val = b;
     1009
    10101010        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) {
    10111011                /* No special constant for unordered - maybe signaled? */
    10121012                return 1;
    10131013        }
    1014        
     1014
    10151015        if (is_float128_eq(ua.data, ub.data))
    10161016                return 0;
    1017        
     1017
    10181018        if (is_float128_lt(ua.data, ub.data))
    10191019                return -1;
    1020        
     1020
    10211021        return 1;
    10221022}
    … …  
    10261026        float128_u ua;
    10271027        ua.val = a;
    1028        
    1029         float128_u ub;
    1030         ub.val = b;
    1031        
     1028
     1029        float128_u ub;
     1030        ub.val = b;
     1031
    10321032        return ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)));
    10331033}
    … …  
    10371037        float128_u ua;
    10381038        ua.val = *a;
    1039        
     1039
    10401040        float128_u ub;
    10411041        ub.val = *b;
    1042        
     1042
    10431043        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10441044                return 3;
    1045        
     1045
    10461046        if (is_float128_eq(ua.data, ub.data))
    10471047                return 0;
    1048        
     1048
    10491049        if (is_float128_lt(ua.data, ub.data))
    10501050                return 1;
    1051        
     1051
    10521052        return 2;
    10531053}
    … …  
    10631063        float128_u ua;
    10641064        ua.val = *a;
    1065        
     1065
    10661066        float128_u ub;
    10671067        ub.val = *b;
    1068        
     1068
    10691069        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10701070                return 0;
    1071        
     1071
    10721072        return is_float128_gt(ua.data, ub.data);
    10731073}
    … …  
    10771077        float128_u ua;
    10781078        ua.val = *a;
    1079        
     1079
    10801080        float128_u ub;
    10811081        ub.val = *b;
    1082        
     1082
    10831083        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10841084                return 0;
    1085        
     1085
    10861086        return is_float128_eq(ua.data, ub.data) ||
    10871087            is_float128_gt(ua.data, ub.data);
    … …  
    10921092        float128_u ua;
    10931093        ua.val = *a;
    1094        
     1094
    10951095        float128_u ub;
    10961096        ub.val = *b;
    1097        
     1097
    10981098        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    10991099                return 0;
    1100        
     1100
    11011101        return is_float128_lt(ua.data, ub.data);
    11021102}
    … …  
    11061106        float128_u ua;
    11071107        ua.val = *a;
    1108        
     1108
    11091109        float128_u ub;
    11101110        ub.val = *b;
    1111        
     1111
    11121112        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11131113                return 0;
    1114        
     1114
    11151115        return is_float128_eq(ua.data, ub.data) ||
    11161116            is_float128_lt(ua.data, ub.data);
    … …  
    11211121        float128_u ua;
    11221122        ua.val = *a;
    1123        
     1123
    11241124        float128_u ub;
    11251125        ub.val = *b;
    1126        
     1126
    11271127        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11281128                return 0;
    1129        
     1129
    11301130        return is_float128_eq(ua.data, ub.data);
    11311131}
    … …  
    11351135        float128_u ua;
    11361136        ua.val = *a;
    1137        
     1137
    11381138        float128_u ub;
    11391139        ub.val = *b;
    1140        
     1140
    11411141        if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data)))
    11421142                return 0;
    1143        
     1143
    11441144        return !is_float128_eq(ua.data, ub.data);
    11451145}
Note: See TracChangeset for help on using the changeset viewer.