Ignore:
Timestamp:
2012-04-13T06:36:25Z (12 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
90f067d9
Parents:
e61aa80 (diff), d11a181 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    re61aa80 r9b0a6b4  
    4848#include <other.h>
    4949
    50 #include <functions.h>
    51 
    5250/* Arithmetic functions */
    5351
    5452float __addsf3(float a, float b)
    5553{
    56         float32 fa, fb;
    57         fa.f = a;
    58         fb.f = b;
    59         if (fa.parts.sign != fb.parts.sign) {
    60                 if (fa.parts.sign) {
    61                         fa.parts.sign = 0;
    62                         return subFloat32(fb, fa).f;
    63                 };
    64                 fb.parts.sign = 0;
    65                 return subFloat32(fa, fb).f;
    66         }
    67         return addFloat32(fa, fb).f;
     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;
    6877}
    6978
    7079double __adddf3(double a, double b)
    7180{
    72         float64 da, db;
    73         da.d = a;
    74         db.d = b;
    75         if (da.parts.sign != db.parts.sign) {
    76                 if (da.parts.sign) {
    77                         da.parts.sign = 0;
    78                         return subFloat64(db, da).d;
    79                 };
    80                 db.parts.sign = 0;
    81                 return subFloat64(da, db).d;
    82         }
    83         return addFloat64(da, db).d;
     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;
    84104}
    85105
    86106long double __addtf3(long double a, long double b)
    87107{
    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;
     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;
    100131}
    101132
    102133float __subsf3(float a, float b)
    103134{
    104         float32 fa, fb;
    105         fa.f = a;
    106         fb.f = b;
    107         if (fa.parts.sign != fb.parts.sign) {
    108                 fb.parts.sign = !fb.parts.sign;
    109                 return addFloat32(fa, fb).f;
    110         }
    111         return subFloat32(fa, fb).f;
     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;
    112151}
    113152
    114153double __subdf3(double a, double b)
    115154{
    116         float64 da, db;
    117         da.d = a;
    118         db.d = b;
    119         if (da.parts.sign != db.parts.sign) {
    120                 db.parts.sign = !db.parts.sign;
    121                 return addFloat64(da, db).d;
    122         }
    123         return subFloat64(da, db).d;
     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;
    124171}
    125172
    126173long double __subtf3(long double a, long double b)
    127174{
    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 
    138 float __mulsf3(float a, float b)
    139 {
    140         float32 fa, fb;
    141         fa.f = a;
    142         fb.f = b;
    143         return  mulFloat32(fa, fb).f;
    144 }
    145 
    146 double __muldf3(double a, double b)
    147 {
    148         float64 da, db;
    149         da.d = a;
    150         db.d = b;
    151         return  mulFloat64(da, db).d;
     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;
    152217}
    153218
    154219long double __multf3(long double a, long double b)
    155220{
    156         float128 ta, tb;
    157         ta.ld = a;
    158         tb.ld = b;
    159         return  mulFloat128(ta, tb).ld;
    160 }
    161 
    162 float __divsf3(float a, float b)
    163 {
    164         float32 fa, fb;
    165         fa.f = a;
    166         fb.f = b;
    167         return  divFloat32(fa, fb).f;
    168 }
    169 
    170 double __divdf3(double a, double b)
    171 {
    172         float64 da, db;
    173         da.d = a;
    174         db.d = b;
    175         return  divFloat64(da, db).d;
     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;
    176256}
    177257
    178258long double __divtf3(long double a, long double b)
    179259{
    180         float128 ta, tb;
    181         ta.ld = a;
    182         tb.ld = b;
    183         return  divFloat128(ta, tb).ld;
     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;
    184269}
    185270
    186271float __negsf2(float a)
    187272{
    188         float32 fa;
    189         fa.f = a;
    190         fa.parts.sign = !fa.parts.sign;
    191         return fa.f;
     273        float_t fa;
     274       
     275        fa.val = a;
     276        fa.data.parts.sign = !fa.data.parts.sign;
     277       
     278        return fa.val;
    192279}
    193280
    194281double __negdf2(double a)
    195282{
    196         float64 da;
    197         da.d = a;
    198         da.parts.sign = !da.parts.sign;
    199         return da.d;
     283        double_t da;
     284       
     285        da.val = a;
     286        da.data.parts.sign = !da.data.parts.sign;
     287       
     288        return da.val;
    200289}
    201290
    202291long double __negtf2(long double a)
    203292{
    204         float128 ta;
    205         ta.ld = a;
    206         ta.parts.sign = !ta.parts.sign;
    207         return ta.ld;
     293        long_double_t ta;
     294       
     295        ta.val = a;
     296        ta.data.parts.sign = !ta.data.parts.sign;
     297       
     298        return ta.val;
    208299}
    209300
    210301/* Conversion functions */
    211302
    212 double __extendsfdf2(float a)
    213 {
    214         float32 fa;
    215         fa.f = a;
    216         return convertFloat32ToFloat64(fa).d;
     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;
    217312}
    218313
    219314long double __extendsftf2(float a)
    220315{
    221         float32 fa;
    222         fa.f = a;
    223         return convertFloat32ToFloat128(fa).ld;
     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;
    224323}
    225324
    226325long double __extenddftf2(double a)
    227326{
    228         float64 da;
    229         da.d = a;
    230         return convertFloat64ToFloat128(da).ld;
    231 }
    232 
    233 float __truncdfsf2(double a)
    234 {
    235         float64 da;
    236         da.d = a;
    237         return convertFloat64ToFloat32(da).f;
     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;
    238345}
    239346
    240347float __trunctfsf2(long double a)
    241348{
    242         float128 ta;
    243         ta.ld = a;
    244         return convertFloat128ToFloat32(ta).f;
     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;
    245356}
    246357
    247358double __trunctfdf2(long double a)
    248359{
    249         float128 ta;
    250         ta.ld = a;
    251         return convertFloat128ToFloat64(ta).d;
     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;
    252367}
    253368
    254369int __fixsfsi(float a)
    255370{
    256         float32 fa;
    257         fa.f = a;
    258        
    259         return float32_to_int(fa);
     371        float_t fa;
     372       
     373        fa.val = a;
     374        return float_to_int(fa.data);
    260375}
    261376
    262377int __fixdfsi(double a)
    263378{
    264         float64 da;
    265         da.d = a;
    266        
    267         return float64_to_int(da);
     379        double_t da;
     380       
     381        da.val = a;
     382        return double_to_int(da.data);
    268383}
    269384
    270385int __fixtfsi(long double a)
    271386{
    272         float128 ta;
    273         ta.ld = a;
    274 
    275         return float128_to_int(ta);
     387        long_double_t ta;
     388       
     389        ta.val = a;
     390        return long_double_to_int(ta.data);
    276391}
    277392 
    278393long __fixsfdi(float a)
    279394{
    280         float32 fa;
    281         fa.f = a;
    282        
    283         return float32_to_long(fa);
     395        float_t fa;
     396       
     397        fa.val = a;
     398        return float_to_long(fa.data);
    284399}
    285400
    286401long __fixdfdi(double a)
    287402{
    288         float64 da;
    289         da.d = a;
    290        
    291         return float64_to_long(da);
     403        double_t da;
     404       
     405        da.val = a;
     406        return double_to_long(da.data);
    292407}
    293408
    294409long __fixtfdi(long double a)
    295410{
    296         float128 ta;
    297         ta.ld = a;
    298 
    299         return float128_to_long(ta);
     411        long_double_t ta;
     412       
     413        ta.val = a;
     414        return long_double_to_long(ta.data);
    300415}
    301416 
    302417long long __fixsfti(float a)
    303418{
    304         float32 fa;
    305         fa.f = a;
    306        
    307         return float32_to_longlong(fa);
     419        float_t fa;
     420       
     421        fa.val = a;
     422        return float_to_llong(fa.data);
    308423}
    309424
    310425long long __fixdfti(double a)
    311426{
    312         float64 da;
    313         da.d = a;
    314        
    315         return float64_to_longlong(da);
     427        double_t da;
     428       
     429        da.val = a;
     430        return double_to_llong(da.data);
    316431}
    317432
    318433long long __fixtfti(long double a)
    319434{
    320         float128 ta;
    321         ta.ld = a;
    322 
    323         return float128_to_longlong(ta);
     435        long_double_t ta;
     436       
     437        ta.val = a;
     438        return long_double_to_llong(ta.data);
    324439}
    325440
    326441unsigned int __fixunssfsi(float a)
    327442{
    328         float32 fa;
    329         fa.f = a;
    330        
    331         return float32_to_uint(fa);
     443        float_t fa;
     444       
     445        fa.val = a;
     446        return float_to_uint(fa.data);
    332447}
    333448
    334449unsigned int __fixunsdfsi(double a)
    335450{
    336         float64 da;
    337         da.d = a;
    338        
    339         return float64_to_uint(da);
     451        double_t da;
     452       
     453        da.val = a;
     454        return double_to_uint(da.data);
    340455}
    341456
    342457unsigned int __fixunstfsi(long double a)
    343458{
    344         float128 ta;
    345         ta.ld = a;
    346 
    347         return float128_to_uint(ta);
     459        long_double_t ta;
     460       
     461        ta.val = a;
     462        return long_double_to_uint(ta.data);
    348463}
    349464 
    350465unsigned long __fixunssfdi(float a)
    351466{
    352         float32 fa;
    353         fa.f = a;
    354        
    355         return float32_to_ulong(fa);
     467        float_t fa;
     468       
     469        fa.val = a;
     470        return float_to_ulong(fa.data);
    356471}
    357472
    358473unsigned long __fixunsdfdi(double a)
    359474{
    360         float64 da;
    361         da.d = a;
    362        
    363         return float64_to_ulong(da);
     475        double_t da;
     476       
     477        da.val = a;
     478        return double_to_ulong(da.data);
    364479}
    365480
    366481unsigned long __fixunstfdi(long double a)
    367482{
    368         float128 ta;
    369         ta.ld = a;
    370 
    371         return float128_to_ulong(ta);
     483        long_double_t ta;
     484       
     485        ta.val = a;
     486        return long_double_to_ulong(ta.data);
    372487}
    373488 
    374489unsigned long long __fixunssfti(float a)
    375490{
    376         float32 fa;
    377         fa.f = a;
    378        
    379         return float32_to_ulonglong(fa);
     491        float_t fa;
     492       
     493        fa.val = a;
     494        return float_to_ullong(fa.data);
    380495}
    381496
    382497unsigned long long __fixunsdfti(double a)
    383498{
    384         float64 da;
    385         da.d = a;
    386        
    387         return float64_to_ulonglong(da);
     499        double_t da;
     500       
     501        da.val = a;
     502        return double_to_ullong(da.data);
    388503}
    389504
    390505unsigned long long __fixunstfti(long double a)
    391506{
    392         float128 ta;
    393         ta.ld = a;
    394 
    395         return float128_to_ulonglong(ta);
     507        long_double_t ta;
     508       
     509        ta.val = a;
     510        return long_double_to_ullong(ta.data);
    396511}
    397512 
    398513float __floatsisf(int i)
    399514{
    400         float32 fa;
    401        
    402         fa = int_to_float32(i);
    403         return fa.f;
     515        float_t res;
     516       
     517        res.data = int_to_float(i);
     518        return res.val;
    404519}
    405520
    406521double __floatsidf(int i)
    407522{
    408         float64 da;
    409        
    410         da = int_to_float64(i);
    411         return da.d;
     523        double_t res;
     524       
     525        res.data = int_to_double(i);
     526        return res.val;
    412527}
    413528
    414529long double __floatsitf(int i)
    415530{
    416         float128 ta;
    417 
    418         ta = int_to_float128(i);
    419         return ta.ld;
     531        long_double_t res;
     532       
     533        res.data = int_to_long_double(i);
     534        return res.val;
    420535}
    421536 
    422537float __floatdisf(long i)
    423538{
    424         float32 fa;
    425        
    426         fa = long_to_float32(i);
    427         return fa.f;
     539        float_t res;
     540       
     541        res.data = long_to_float(i);
     542        return res.val;
    428543}
    429544
    430545double __floatdidf(long i)
    431546{
    432         float64 da;
    433        
    434         da = long_to_float64(i);
    435         return da.d;
     547        double_t res;
     548       
     549        res.data = long_to_double(i);
     550        return res.val;
    436551}
    437552
    438553long double __floatditf(long i)
    439554{
    440         float128 ta;
    441 
    442         ta = long_to_float128(i);
    443         return ta.ld;
    444 }
    445  
     555        long_double_t res;
     556       
     557        res.data = long_to_long_double(i);
     558        return res.val;
     559}
     560
    446561float __floattisf(long long i)
    447562{
    448         float32 fa;
    449        
    450         fa = longlong_to_float32(i);
    451         return fa.f;
     563        float_t res;
     564       
     565        res.data = llong_to_float(i);
     566        return res.val;
    452567}
    453568
    454569double __floattidf(long long i)
    455570{
    456         float64 da;
    457        
    458         da = longlong_to_float64(i);
    459         return da.d;
     571        double_t res;
     572       
     573        res.data = llong_to_double(i);
     574        return res.val;
    460575}
    461576
    462577long double __floattitf(long long i)
    463578{
    464         float128 ta;
    465 
    466         ta = longlong_to_float128(i);
    467         return ta.ld;
     579        long_double_t res;
     580       
     581        res.data = llong_to_long_double(i);
     582        return res.val;
    468583}
    469584
    470585float __floatunsisf(unsigned int i)
    471586{
    472         float32 fa;
    473        
    474         fa = uint_to_float32(i);
    475         return fa.f;
     587        float_t res;
     588       
     589        res.data = uint_to_float(i);
     590        return res.val;
    476591}
    477592
    478593double __floatunsidf(unsigned int i)
    479594{
    480         float64 da;
    481        
    482         da = uint_to_float64(i);
    483         return da.d;
     595        double_t res;
     596       
     597        res.data = uint_to_double(i);
     598        return res.val;
    484599}
    485600
    486601long double __floatunsitf(unsigned int i)
    487602{
    488         float128 ta;
    489 
    490         ta = uint_to_float128(i);
    491         return ta.ld;
     603        long_double_t res;
     604       
     605        res.data = uint_to_long_double(i);
     606        return res.val;
    492607}
    493608 
    494609float __floatundisf(unsigned long i)
    495610{
    496         float32 fa;
    497        
    498         fa = ulong_to_float32(i);
    499         return fa.f;
     611        float_t res;
     612       
     613        res.data = ulong_to_float(i);
     614        return res.val;
    500615}
    501616
    502617double __floatundidf(unsigned long i)
    503618{
    504         float64 da;
    505        
    506         da = ulong_to_float64(i);
    507         return da.d;
     619        double_t res;
     620       
     621        res.data = ulong_to_double(i);
     622        return res.val;
    508623}
    509624
    510625long double __floatunditf(unsigned long i)
    511626{
    512         float128 ta;
    513 
    514         ta = ulong_to_float128(i);
    515         return ta.ld;
     627        long_double_t res;
     628       
     629        res.data = ulong_to_long_double(i);
     630        return res.val;
    516631}
    517632 
    518633float __floatuntisf(unsigned long long i)
    519634{
    520         float32 fa;
    521        
    522         fa = ulonglong_to_float32(i);
    523         return fa.f;
     635        float_t res;
     636       
     637        res.data = ullong_to_float(i);
     638        return res.val;
    524639}
    525640
    526641double __floatuntidf(unsigned long long i)
    527642{
    528         float64 da;
    529        
    530         da = ulonglong_to_float64(i);
    531         return da.d;
     643        double_t res;
     644       
     645        res.data = ullong_to_double(i);
     646        return res.val;
    532647}
    533648
    534649long double __floatuntitf(unsigned long long i)
    535650{
    536         float128 ta;
    537 
    538         ta = ulonglong_to_float128(i);
    539         return ta.ld;
     651        long_double_t res;
     652       
     653        res.data = ullong_to_long_double(i);
     654        return res.val;
    540655}
    541656
    … …  
    544659int __cmpsf2(float a, float b)
    545660{
    546         float32 fa, fb;
    547         fa.f = a;
    548         fb.f = b;
    549 
    550         if ((isFloat32NaN(fa)) || (isFloat32NaN(fb))) {
    551                 return 1; /* no special constant for unordered - maybe signaled? */
    552         }
    553        
    554         if (isFloat32eq(fa, fb)) {
    555                 return 0;
    556         }
    557        
    558         if (isFloat32lt(fa, fb)) {
    559                 return -1;
    560         }
    561 
     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       
    562678        return 1;
    563679}
    … …  
    565681int __cmpdf2(double a, double b)
    566682{
    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 
     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       
    583700        return 1;
    584701}
    … …  
    586703int __cmptf2(long double a, long double b)
    587704{
    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 
     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       
    604722        return 1;
    605723}
    606724
    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)));
     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)));
    613734}
    614735
    615736int __unorddf2(double a, double b)
    616737{
    617         float64 da, db;
    618         da.d = a;
    619         db.d = b;
    620         return ((isFloat64NaN(da)) || (isFloat64NaN(db)));
     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)));
    621745}
    622746
    623747int __unordtf2(long double a, long double b)
    624748{
    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;
     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;
    641772}
    642773
    643774int __eqdf2(double a, double b)
    644775{
    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;
     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;
    653788}
    654789
    655790int __eqtf2(long double a, long double b)
    656791{
    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)
     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)
    668807{
    669808        /* strange behavior, but it was in gcc documentation */
    … …  
    685824int __gesf2(float a, float b)
    686825{
    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         }
    695        
    696         if (isFloat32eq(fa, fb)) {
    697                 return 0;
    698         }
    699        
    700         if (isFloat32gt(fa, fb)) {
    701                 return 1;
    702         }
     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;
    703842       
    704843        return -1;
    … …  
    707846int __gedf2(double a, double b)
    708847{
    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 
     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       
    726865        return -1;
    727866}
    … …  
    729868int __getf2(long double a, long double b)
    730869{
    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 
     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       
    748887        return -1;
    749888}
    … …  
    751890int __ltsf2(float a, float b)
    752891{
    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 
    762         if (isFloat32lt(fa, fb)) {
    763                 return -1;
    764         }
    765 
     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       
    766906        return 0;
    767907}
    … …  
    769909int __ltdf2(double a, double b)
    770910{
    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 
     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       
    784925        return 0;
    785926}
    … …  
    787928int __lttf2(long double a, long double b)
    788929{
    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 
     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       
    802944        return 0;
    803945}
    … …  
    805947int __lesf2(float a, float b)
    806948{
    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         }
    815        
    816         if (isFloat32eq(fa, fb)) {
    817                 return 0;
    818         }
    819        
    820         if (isFloat32lt(fa, fb)) {
    821                 return -1;
    822         }
     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;
    823965       
    824966        return 1;
    … …  
    827969int __ledf2(double a, double b)
    828970{
    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 
     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       
    846988        return 1;
    847989}
    … …  
    849991int __letf2(long double a, long double b)
    850992{
    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 
     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       
    8681010        return 1;
    8691011}
    … …  
    8711013int __gtsf2(float a, float b)
    8721014{
    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 
    882         if (isFloat32gt(fa, fb)) {
    883                 return 1;
    884         }
    885 
     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       
    8861029        return 0;
    8871030}
    … …  
    8891032int __gtdf2(double a, double b)
    8901033{
    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 
     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       
    9041048        return 0;
    9051049}
    … …  
    9071051int __gttf2(long double a, long double b)
    9081052{
    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 
     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       
    9221067        return 0;
    9231068}
    9241069
    925 
    926 
    927 #ifdef SPARC_SOFTFLOAT
    928 
    9291070/* SPARC quadruple-precision wrappers */
    9301071
    … …  
    10161157int _Qp_cmp(long double *a, long double *b)
    10171158{
    1018         float128 ta, tb;
    1019         ta.ld = *a;
    1020         tb.ld = *b;
    1021 
    1022         if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
     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)))
    10231166                return 3;
    1024         }
    1025 
    1026         if (isFloat128eq(ta, tb)) {
    1027                 return 0;
    1028         }
    1029 
    1030         if (isFloat128lt(ta, tb)) {
    1031                 return 1;
    1032         }
    1033 
     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       
    10341174        return 2;
    10351175}
    … …  
    10431183int _Qp_feq(long double *a, long double *b)
    10441184{
    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);
     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);
    10541195}
    10551196
    10561197int _Qp_fge(long double *a, long double *b)
    10571198{
    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);
     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);
    10671210}
    10681211
    10691212int _Qp_fgt(long double *a, long double *b)
    10701213{
    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);
     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);
    10801224}
    10811225
    10821226int _Qp_fle(long double*a, long double *b)
    10831227{
    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);
     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);
    10931239}
    10941240
    10951241int _Qp_flt(long double *a, long double *b)
    10961242{
    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);
     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);
    11061253}
    11071254
    11081255int _Qp_fne(long double *a, long double *b)
    11091256{
    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
     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}
    11221268
    11231269/** @}
Note: See TracChangeset for help on using the changeset viewer.