Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r88d5c1e r9d58539  
    4848#include <other.h>
    4949
     50#include <functions.h>
     51
    5052/* Arithmetic functions */
    5153
    5254float __addsf3(float a, float b)
    5355{
    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;
     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;
    7768}
    7869
    7970double __adddf3(double a, double b)
    8071{
    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;
     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;
    10484}
    10585
    10686long double __addtf3(long double a, long double b)
    10787{
    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;
     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;
    131100}
    132101
    133102float __subsf3(float a, float b)
    134103{
    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;
     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;
    151112}
    152113
    153114double __subdf3(double a, double b)
    154115{
    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;
     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;
    171124}
    172125
    173126long double __subtf3(long double a, long double b)
    174127{
    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 
    193 float __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 
    206 double __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;
     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
     138float __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
     146double __muldf3(double a, double b)
     147{
     148        float64 da, db;
     149        da.d = a;
     150        db.d = b;
     151        return  mulFloat64(da, db).d;
    217152}
    218153
    219154long double __multf3(long double a, long double b)
    220155{
    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 
    232 float __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 
    245 double __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;
     156        float128 ta, tb;
     157        ta.ld = a;
     158        tb.ld = b;
     159        return  mulFloat128(ta, tb).ld;
     160}
     161
     162float __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
     170double __divdf3(double a, double b)
     171{
     172        float64 da, db;
     173        da.d = a;
     174        db.d = b;
     175        return  divFloat64(da, db).d;
    256176}
    257177
    258178long double __divtf3(long double a, long double b)
    259179{
    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;
     180        float128 ta, tb;
     181        ta.ld = a;
     182        tb.ld = b;
     183        return  divFloat128(ta, tb).ld;
    269184}
    270185
    271186float __negsf2(float a)
    272187{
    273         float_t fa;
    274        
    275         fa.val = a;
    276         fa.data.parts.sign = !fa.data.parts.sign;
    277        
    278         return fa.val;
     188        float32 fa;
     189        fa.f = a;
     190        fa.parts.sign = !fa.parts.sign;
     191        return fa.f;
    279192}
    280193
    281194double __negdf2(double a)
    282195{
    283         double_t da;
    284        
    285         da.val = a;
    286         da.data.parts.sign = !da.data.parts.sign;
    287        
    288         return da.val;
     196        float64 da;
     197        da.d = a;
     198        da.parts.sign = !da.parts.sign;
     199        return da.d;
    289200}
    290201
    291202long double __negtf2(long double a)
    292203{
    293         long_double_t ta;
    294        
    295         ta.val = a;
    296         ta.data.parts.sign = !ta.data.parts.sign;
    297        
    298         return ta.val;
     204        float128 ta;
     205        ta.ld = a;
     206        ta.parts.sign = !ta.parts.sign;
     207        return ta.ld;
    299208}
    300209
    301210/* Conversion functions */
    302211
    303 double __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;
     212double __extendsfdf2(float a)
     213{
     214        float32 fa;
     215        fa.f = a;
     216        return convertFloat32ToFloat64(fa).d;
    312217}
    313218
    314219long double __extendsftf2(float a)
    315220{
    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;
     221        float32 fa;
     222        fa.f = a;
     223        return convertFloat32ToFloat128(fa).ld;
    323224}
    324225
    325226long double __extenddftf2(double a)
    326227{
    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 
    336 float __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;
     228        float64 da;
     229        da.d = a;
     230        return convertFloat64ToFloat128(da).ld;
     231}
     232
     233float __truncdfsf2(double a)
     234{
     235        float64 da;
     236        da.d = a;
     237        return convertFloat64ToFloat32(da).f;
    345238}
    346239
    347240float __trunctfsf2(long double a)
    348241{
    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;
     242        float128 ta;
     243        ta.ld = a;
     244        return convertFloat128ToFloat32(ta).f;
    356245}
    357246
    358247double __trunctfdf2(long double a)
    359248{
    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;
     249        float128 ta;
     250        ta.ld = a;
     251        return convertFloat128ToFloat64(ta).d;
    367252}
    368253
    369254int __fixsfsi(float a)
    370255{
    371         float_t fa;
    372        
    373         fa.val = a;
    374         return float_to_int(fa.data);
     256        float32 fa;
     257        fa.f = a;
     258       
     259        return float32_to_int(fa);
    375260}
    376261
    377262int __fixdfsi(double a)
    378263{
    379         double_t da;
    380        
    381         da.val = a;
    382         return double_to_int(da.data);
     264        float64 da;
     265        da.d = a;
     266       
     267        return float64_to_int(da);
    383268}
    384269
    385270int __fixtfsi(long double a)
    386271{
    387         long_double_t ta;
    388        
    389         ta.val = a;
    390         return long_double_to_int(ta.data);
     272        float128 ta;
     273        ta.ld = a;
     274
     275        return float128_to_int(ta);
    391276}
    392277 
    393278long __fixsfdi(float a)
    394279{
    395         float_t fa;
    396        
    397         fa.val = a;
    398         return float_to_long(fa.data);
     280        float32 fa;
     281        fa.f = a;
     282       
     283        return float32_to_long(fa);
    399284}
    400285
    401286long __fixdfdi(double a)
    402287{
    403         double_t da;
    404        
    405         da.val = a;
    406         return double_to_long(da.data);
     288        float64 da;
     289        da.d = a;
     290       
     291        return float64_to_long(da);
    407292}
    408293
    409294long __fixtfdi(long double a)
    410295{
    411         long_double_t ta;
    412        
    413         ta.val = a;
    414         return long_double_to_long(ta.data);
     296        float128 ta;
     297        ta.ld = a;
     298
     299        return float128_to_long(ta);
    415300}
    416301 
    417302long long __fixsfti(float a)
    418303{
    419         float_t fa;
    420        
    421         fa.val = a;
    422         return float_to_llong(fa.data);
     304        float32 fa;
     305        fa.f = a;
     306       
     307        return float32_to_longlong(fa);
    423308}
    424309
    425310long long __fixdfti(double a)
    426311{
    427         double_t da;
    428        
    429         da.val = a;
    430         return double_to_llong(da.data);
     312        float64 da;
     313        da.d = a;
     314       
     315        return float64_to_longlong(da);
    431316}
    432317
    433318long long __fixtfti(long double a)
    434319{
    435         long_double_t ta;
    436        
    437         ta.val = a;
    438         return long_double_to_llong(ta.data);
     320        float128 ta;
     321        ta.ld = a;
     322
     323        return float128_to_longlong(ta);
    439324}
    440325
    441326unsigned int __fixunssfsi(float a)
    442327{
    443         float_t fa;
    444        
    445         fa.val = a;
    446         return float_to_uint(fa.data);
     328        float32 fa;
     329        fa.f = a;
     330       
     331        return float32_to_uint(fa);
    447332}
    448333
    449334unsigned int __fixunsdfsi(double a)
    450335{
    451         double_t da;
    452        
    453         da.val = a;
    454         return double_to_uint(da.data);
     336        float64 da;
     337        da.d = a;
     338       
     339        return float64_to_uint(da);
    455340}
    456341
    457342unsigned int __fixunstfsi(long double a)
    458343{
    459         long_double_t ta;
    460        
    461         ta.val = a;
    462         return long_double_to_uint(ta.data);
     344        float128 ta;
     345        ta.ld = a;
     346
     347        return float128_to_uint(ta);
    463348}
    464349 
    465350unsigned long __fixunssfdi(float a)
    466351{
    467         float_t fa;
    468        
    469         fa.val = a;
    470         return float_to_ulong(fa.data);
     352        float32 fa;
     353        fa.f = a;
     354       
     355        return float32_to_ulong(fa);
    471356}
    472357
    473358unsigned long __fixunsdfdi(double a)
    474359{
    475         double_t da;
    476        
    477         da.val = a;
    478         return double_to_ulong(da.data);
     360        float64 da;
     361        da.d = a;
     362       
     363        return float64_to_ulong(da);
    479364}
    480365
    481366unsigned long __fixunstfdi(long double a)
    482367{
    483         long_double_t ta;
    484        
    485         ta.val = a;
    486         return long_double_to_ulong(ta.data);
     368        float128 ta;
     369        ta.ld = a;
     370
     371        return float128_to_ulong(ta);
    487372}
    488373 
    489374unsigned long long __fixunssfti(float a)
    490375{
    491         float_t fa;
    492        
    493         fa.val = a;
    494         return float_to_ullong(fa.data);
     376        float32 fa;
     377        fa.f = a;
     378       
     379        return float32_to_ulonglong(fa);
    495380}
    496381
    497382unsigned long long __fixunsdfti(double a)
    498383{
    499         double_t da;
    500        
    501         da.val = a;
    502         return double_to_ullong(da.data);
     384        float64 da;
     385        da.d = a;
     386       
     387        return float64_to_ulonglong(da);
    503388}
    504389
    505390unsigned long long __fixunstfti(long double a)
    506391{
    507         long_double_t ta;
    508        
    509         ta.val = a;
    510         return long_double_to_ullong(ta.data);
     392        float128 ta;
     393        ta.ld = a;
     394
     395        return float128_to_ulonglong(ta);
    511396}
    512397 
    513398float __floatsisf(int i)
    514399{
    515         float_t res;
    516        
    517         res.data = int_to_float(i);
    518         return res.val;
     400        float32 fa;
     401       
     402        fa = int_to_float32(i);
     403        return fa.f;
    519404}
    520405
    521406double __floatsidf(int i)
    522407{
    523         double_t res;
    524        
    525         res.data = int_to_double(i);
    526         return res.val;
     408        float64 da;
     409       
     410        da = int_to_float64(i);
     411        return da.d;
    527412}
    528413
    529414long double __floatsitf(int i)
    530415{
    531         long_double_t res;
    532        
    533         res.data = int_to_long_double(i);
    534         return res.val;
     416        float128 ta;
     417
     418        ta = int_to_float128(i);
     419        return ta.ld;
    535420}
    536421 
    537422float __floatdisf(long i)
    538423{
    539         float_t res;
    540        
    541         res.data = long_to_float(i);
    542         return res.val;
     424        float32 fa;
     425       
     426        fa = long_to_float32(i);
     427        return fa.f;
    543428}
    544429
    545430double __floatdidf(long i)
    546431{
    547         double_t res;
    548        
    549         res.data = long_to_double(i);
    550         return res.val;
     432        float64 da;
     433       
     434        da = long_to_float64(i);
     435        return da.d;
    551436}
    552437
    553438long double __floatditf(long i)
    554439{
    555         long_double_t res;
    556        
    557         res.data = long_to_long_double(i);
    558         return res.val;
    559 }
    560 
     440        float128 ta;
     441
     442        ta = long_to_float128(i);
     443        return ta.ld;
     444}
     445 
    561446float __floattisf(long long i)
    562447{
    563         float_t res;
    564        
    565         res.data = llong_to_float(i);
    566         return res.val;
     448        float32 fa;
     449       
     450        fa = longlong_to_float32(i);
     451        return fa.f;
    567452}
    568453
    569454double __floattidf(long long i)
    570455{
    571         double_t res;
    572        
    573         res.data = llong_to_double(i);
    574         return res.val;
     456        float64 da;
     457       
     458        da = longlong_to_float64(i);
     459        return da.d;
    575460}
    576461
    577462long double __floattitf(long long i)
    578463{
    579         long_double_t res;
    580        
    581         res.data = llong_to_long_double(i);
    582         return res.val;
     464        float128 ta;
     465
     466        ta = longlong_to_float128(i);
     467        return ta.ld;
    583468}
    584469
    585470float __floatunsisf(unsigned int i)
    586471{
    587         float_t res;
    588        
    589         res.data = uint_to_float(i);
    590         return res.val;
     472        float32 fa;
     473       
     474        fa = uint_to_float32(i);
     475        return fa.f;
    591476}
    592477
    593478double __floatunsidf(unsigned int i)
    594479{
    595         double_t res;
    596        
    597         res.data = uint_to_double(i);
    598         return res.val;
     480        float64 da;
     481       
     482        da = uint_to_float64(i);
     483        return da.d;
    599484}
    600485
    601486long double __floatunsitf(unsigned int i)
    602487{
    603         long_double_t res;
    604        
    605         res.data = uint_to_long_double(i);
    606         return res.val;
     488        float128 ta;
     489
     490        ta = uint_to_float128(i);
     491        return ta.ld;
    607492}
    608493 
    609494float __floatundisf(unsigned long i)
    610495{
    611         float_t res;
    612        
    613         res.data = ulong_to_float(i);
    614         return res.val;
     496        float32 fa;
     497       
     498        fa = ulong_to_float32(i);
     499        return fa.f;
    615500}
    616501
    617502double __floatundidf(unsigned long i)
    618503{
    619         double_t res;
    620        
    621         res.data = ulong_to_double(i);
    622         return res.val;
     504        float64 da;
     505       
     506        da = ulong_to_float64(i);
     507        return da.d;
    623508}
    624509
    625510long double __floatunditf(unsigned long i)
    626511{
    627         long_double_t res;
    628        
    629         res.data = ulong_to_long_double(i);
    630         return res.val;
     512        float128 ta;
     513
     514        ta = ulong_to_float128(i);
     515        return ta.ld;
    631516}
    632517 
    633518float __floatuntisf(unsigned long long i)
    634519{
    635         float_t res;
    636        
    637         res.data = ullong_to_float(i);
    638         return res.val;
     520        float32 fa;
     521       
     522        fa = ulonglong_to_float32(i);
     523        return fa.f;
    639524}
    640525
    641526double __floatuntidf(unsigned long long i)
    642527{
    643         double_t res;
    644        
    645         res.data = ullong_to_double(i);
    646         return res.val;
     528        float64 da;
     529       
     530        da = ulonglong_to_float64(i);
     531        return da.d;
    647532}
    648533
    649534long double __floatuntitf(unsigned long long i)
    650535{
    651         long_double_t res;
    652        
    653         res.data = ullong_to_long_double(i);
    654         return res.val;
     536        float128 ta;
     537
     538        ta = ulonglong_to_float128(i);
     539        return ta.ld;
    655540}
    656541
    … …  
    659544int __cmpsf2(float a, float b)
    660545{
    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        
     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
    678562        return 1;
    679563}
    … …  
    681565int __cmpdf2(double a, double b)
    682566{
    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        
     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
    700583        return 1;
    701584}
    … …  
    703586int __cmptf2(long double a, long double b)
    704587{
    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        
     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
    722604        return 1;
    723605}
    724606
    725 int __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)));
     607int __unordsf2(float a, float b)
     608{
     609        float32 fa, fb;
     610        fa.f = a;
     611        fb.f = b;
     612        return ((isFloat32NaN(fa)) || (isFloat32NaN(fb)));
    734613}
    735614
    736615int __unorddf2(double a, double b)
    737616{
    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)));
     617        float64 da, db;
     618        da.d = a;
     619        db.d = b;
     620        return ((isFloat64NaN(da)) || (isFloat64NaN(db)));
    745621}
    746622
    747623int __unordtf2(long double a, long double b)
    748624{
    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 
    758 int __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;
     625        float128 ta, tb;
     626        ta.ld = a;
     627        tb.ld = b;
     628        return ((isFloat128NaN(ta)) || (isFloat128NaN(tb)));
     629}
     630
     631int __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;
    772641}
    773642
    774643int __eqdf2(double a, double b)
    775644{
    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;
     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;
    788653}
    789654
    790655int __eqtf2(long double a, long double b)
    791656{
    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 
    806 int __nesf2(float a, float b)
     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
     667int __nesf2(float a, float b)
    807668{
    808669        /* strange behavior, but it was in gcc documentation */
    … …  
    824685int __gesf2(float a, float b)
    825686{
    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;
     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        }
    842703       
    843704        return -1;
    … …  
    846707int __gedf2(double a, double b)
    847708{
    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        
     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
    865726        return -1;
    866727}
    … …  
    868729int __getf2(long double a, long double b)
    869730{
    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        
     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
    887748        return -1;
    888749}
    … …  
    890751int __ltsf2(float a, float b)
    891752{
    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        
     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
    906766        return 0;
    907767}
    … …  
    909769int __ltdf2(double a, double b)
    910770{
    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        
     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
    925784        return 0;
    926785}
    … …  
    928787int __lttf2(long double a, long double b)
    929788{
    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        
     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
    944802        return 0;
    945803}
    … …  
    947805int __lesf2(float a, float b)
    948806{
    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;
     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        }
    965823       
    966824        return 1;
    … …  
    969827int __ledf2(double a, double b)
    970828{
    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        
     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
    988846        return 1;
    989847}
    … …  
    991849int __letf2(long double a, long double b)
    992850{
    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        
     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
    1010868        return 1;
    1011869}
    … …  
    1013871int __gtsf2(float a, float b)
    1014872{
    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        
     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
    1029886        return 0;
    1030887}
    … …  
    1032889int __gtdf2(double a, double b)
    1033890{
    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        
     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
    1048904        return 0;
    1049905}
    … …  
    1051907int __gttf2(long double a, long double b)
    1052908{
    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        
     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
    1067922        return 0;
    1068923}
    1069924
     925
     926
     927#ifdef SPARC_SOFTFLOAT
     928
    1070929/* SPARC quadruple-precision wrappers */
    1071930
    … …  
    11571016int _Qp_cmp(long double *a, long double *b)
    11581017{
    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)))
     1018        float128 ta, tb;
     1019        ta.ld = *a;
     1020        tb.ld = *b;
     1021
     1022        if ((isFloat128NaN(ta)) || (isFloat128NaN(tb))) {
    11661023                return 3;
    1167        
    1168         if (is_long_double_eq(ta.data, tb.data))
    1169                 return 0;
    1170        
    1171         if (is_long_double_lt(ta.data, tb.data))
    1172                 return 1;
    1173        
     1024        }
     1025
     1026        if (isFloat128eq(ta, tb)) {
     1027                return 0;
     1028        }
     1029
     1030        if (isFloat128lt(ta, tb)) {
     1031                return 1;
     1032        }
     1033
    11741034        return 2;
    11751035}
    … …  
    11831043int _Qp_feq(long double *a, long double *b)
    11841044{
    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);
     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);
    11951054}
    11961055
    11971056int _Qp_fge(long double *a, long double *b)
    11981057{
    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);
     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);
    12101067}
    12111068
    12121069int _Qp_fgt(long double *a, long double *b)
    12131070{
    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);
     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);
    12241080}
    12251081
    12261082int _Qp_fle(long double*a, long double *b)
    12271083{
    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);
     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);
    12391093}
    12401094
    12411095int _Qp_flt(long double *a, long double *b)
    12421096{
    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);
     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);
    12531106}
    12541107
    12551108int _Qp_fne(long double *a, long double *b)
    12561109{
    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 }
     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
    12681122
    12691123/** @}
Note: See TracChangeset for help on using the changeset viewer.