Changeset 777 for soft/giet_vm/giet_libs


Ignore:
Timestamp:
Feb 4, 2016, 6:25:22 PM (9 years ago)
Author:
meunier
Message:
  • Ajout de quelques fonction dans la lib math
  • Déplacement de certaines fonctions de stdlib vers string
Location:
soft/giet_vm/giet_libs
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/giet_libs/malloc.c

    r709 r777  
    88#include "malloc.h"
    99#include "stdio.h"
     10#include "stdlib.h"
    1011#include "giet_config.h"
    1112
    … …  
    214215
    215216////////////////////////////////////////
    216 void * remote_malloc( unsigned int size,
     217void * remote_malloc( int size,
    217218                      unsigned int x,
    218219                      unsigned int y )
    … …  
    278279#endif
    279280
    280     return (void*)base;
     281    return (void*) base;
    281282
    282283} // end remote_malloc()
    … …  
    284285
    285286//////////////////////////////////
    286 void * malloc( unsigned int size )
     287void * malloc( int size )
    287288{
    288289    // get cluster coordinates
    289     unsigned int    x;
    290     unsigned int    y;
    291     unsigned int    lpid;
     290    unsigned int x;
     291    unsigned int y;
     292    unsigned int lpid;
    292293    giet_proc_xyp( &x, &y, &lpid );
    293294
    294295    return remote_malloc( size, x, y );
    295296}
     297
     298
     299////////////////////////////////////
     300void * calloc ( int nbmem, int size )
     301{
     302    void * a = malloc( nbmem * size );
     303    memset( a, 0, nbmem * size );
     304    return a;
     305}
    296306
    297307///////////////////////////////////////////

  • soft/giet_vm/giet_libs/malloc.h

    r709 r777  
    9393                       unsigned int y );
    9494
    95 extern void* malloc( unsigned int size );
     95extern void * malloc( int size );
     96extern void * calloc( int nbmem,
     97                      int size );
    9698
    97 extern void* remote_malloc( unsigned int size,
    98                             unsigned int x,
    99                             unsigned int y );
     99extern void * remote_malloc( int size,
     100                             unsigned int x,
     101                             unsigned int y );
    100102
    101103extern void free(void * ptr);

  • soft/giet_vm/giet_libs/math.h

    r667 r777  
    77
    88double  fabs    (double x);
     9double  fmod    (double x, double y);
    910double  floor   (double x);
     11double  ceil    (double x);
    1012double  sin             (double x);
    1113double  cos             (double x);
    1214double  pow             (double x, double y);
     15double  exp     (double x);
    1316int             isnan   (double x);
    1417int             isfinite(double x);

  • soft/giet_vm/giet_libs/math/e_pow.c

    r682 r777  
    103103        int32_t i,j,k,yisint,n;
    104104        int32_t hx,hy,ix,iy;
    105         u_int32_t lx,ly;
     105        uint32_t lx,ly;
    106106
    107107        EXTRACT_WORDS(hx,lx,x);
    … …  
    180180
    181181    /* (x<0)**(non-int) is NaN */
    182         if(((((u_int32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x);
     182        if(((((uint32_t)hx>>31)-1)|yisint)==0) return (x-x)/(x-x);
    183183
    184184    /* |y| is huge */
    … …  
    251251
    252252        s = one; /* s (sign of result -ve**odd) = -1 else = 1 */
    253         if(((((u_int32_t)hx>>31)-1)|(yisint-1))==0)
     253        if(((((uint32_t)hx>>31)-1)|(yisint-1))==0)
    254254            s = -one;/* (-ve)**(odd int) */
    255255
    … …  
    312312{
    313313        double z = __ieee754_pow(x, y);
    314         if (isnan(y))
     314        if (isnan(y)) {
    315315                return z;
     316    }
    316317        if (isnan(x)) {
    317318                if (y == 0.0) {
    … …  
    322323        if (x == 0.0) {
    323324                if (y == 0.0) {
    324                         return 0; /* pow(0.0,0.0) */
     325            return 0; /* pow(0.0,0.0) */
    325326                }
    326327                if (isfinite(y) && y < 0.0) {
    … …  
    332333                if (isfinite(x) && isfinite(y)) {
    333334                        if (isnan(z)) {
    334                                 return 0.0/0.0; /* pow neg**non-int */
     335                                return 0.0 / 0.0; /* pow neg**non-int */
    335336                        }
    336337                        {
    337338                                double ret = huge;
    338339                                y *= 0.5;
    339                                 if(x<zero&&rint(y)!=y) ret = -huge;
     340                                if (x < zero && rint(y) !=y ) {
     341                    ret = -huge;
     342                }
    340343                                return ret;
    341344                        }
    … …  
    347350        return z;
    348351}
     352
     353/*
     354 * Pseudo exp function (QM)
     355 * There probably is a better implementation
     356 */
     357double exp(double x)
     358{
     359    const double e = 2.71828182846;
     360    return pow(e, x);
     361}
     362

  • soft/giet_vm/giet_libs/math/e_rem_pio2.c

    r581 r777  
    7575        double tx[3];
    7676        int32_t e0,i,j,nx,n,ix,hx;
    77         u_int32_t low;
     77        uint32_t low;
    7878
    7979        GET_HIGH_WORD(hx,x);            /* high word of x */
    … …  
    115115                y[0] = r-w;     /* quick check no cancellation */
    116116            } else {
    117                 u_int32_t high;
     117                uint32_t high;
    118118                j  = ix>>20;
    119119                y[0] = r-w;

  • soft/giet_vm/giet_libs/math/e_sqrt.c

    r581 r777  
    9393        int32_t sign = (int)0x80000000;
    9494        int32_t ix0,s0,q,m,t,i;
    95         u_int32_t r,t1,s1,ix1,q1;
     95        uint32_t r,t1,s1,ix1,q1;
    9696
    9797        EXTRACT_WORDS(ix0,ix1,x);
    … …  
    168168            if (z>=one) {
    169169                z = one+tiny;
    170                 if (q1==(u_int32_t)0xffffffff) { q1=0; q += 1;}
     170                if (q1==(uint32_t)0xffffffff) { q1=0; q += 1;}
    171171                else if (z>one) {
    172                     if (q1==(u_int32_t)0xfffffffe) q+=1;
     172                    if (q1==(uint32_t)0xfffffffe) q+=1;
    173173                    q1+=2;
    174174                } else

  • soft/giet_vm/giet_libs/math/math_private.h

    r588 r777  
    1616#define _MATH_PRIVATE_H_
    1717
    18 typedef unsigned int u_int32_t;
    19 
     18typedef unsigned int uint32_t;
    2019typedef int          int32_t;
     20typedef unsigned long long int uint64_t;
     21typedef long long int int64_t;
    2122
    2223/* The original fdlibm code used statements like:
    … …  
    5152  struct
    5253  {
    53     u_int32_t msw;
    54     u_int32_t lsw;
     54    uint32_t msw;
     55    uint32_t lsw;
    5556  } parts;
    5657} ieee_double_shape_type;
    … …  
    6465  struct
    6566  {
    66     u_int32_t lsw;
    67     u_int32_t msw;
     67    uint32_t lsw;
     68    uint32_t msw;
    6869  } parts;
    6970} ieee_double_shape_type;

  • soft/giet_vm/giet_libs/math/s_copysign.c

    r581 r777  
    2424double copysign(double x, double y)
    2525{
    26         u_int32_t hx,hy;
     26        uint32_t hx,hy;
    2727        GET_HIGH_WORD(hx,x);
    2828        GET_HIGH_WORD(hy,y);

  • soft/giet_vm/giet_libs/math/s_fabs.c

    r581 r777  
    2222double fabs(double x)
    2323{
    24         u_int32_t high;
     24        uint32_t high;
    2525        GET_HIGH_WORD(high,x);
    2626        SET_HIGH_WORD(x,high&0x7fffffff);

  • soft/giet_vm/giet_libs/math/s_finite.c

    r581 r777  
    2323int isfinite(double x)
    2424{
    25         u_int32_t hx;
     25        uint32_t hx;
    2626
    2727        GET_HIGH_WORD(hx, x);

  • soft/giet_vm/giet_libs/math/s_floor.c

    r581 r777  
    1111
    1212/* Modified for GIET-VM static OS at UPMC, France 2015.
    13  */
     13*/
    1414
    1515/*
    … …  
    2828double floor(double x)
    2929{
    30         int32_t i0,i1,j0;
    31         u_int32_t i,j;
    32         EXTRACT_WORDS(i0,i1,x);
    33         j0 = ((i0>>20)&0x7ff)-0x3ff;
    34         if(j0<20) {
    35             if(j0<0) {  /* raise inexact if x != 0 */
    36                 if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */
    37                     if(i0>=0) {i0=i1=0;}
    38                     else if(((i0&0x7fffffff)|i1)!=0)
    39                         { i0=0xbff00000;i1=0;}
    40                 }
    41             } else {
    42                 i = (0x000fffff)>>j0;
    43                 if(((i0&i)|i1)==0) return x; /* x is integral */
    44                 if(huge+x>0.0) {        /* raise inexact flag */
    45                     if(i0<0) i0 += (0x00100000)>>j0;
    46                     i0 &= (~i); i1=0;
    47                 }
    48             }
    49         } else if (j0>51) {
    50             if(j0==0x400) return x+x;   /* inf or NaN */
    51             else return x;              /* x is integral */
    52         } else {
    53             i = ((u_int32_t)(0xffffffff))>>(j0-20);
    54             if((i1&i)==0) return x;     /* x is integral */
    55             if(huge+x>0.0) {            /* raise inexact flag */
    56                 if(i0<0) {
    57                     if(j0==20) i0+=1;
    58                     else {
    59                         j = i1+(1<<(52-j0));
    60                         if(j<i1) i0 +=1 ;       /* got a carry */
    61                         i1=j;
    62                     }
    63                 }
    64                 i1 &= (~i);
    65             }
    66         }
    67         INSERT_WORDS(x,i0,i1);
    68         return x;
     30    int32_t i0, i1, j0;
     31    uint32_t i, j;
     32    EXTRACT_WORDS(i0, i1, x);
     33    j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
     34    if (j0 < 20) {
     35        if (j0 < 0) {   /* raise inexact if x != 0 */
     36            if (huge + x > 0.0) {/* return 0*sign(x) if |x|<1 */
     37                if (i0 >= 0) {
     38                    i0 = i1 = 0;
     39                }
     40                else if (((i0 & 0x7fffffff) | i1) != 0) {
     41                    i0 = 0xbff00000;
     42                    i1 = 0;
     43                }
     44            }
     45        }
     46        else {
     47            i = (0x000fffff) >> j0;
     48            if (((i0 & i) | i1) == 0) {
     49                return x; /* x is integral */
     50            }
     51            if (huge + x > 0.0) {       /* raise inexact flag */
     52                if (i0 < 0) {
     53                    i0 += (0x00100000) >> j0;
     54                }
     55                i0 &= (~i);
     56                i1 = 0;
     57            }
     58        }
     59    }
     60    else if (j0 > 51) {
     61        if (j0 == 0x400) {
     62            return x + x;       /* inf or NaN */
     63        }
     64        else {
     65            return x;           /* x is integral */
     66        }
     67    }
     68    else {
     69        i = ((uint32_t) (0xffffffff)) >> (j0 - 20);
     70        if ((i1 & i)== 0) {
     71            return x;   /* x is integral */
     72        }
     73        if (huge + x > 0.0) {           /* raise inexact flag */
     74            if (i0 < 0) {
     75                if (j0 == 20) {
     76                    i0 += 1;
     77                }
     78                else {
     79                    j = i1 + (1 << (52 - j0));
     80                    if (j < i1) {
     81                        i0 += 1 ;       /* got a carry */
     82                    }
     83                    i1 = j;
     84                }
     85            }
     86            i1 &= (~i);
     87        }
     88    }
     89    INSERT_WORDS(x, i0, i1);
     90    return x;
    6991}
    7092

  • soft/giet_vm/giet_libs/math/s_isnan.c

    r581 r777  
    2626        EXTRACT_WORDS(hx,lx,x);
    2727        hx &= 0x7fffffff;
    28         hx |= (u_int32_t)(lx|(-lx))>>31;
     28        hx |= (uint32_t)(lx|(-lx))>>31;
    2929        hx = 0x7ff00000 - hx;
    30         return (int)(((u_int32_t)hx)>>31);
     30        return (int)(((uint32_t)hx)>>31);
    3131}

  • soft/giet_vm/giet_libs/math/s_rint.c

    r581 r777  
    3535{
    3636        int32_t i0, j0, sx;
    37         u_int32_t i,i1;
     37        uint32_t i,i1;
    3838        double t;
    3939        /* We use w = x + 2^52; t = w - 2^52; trick to round x to integer.
    … …  
    4747        EXTRACT_WORDS(i0,i1,x);
    4848        /* Unbiased exponent */
    49         j0 = ((((u_int32_t)i0) >> 20)&0x7ff)-0x3ff;
     49        j0 = ((((uint32_t)i0) >> 20)&0x7ff)-0x3ff;
    5050
    5151        if (j0 > 51) {
    … …  
    5757
    5858        /* Sign */
    59         sx = ((u_int32_t)i0) >> 31;
     59        sx = ((uint32_t)i0) >> 31;
    6060
    6161        if (j0<20) {
    … …  
    8181            }
    8282        } else {
    83             i = ((u_int32_t)(0xffffffff))>>(j0-20);
     83            i = ((uint32_t)(0xffffffff))>>(j0-20);
    8484            if ((i1&i)==0) return x;    /* x is integral */
    8585            i>>=1;

  • soft/giet_vm/giet_libs/stdlib.c

    r772 r777  
    110110    }
    111111    return dst;
    112 }
    113 
    114 ///////////////////////////////////
    115 int strlen( const char* string )
    116 {
    117     unsigned int i = 0;
    118     while ( string[i] != 0 ) i++;
    119     return i;
    120 }
    121 
    122 ///////////////////////////////
    123 int strcmp( const char * s1,
    124             const char * s2 )
    125 {
    126     while (1)
    127     {
    128         if (*s1 != *s2) return 1;
    129         if (*s1 == 0)   break;
    130         s1++, s2++;
    131     }
    132     return 0;
    133 }
    134 
    135 /////////////////////////
    136 char* strcpy( char* dest,
    137               const char* source )
    138 {
    139     if (!dest || !source) return dest;
    140 
    141     while (*source)
    142     {
    143         *(dest) = *(source);
    144         dest++;
    145         source++;
    146     }
    147     *dest = 0;
    148     return dest;
    149112}
    150113

  • soft/giet_vm/giet_libs/stdlib.h

    r772 r777  
    4141              unsigned int size );
    4242
    43 ////////////////////////////////////////////////////////////////////////////////////////
    44 // This function returns the number of characters in a string.
    45 // The terminating NUL character is not taken into account.
    46 ////////////////////////////////////////////////////////////////////////////////////////
    47 int strlen( const char* string );
    48 
    49 ////////////////////////////////////////////////////////////////////////////////////////
    50 // This function compare the two s1 & s2 strings.
    51 // It returns 0 if strings are identical (including the terminating NUL character).
    52 // It returns 1 if they are not.
    53 ////////////////////////////////////////////////////////////////////////////////////////
    54 int strcmp( const char* s1,
    55             const char* s2 );
    56 
    57 ////////////////////////////////////////////////////////////////////////////////////////
    58 // This function copies the source string to the dest string.
    59 // It returns a pointer on the dest string.
    60 ////////////////////////////////////////////////////////////////////////////////////////
    61 char* strcpy( char* dest,
    62               const char* source );
    6343
    6444///////////////////////////////////////////////////////////////////////////////////////

  • soft/giet_vm/giet_libs/string.c

    r607 r777  
    77
    88///////////////////////////////////////////////////////////////////////////////////
    9 // char * strcpy ( char * destination, const char * source )
     9// char * strcpy (char * destination, const char * source)
    1010///////////////////////////////////////////////////////////////////////////////////
    11 char * strcpy ( char * destination, const char * source )
     11char * strcpy (char * destination, const char * source)
    1212{
    13     if (!destination || !source)
     13    if (!destination || !source) {
    1414        return destination;
     15    }
    1516
    16     while (*source)
     17    while (*source) {
    1718        *(destination++) = *(source++);
     19    }
    1820
    1921    return destination;
    2022}
    2123
     24
    2225///////////////////////////////////////////////////////////////////////////////////
    23 // int strcmp ( const char * str1, const char * str2 )
     26// char * strncpy (char * destination, const char * source, int maxlen)
    2427///////////////////////////////////////////////////////////////////////////////////
    25 int strcmp ( const char * str1, const char * str2 )
     28char * strncpy(char * dest, const char * src, int n)
    2629{
    27     if (!str1 || !str2)
     30    int i;
     31    for (i = 0; i < n && src[i] != '\0'; i++) {
     32        dest[i] = src[i];
     33    }
     34    for (; i < n ; i++) {
     35        dest[i] = '\0';
     36    }
     37    return dest;
     38}
     39
     40
     41///////////////////////////////////////////////////////////////////////////////////
     42// int strcmp (const char * str1, const char * str2)
     43///////////////////////////////////////////////////////////////////////////////////
     44int strcmp (const char * str1, const char * str2)
     45{
     46    if (!str1 || !str2) {
    2847        return -123456; // return a value out of the char's bounds
     48    }
    2949
    30     while (*str1 && *str1 == *str2)
    31     {
     50    while (*str1 && *str1 == *str2) {
    3251        str1++;
    3352        str2++;
    … …  
    4059// int strlen ( const char * str )
    4160///////////////////////////////////////////////////////////////////////////////////
    42 int strlen ( const char * str )
     61int strlen (const char * str)
    4362{
    44     const char *s = str;
     63    const char * s = str;
    4564
    46     while (*s)
     65    while (*s) {
    4766        s++;
    48 
     67    }
    4968    return (s - str);
    5069}
     70
     71
     72///////////////////////////////////////////////////////////////////////////////////
     73// char * strchr(const char * str)
     74///////////////////////////////////////////////////////////////////////////////////
     75char * strchr(const char * str, int c)
     76{
     77    const char * s = str;
     78    const char ch = c;
     79    while (*s != ch && *s != '\0') {
     80        s++;
     81    }
     82
     83    return (char *) s;
     84}
     85
    5186
    5287// Local Variables:

  • soft/giet_vm/giet_libs/string.h

    r607 r777  
    99#define _STRING_H
    1010
    11 char * strcpy ( char * destination, const char * source );
    12 int strcmp ( const char * str1, const char * str2 );
    13 int strlen ( const char * str );
     11////////////////////////////////////////////////////////////////////////////////////////
     12// This function copies the source string to the dest string.
     13// It returns a pointer on the dest string.
     14////////////////////////////////////////////////////////////////////////////////////////
     15char * strcpy(char * destination, const char * source);
     16
     17////////////////////////////////////////////////////////////////////////////////////////
     18// The strncpy() function is similar to strcpy, except that at most n bytes of src
     19// are copied. If there is no null byte among the first n bytes of src, the string
     20// placed in dest will not be null terminated.
     21////////////////////////////////////////////////////////////////////////////////////////
     22char * strncpy(char * dest, const char * src, int n);
     23
     24////////////////////////////////////////////////////////////////////////////////////////
     25//The strcmp() function compares the two strings s1 and s2.  It returns an integer less than, equal to, or greater than zero if s1 is found, respectively, to be less than, to match, or be greater than s2.
     26////////////////////////////////////////////////////////////////////////////////////////
     27int strcmp(const char * str1, const char * str2);
     28
     29////////////////////////////////////////////////////////////////////////////////////////
     30// This function returns the number of characters in a string.
     31// The terminating NULL character is not taken into account.
     32////////////////////////////////////////////////////////////////////////////////////////
     33int strlen(const char * str);
     34
     35////////////////////////////////////////////////////////////////////////////////////////
     36// The strchr() function returns a pointer to the first occurrence of the character c
     37// in the string s.
     38////////////////////////////////////////////////////////////////////////////////////////
     39char * strchr(const char * str, int c);
    1440
    1541#endif
Note: See TracChangeset for help on using the changeset viewer.