Ignore:
Timestamp:
2015-03-16T16:07:21Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2003739
Parents:
6069061 (diff), 795e2bf (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:

Mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/tester/float/softfloat1.c

    r6069061 r58775d30  
    2929#include <stdio.h>
    3030#include <stdlib.h>
    31 #include <sftypes.h>
     31#include <mathtypes.h>
    3232#include <add.h>
    3333#include <sub.h>
    … …  
    3939#include "../tester.h"
    4040
     41#define add_float  __addsf3
     42#define sub_float  __subsf3
     43#define mul_float  __mulsf3
     44#define div_float  __divsf3
     45
     46#define is_float_lt  __ltsf2
     47#define is_float_gt  __gtsf2
     48#define is_float_eq  __eqsf2
     49
     50#define add_double  __adddf3
     51#define sub_double  __subdf3
     52#define mul_double  __muldf3
     53#define div_double  __divdf3
     54
     55#define is_double_lt  __ltdf2
     56#define is_double_gt  __gtdf2
     57#define is_double_eq  __eqdf2
     58
     59#define uint_to_double  __floatsidf
     60#define double_to_uint  __fixunsdfsi
     61#define double_to_int   __fixdfsi
     62
    4163#define OPERANDS   10
    42 #define PRECISION  10000
     64#define PRECISION  1000
    4365
    4466#define PRIdCMPTYPE  PRId32
    … …  
    4668typedef int32_t cmptype_t;
    4769
    48 typedef void (* uint_to_double_op_t)(unsigned int, double *, double_t *);
     70typedef void (* uint_to_double_op_t)(unsigned int, double *, double *);
    4971typedef void (* double_to_uint_op_t)(double, unsigned int *, unsigned int *);
    50 typedef void (* float_binary_op_t)(float, float, float *, float_t *);
    51 typedef void (* double_binary_op_t)(double, double, double *, double_t *);
     72typedef void (* float_binary_op_t)(float, float, float *, float *);
     73typedef void (* float_cmp_op_t)(float, float, cmptype_t *, cmptype_t *);
     74typedef void (* double_binary_op_t)(double, double, double *, double *);
    5275typedef void (* double_cmp_op_t)(double, double, cmptype_t *, cmptype_t *);
    5376
    … …  
    6891
    6992static unsigned int uop_a[OPERANDS] = {
    70         4, -100, 100, 50, 1024, 0, 1000000, -1U, 0x80000000U, 500
     93        4, 2, 100, 50, 1024, 0, 1000000, 1, 0x8000000, 500
    7194};
    7295
    73 static cmptype_t cmpabs(cmptype_t a)
    74 {
    75         if (a >= 0)
    76                 return a;
    77        
    78         return -a;
    79 }
    80 
    81 static int dcmp(double a, double b)
     96static int fcmp(float a, float b)
    8297{
    8398        if (a < b)
    … …  
    90105}
    91106
     107static int dcmp(double a, double b)
     108{
     109        if (a < b)
     110                return -1;
     111       
     112        if (a > b)
     113                return 1;
     114       
     115        return 0;
     116}
     117
    92118static void uint_to_double_template(void *f, unsigned i, cmptype_t *pic,
    93119    cmptype_t *pisc)
    … …  
    96122       
    97123        double c;
    98         double_t sc;
     124        double sc;
    99125        op(uop_a[i], &c, &sc);
    100126       
    101127        *pic = (cmptype_t) (c * PRECISION);
    102         *pisc = (cmptype_t) (sc.val * PRECISION);
     128        *pisc = (cmptype_t) (sc * PRECISION);
    103129}
    104130
    … …  
    116142}
    117143
    118 
    119144static void float_template_binary(void *f, unsigned i, unsigned j,
    120145    cmptype_t *pic, cmptype_t *pisc)
    … …  
    123148       
    124149        float c;
    125         float_t sc;
     150        float sc;
    126151        op(fop_a[i], fop_a[j], &c, &sc);
    127152       
    128153        *pic = (cmptype_t) (c * PRECISION);
    129         *pisc = (cmptype_t) (sc.val * PRECISION);
     154        *pisc = (cmptype_t) (sc * PRECISION);
     155}
     156
     157static void float_compare_template(void *f, unsigned i, unsigned j,
     158    cmptype_t *pis, cmptype_t *piss)
     159{
     160        float_cmp_op_t op = (float_cmp_op_t) f;
     161       
     162        op(dop_a[i], dop_a[j], pis, piss);
    130163}
    131164
    … …  
    136169       
    137170        double c;
    138         double_t sc;
     171        double sc;
    139172        op(dop_a[i], dop_a[j], &c, &sc);
    140173       
    141174        *pic = (cmptype_t) (c * PRECISION);
    142         *pisc = (cmptype_t) (sc.val * PRECISION);
     175        *pisc = (cmptype_t) (sc * PRECISION);
    143176}
    144177
    … …  
    160193               
    161194                template(f, i, &ic, &isc);
    162                 cmptype_t diff = cmpabs(ic - isc);
     195                cmptype_t diff = ic - isc;
    163196               
    164197                if (diff != 0) {
    165                         TPRINTF("i=%u diff=%" PRIdCMPTYPE "\n", i, diff);
     198                        TPRINTF("i=%u ic=%" PRIdCMPTYPE " isc=%" PRIdCMPTYPE "\n",
     199                            i, ic, isc);
    166200                        correct = false;
    167201                }
    … …  
    181215                       
    182216                        template(f, i, j, &ic, &isc);
    183                         cmptype_t diff = cmpabs(ic - isc);
     217                        cmptype_t diff = ic - isc;
    184218                       
    185219                        if (diff != 0) {
    186                                 TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n",
    187                                     i, j, diff);
     220                                TPRINTF("i=%u, j=%u ic=%" PRIdCMPTYPE
     221                                    " isc=%" PRIdCMPTYPE "\n", i, j, ic, isc);
    188222                                correct = false;
    189223                        }
    … …  
    194228}
    195229
    196 static void uint_to_double_operator(unsigned int a, double *pc, double_t *psc)
     230static void uint_to_double_operator(unsigned int a, double *pc, double *psc)
    197231{
    198232        *pc = (double) a;
    199         psc->data = uint_to_double(a);
     233        *psc = uint_to_double(a);
    200234}
    201235
    … …  
    203237    unsigned int *psc)
    204238{
    205         double_t sa;
    206        
    207         sa.val = a;
    208        
    209239        *pc = (unsigned int) a;
    210         *psc = double_to_uint(sa.data);
     240        *psc = double_to_uint(a);
    211241}
    212242
    … …  
    214244    unsigned int *psc)
    215245{
    216         double_t sa;
    217        
    218         sa.val = a;
    219        
    220246        *pc = (int) a;
    221         *psc = double_to_int(sa.data);
    222 }
    223 
    224 static void float_add_operator(float a, float b, float *pc, float_t *psc)
     247        *psc = double_to_int(a);
     248}
     249
     250static void float_add_operator(float a, float b, float *pc, float *psc)
    225251{
    226252        *pc = a + b;
    227        
    228         float_t sa;
    229         float_t sb;
    230        
    231         sa.val = a;
    232         sb.val = b;
    233        
    234         if (sa.data.parts.sign == sb.data.parts.sign) {
    235                 psc->data = add_float(sa.data, sb.data);
    236         } else if (sa.data.parts.sign) {
    237                 sa.data.parts.sign = 0;
    238                 psc->data = sub_float(sb.data, sa.data);
    239         } else {
    240                 sb.data.parts.sign = 0;
    241                 psc->data = sub_float(sa.data, sb.data);
    242         }
    243 }
    244 
    245 static void float_mul_operator(float a, float b, float *pc, float_t *psc)
     253        *psc = add_float(a, b);
     254}
     255
     256static void float_sub_operator(float a, float b, float *pc, float *psc)
     257{
     258        *pc = a - b;
     259        *psc = sub_float(a, b);
     260}
     261
     262static void float_mul_operator(float a, float b, float *pc, float *psc)
    246263{
    247264        *pc = a * b;
    248        
    249         float_t sa;
    250         float_t sb;
    251        
    252         sa.val = a;
    253         sb.val = b;
    254         psc->data = mul_float(sa.data, sb.data);
    255 }
    256 
    257 static void float_div_operator(float a, float b, float *pc, float_t *psc)
     265        *psc = mul_float(a, b);
     266}
     267
     268static void float_div_operator(float a, float b, float *pc, float *psc)
    258269{
    259270        if ((cmptype_t) b == 0) {
    260271                *pc = 0.0;
    261                 psc->val = 0.0;
     272                *psc = 0.0;
    262273                return;
    263274        }
    264275       
    265276        *pc = a / b;
    266        
    267         float_t sa;
    268         float_t sb;
    269        
    270         sa.val = a;
    271         sb.val = b;
    272         psc->data = div_float(sa.data, sb.data);
    273 }
    274 
    275 static void double_add_operator(double a, double b, double *pc, double_t *psc)
    276 {
    277         *pc = a + b;
    278        
    279         double_t sa;
    280         double_t sb;
    281        
    282         sa.val = a;
    283         sb.val = b;
    284        
    285         if (sa.data.parts.sign == sb.data.parts.sign) {
    286                 psc->data = add_double(sa.data, sb.data);
    287         } else if (sa.data.parts.sign) {
    288                 sa.data.parts.sign = 0;
    289                 psc->data = sub_double(sb.data, sa.data);
    290         } else {
    291                 sb.data.parts.sign = 0;
    292                 psc->data = sub_double(sa.data, sb.data);
    293         }
    294 }
    295 
    296 static void double_mul_operator(double a, double b, double *pc, double_t *psc)
    297 {
    298         *pc = a * b;
    299        
    300         double_t sa;
    301         double_t sb;
    302        
    303         sa.val = a;
    304         sb.val = b;
    305         psc->data = mul_double(sa.data, sb.data);
    306 }
    307 
    308 static void double_div_operator(double a, double b, double *pc, double_t *psc)
    309 {
    310         if ((cmptype_t) b == 0) {
    311                 *pc = 0.0;
    312                 psc->val = 0.0;
    313                 return;
    314         }
    315        
    316         *pc = a / b;
    317        
    318         double_t sa;
    319         double_t sb;
    320        
    321         sa.val = a;
    322         sb.val = b;
    323         psc->data = div_double(sa.data, sb.data);
    324 }
    325 
    326 static void double_cmp_operator(double a, double b, cmptype_t *pis,
     277        *psc = div_float(a, b);
     278}
     279
     280static void float_cmp_operator(float a, float b, cmptype_t *pis,
    327281    cmptype_t *piss)
    328282{
    329         *pis = dcmp(a, b);
    330        
    331         double_t sa;
    332         double_t sb;
    333        
    334         sa.val = a;
    335         sb.val = b;
    336        
    337         if (is_double_lt(sa.data, sb.data))
     283        *pis = fcmp(a, b);
     284       
     285        if (is_float_lt(a, b) == -1)
    338286                *piss = -1;
    339         else if (is_double_gt(sa.data, sb.data))
     287        else if (is_float_gt(a, b) == 1)
    340288                *piss = 1;
    341         else if (is_double_eq(sa.data, sb.data))
     289        else if (is_float_eq(a, b) == 0)
    342290                *piss = 0;
    343291        else
    … …  
    345293}
    346294
     295static void double_add_operator(double a, double b, double *pc, double *psc)
     296{
     297        *pc = a + b;
     298        *psc = add_double(a, b);
     299}
     300
     301static void double_sub_operator(double a, double b, double *pc, double *psc)
     302{
     303        *pc = a - b;
     304        *psc = sub_double(a, b);
     305}
     306
     307static void double_mul_operator(double a, double b, double *pc, double *psc)
     308{
     309        *pc = a * b;
     310        *psc = mul_double(a, b);
     311}
     312
     313static void double_div_operator(double a, double b, double *pc, double *psc)
     314{
     315        if ((cmptype_t) b == 0) {
     316                *pc = 0.0;
     317                *psc = 0.0;
     318                return;
     319        }
     320       
     321        *pc = a / b;
     322        *psc = div_double(a, b);
     323}
     324
     325static void double_cmp_operator(double a, double b, cmptype_t *pis,
     326    cmptype_t *piss)
     327{
     328        *pis = dcmp(a, b);
     329       
     330        if (is_double_lt(a, b) == -1)
     331                *piss = -1;
     332        else if (is_double_gt(a, b) == 1)
     333                *piss = 1;
     334        else if (is_double_eq(a, b) == 0)
     335                *piss = 0;
     336        else
     337                *piss = 42;
     338}
     339
    347340const char *test_softfloat1(void)
    348341{
    349         const char *err = NULL;
     342        bool err = false;
    350343       
    351344        if (!test_template_binary(float_template_binary, float_add_operator)) {
    352                 err = "Float addition failed";
    353                 TPRINTF("%s\n", err);
     345                err = true;
     346                TPRINTF("%s\n", "Float addition failed");
     347        }
     348       
     349        if (!test_template_binary(float_template_binary, float_sub_operator)) {
     350                err = true;
     351                TPRINTF("%s\n", "Float addition failed");
    354352        }
    355353       
    356354        if (!test_template_binary(float_template_binary, float_mul_operator)) {
    357                 err = "Float multiplication failed";
    358                 TPRINTF("%s\n", err);
     355                err = true;
     356                TPRINTF("%s\n", "Float multiplication failed");
    359357        }
    360358       
    361359        if (!test_template_binary(float_template_binary, float_div_operator)) {
    362                 err = "Float division failed";
    363                 TPRINTF("%s\n", err);
     360                err = true;
     361                TPRINTF("%s\n", "Float division failed");
     362        }
     363       
     364        if (!test_template_binary(float_compare_template, float_cmp_operator)) {
     365                err = true;
     366                TPRINTF("%s\n", "Float comparison failed");
    364367        }
    365368       
    366369        if (!test_template_binary(double_template_binary, double_add_operator)) {
    367                 err = "Double addition failed";
    368                 TPRINTF("%s\n", err);
     370                err = true;
     371                TPRINTF("%s\n", "Double addition failed");
     372        }
     373       
     374        if (!test_template_binary(double_template_binary, double_sub_operator)) {
     375                err = true;
     376                TPRINTF("%s\n", "Double addition failed");
    369377        }
    370378       
    371379        if (!test_template_binary(double_template_binary, double_mul_operator)) {
    372                 err = "Double multiplication failed";
    373                 TPRINTF("%s\n", err);
     380                err = true;
     381                TPRINTF("%s\n", "Double multiplication failed");
    374382        }
    375383       
    376384        if (!test_template_binary(double_template_binary, double_div_operator)) {
    377                 err = "Double division failed";
    378                 TPRINTF("%s\n", err);
     385                err = true;
     386                TPRINTF("%s\n", "Double division failed");
    379387        }
    380388       
    381389        if (!test_template_binary(double_compare_template, double_cmp_operator)) {
    382                 err = "Double comparison failed";
    383                 TPRINTF("%s\n", err);
     390                err = true;
     391                TPRINTF("%s\n", "Double comparison failed");
    384392        }
    385393       
    386394        if (!test_template_unary(uint_to_double_template,
    387395            uint_to_double_operator)) {
    388                 err = "Conversion from unsigned int to double failed";
    389                 TPRINTF("%s\n", err);
     396                err = true;
     397                TPRINTF("%s\n", "Conversion from unsigned int to double failed");
    390398        }
    391399       
    392400        if (!test_template_unary(double_to_uint_template,
    393401            double_to_uint_operator)) {
    394                 err = "Conversion from double to unsigned int failed";
    395                 TPRINTF("%s\n", err);
     402                err = true;
     403                TPRINTF("%s\n", "Conversion from double to unsigned int failed");
    396404        }
    397405       
    398406        if (!test_template_unary(double_to_uint_template,
    399407            double_to_int_operator)) {
    400                 err = "Conversion from double to signed int failed";
    401                 TPRINTF("%s\n", err);
    402         }
    403        
    404         return err;
    405 }
     408                err = true;
     409                TPRINTF("%s\n", "Conversion from double to signed int failed");
     410        }
     411       
     412        if (err)
     413                return "Software floating point imprecision";
     414       
     415        return NULL;
     416}
Note: See TracChangeset for help on using the changeset viewer.