Changeset 9539be6 in mainline for uspace/lib


Ignore:
Timestamp:
2010-06-22T14:13:55Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
851f33a
Parents:
402eda5
Message:

autotool now also detects values of UINT_MAX and friends

Location:
uspace/lib
Files:
8 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/arch/abs32le/include/types.h

    r402eda5 r9539be6  
    4040#include <libarch/common.h>
    4141
     42#define SIZE_MIN  UINT32_MIN
     43#define SIZE_MAX  UINT32_MAX
     44
     45#define SSIZE_MIN  INT32_MIN
     46#define SSIZE_MAX  INT32_MAX
     47
    4248typedef uint32_t sysarg_t;
    4349

  • uspace/lib/c/arch/amd64/include/types.h

    r402eda5 r9539be6  
    4040#include <libarch/common.h>
    4141
     42#define SIZE_MIN  UINT64_MIN
     43#define SIZE_MAX  UINT64_MAX
     44
     45#define SSIZE_MIN  INT64_MIN
     46#define SSIZE_MAX  INT64_MAX
     47
    4248typedef uint64_t sysarg_t;
    4349

  • uspace/lib/c/arch/arm32/include/types.h

    r402eda5 r9539be6  
    4141#include <libarch/common.h>
    4242
     43#define SIZE_MIN  UINT32_MIN
     44#define SIZE_MAX  UINT32_MAX
     45
     46#define SSIZE_MIN  INT32_MIN
     47#define SSIZE_MAX  INT32_MAX
     48
    4349typedef uint32_t sysarg_t;
    4450

  • uspace/lib/c/arch/ia32/include/types.h

    r402eda5 r9539be6  
    4040#include <libarch/common.h>
    4141
     42#define SIZE_MIN  UINT32_MIN
     43#define SIZE_MAX  UINT32_MAX
     44
     45#define SSIZE_MIN  INT32_MIN
     46#define SSIZE_MAX  INT32_MAX
     47
    4248typedef uint32_t sysarg_t;
    4349

  • uspace/lib/c/arch/ia64/include/types.h

    r402eda5 r9539be6  
    4040#include <libarch/common.h>
    4141
     42#define SIZE_MIN  UINT64_MIN
     43#define SIZE_MAX  UINT64_MAX
     44
     45#define SSIZE_MIN  INT64_MIN
     46#define SSIZE_MAX  INT64_MAX
     47
    4248typedef struct {
    4349        uint64_t lo;

  • uspace/lib/c/arch/mips32/include/types.h

    r402eda5 r9539be6  
    4141#include <libarch/common.h>
    4242
     43#define SIZE_MIN  UINT32_MIN
     44#define SIZE_MAX  UINT32_MAX
     45
     46#define SSIZE_MIN  INT32_MIN
     47#define SSIZE_MAX  INT32_MAX
     48
    4349typedef uint32_t sysarg_t;
    4450

  • uspace/lib/c/arch/ppc32/include/types.h

    r402eda5 r9539be6  
    4040#include <libarch/common.h>
    4141
     42#define SIZE_MIN  UINT32_MIN
     43#define SIZE_MAX  UINT32_MAX
     44
     45#define SSIZE_MIN  INT32_MIN
     46#define SSIZE_MAX  INT32_MAX
     47
    4248typedef uint32_t sysarg_t;
    4349

  • uspace/lib/c/arch/sparc64/include/types.h

    r402eda5 r9539be6  
    4040#include <libarch/common.h>
    4141
     42#define SIZE_MIN  UINT64_MIN
     43#define SIZE_MAX  UINT64_MAX
     44
     45#define SSIZE_MIN  INT64_MIN
     46#define SSIZE_MAX  INT64_MAX
     47
    4248typedef uint64_t sysarg_t;
    4349

  • uspace/lib/c/generic/str.c

    r402eda5 r9539be6  
    3737#include <stdlib.h>
    3838#include <assert.h>
    39 #include <limits.h>
     39#include <stdint.h>
    4040#include <ctype.h>
    4141#include <malloc.h>

  • uspace/lib/c/include/stdint.h

    r402eda5 r9539be6  
    3636#define LIBC_STDINT_H_
    3737
    38 /* Definitions of types with fixed size */
     38#define INT8_MIN  (0x80)
     39#define INT8_MAX  (0x7F)
     40
     41#define UINT8_MIN  (0u)
     42#define UINT8_MAX  (0xFFu)
     43
     44#define INT16_MIN  (0x8000)
     45#define INT16_MAX  (0x7FFF)
     46
     47#define UINT16_MIN  (0u)
     48#define UINT16_MAX  (0xFFFFu)
     49
     50#define INT32_MIN  (0x80000000l)
     51#define INT32_MAX  (0x7FFFFFFFl)
     52
     53#define UINT32_MIN  (0ul)
     54#define UINT32_MAX  (0xFFFFFFFFul)
     55
     56#define INT64_MIN  (0x8000000000000000ll)
     57#define INT64_MAX  (0x7FFFFFFFFFFFFFFFll)
     58
     59#define UINT64_MIN  (0ull)
     60#define UINT64_MAX  (0xFFFFFFFFFFFFFFFFull)
     61
    3962#include <libarch/types.h>
    4063
    41 #define MAX_INT8 (0x7F)
    42 #define MIN_INT8 (0x80)
    43 #define MAX_UINT8 (0xFFu)
    44 #define MIN_UINT8 (0u)
     64/* off64_t */
     65#define OFF64_MIN  INT64_MIN
     66#define OFF64_MAX  INT64_MAX
    4567
    46 #define MAX_INT16 (0x7FFF)
    47 #define MIN_INT16 (0x8000)
    48 #define MAX_UINT16 (0xFFFFu)
    49 #define MIN_UINT16 (0u)
    50 
    51 #define MAX_INT32 (0x7FFFFFFF)
    52 #define MIN_INT32 (0x80000000)
    53 #define MAX_UINT32 (0xFFFFFFFFu)
    54 #define MIN_UINT32 (0u)
    55 
    56 #define MAX_INT64 (0x7FFFFFFFFFFFFFFFll)
    57 #define MIN_INT64 (0x8000000000000000ll)
    58 #define MAX_UINT64 (0xFFFFFFFFFFFFFFFFull)
    59 #define MIN_UINT64 (0ull)
     68/* aoff64_t */
     69#define AOFF64_MIN  UINT64_MIN
     70#define AOFF64_MAX  UINT64_MAX
    6071
    6172#endif

  • uspace/lib/pci/types.h

    r402eda5 r9539be6  
    1818
    1919#ifdef PCI_HAVE_64BIT_ADDRESS
    20 #include <limits.h>
     20
     21#include <stdint.h>
     22
    2123#if ULONG_MAX > 0xffffffff
     24
    2225typedef unsigned long u64;
    2326#define PCI_U64_FMT "l"
    24 #else
     27
     28#else /* ULONG_MAX > 0xffffffff */
     29
    2530typedef unsigned long long u64;
    2631#define PCI_U64_FMT "ll"
    27 #endif
    28 #endif
    2932
    30 #endif                          /* PCI_HAVE_Uxx_TYPES */
     33#endif /* ULONG_MAX > 0xffffffff */
     34#endif /* PCI_HAVE_64BIT_ADDRESS */
     35#endif /* PCI_HAVE_Uxx_TYPES */
    3136
    3237#ifdef PCI_HAVE_64BIT_ADDRESS
     38
    3339typedef u64 pciaddr_t;
    3440#define PCIADDR_T_FMT "%08" PCI_U64_FMT "x"
    3541#define PCIADDR_PORT_FMT "%04" PCI_U64_FMT "x"
    36 #else
     42
     43#else /* PCI_HAVE_64BIT_ADDRESS */
     44
    3745typedef u32 pciaddr_t;
    3846#define PCIADDR_T_FMT "%08x"
    3947#define PCIADDR_PORT_FMT "%04x"
    40 #endif
     48
     49#endif /* PCI_HAVE_64BIT_ADDRESS */
    4150
    4251#ifdef PCI_ARCH_SPARC64
     52
    4353/* On sparc64 Linux the kernel reports remapped port addresses and IRQ numbers */
    4454#undef PCIADDR_PORT_FMT
    4555#define PCIADDR_PORT_FMT PCIADDR_T_FMT
    4656#define PCIIRQ_FMT "%08x"
    47 #else
     57
     58#else /* PCI_ARCH_SPARC64 */
     59
    4860#define PCIIRQ_FMT "%d"
    49 #endif
     61
     62#endif /* PCI_ARCH_SPARC64 */

  • uspace/lib/socket/generic/socket_client.c

    r402eda5 r9539be6  
    4040#include <async.h>
    4141#include <fibril_synch.h>
    42 #include <limits.h>
     42#include <stdint.h>
    4343#include <stdlib.h>
    4444

  • uspace/lib/socket/generic/socket_core.c

    r402eda5 r9539be6  
    3535 */
    3636
    37 #include <limits.h>
     37#include <stdint.h>
    3838#include <stdlib.h>
    3939

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

    r402eda5 r9539be6  
    2727 */
    2828
    29 /** @addtogroup softfloat       
     29/** @addtogroup softfloat
    3030 * @{
    3131 */
    … …  
    4545        result.parts.sign = a.parts.sign;
    4646        result.parts.fraction = a.parts.fraction;
    47         result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE );
    48        
    49         if ((isFloat32Infinity(a))||(isFloat32NaN(a))) {
     47        result.parts.fraction <<= (FLOAT64_FRACTION_SIZE - FLOAT32_FRACTION_SIZE);
     48       
     49        if ((isFloat32Infinity(a)) || (isFloat32NaN(a))) {
    5050                result.parts.exp = 0x7FF;
    5151                /* TODO; check if its correct for SigNaNs*/
    … …  
    5353        };
    5454       
    55         result.parts.exp = a.parts.exp + ( (int)FLOAT64_BIAS - FLOAT32_BIAS );
     55        result.parts.exp = a.parts.exp + ((int) FLOAT64_BIAS - FLOAT32_BIAS);
    5656        if (a.parts.exp == 0) {
    5757                /* normalize denormalized numbers */
    … …  
    181181uint32_t float32_to_uint32(float32 a)
    182182{
    183         if (isFloat32NaN(a)) {
    184                 return MAX_UINT32;
    185         }
    186        
    187         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
    188                 if (a.parts.sign) {
    189                         return MIN_UINT32;
    190                 }
    191                 return MAX_UINT32;
    192         }
    193        
    194         return _float32_to_uint32_helper(a);   
     183        if (isFloat32NaN(a))
     184                return UINT32_MAX;
     185       
     186        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     187                if (a.parts.sign)
     188                        return UINT32_MIN;
     189               
     190                return UINT32_MAX;
     191        }
     192       
     193        return _float32_to_uint32_helper(a);
    195194}
    196195
    … …  
    201200int32_t float32_to_int32(float32 a)
    202201{
    203         if (isFloat32NaN(a)) {
    204                 return MAX_INT32;
    205         }
    206        
    207         if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS)))  {
    208                 if (a.parts.sign) {
    209                         return MIN_INT32;
    210                 }
    211                 return MAX_INT32;
    212         }
     202        if (isFloat32NaN(a))
     203                return INT32_MAX;
     204       
     205        if (isFloat32Infinity(a) || (a.parts.exp >= (32 + FLOAT32_BIAS))) {
     206                if (a.parts.sign)
     207                        return INT32_MIN;
     208               
     209                return INT32_MAX;
     210        }
     211       
    213212        return _float32_to_uint32_helper(a);
    214 }       
     213}
    215214
    216215
    … …  
    249248uint64_t float64_to_uint64(float64 a)
    250249{
    251         if (isFloat64NaN(a)) {
    252                 return MAX_UINT64;
    253         }
    254        
    255         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
    256                 if (a.parts.sign) {
    257                         return MIN_UINT64;
    258                 }
    259                 return MAX_UINT64;
    260         }
    261        
    262         return _float64_to_uint64_helper(a);   
     250        if (isFloat64NaN(a))
     251                return UINT64_MAX;
     252       
     253       
     254        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     255                if (a.parts.sign)
     256                        return UINT64_MIN;
     257               
     258                return UINT64_MAX;
     259        }
     260       
     261        return _float64_to_uint64_helper(a);
    263262}
    264263
    … …  
    269268int64_t float64_to_int64(float64 a)
    270269{
    271         if (isFloat64NaN(a)) {
    272                 return MAX_INT64;
    273         }
    274        
    275         if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
    276                 if (a.parts.sign) {
    277                         return MIN_INT64;
    278                 }
    279                 return MAX_INT64;
    280         }
     270        if (isFloat64NaN(a))
     271                return INT64_MAX;
     272       
     273       
     274        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
     275                if (a.parts.sign)
     276                        return INT64_MIN;
     277               
     278                return INT64_MAX;
     279        }
     280       
    281281        return _float64_to_uint64_helper(a);
    282 }       
     282}
    283283
    284284
    … …  
    320320uint64_t float32_to_uint64(float32 a)
    321321{
    322         if (isFloat32NaN(a)) {
    323                 return MAX_UINT64;
    324         }
    325        
    326         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
    327                 if (a.parts.sign) {
    328                         return MIN_UINT64;
    329                 }
    330                 return MAX_UINT64;
    331         }
    332        
    333         return _float32_to_uint64_helper(a);   
     322        if (isFloat32NaN(a))
     323                return UINT64_MAX;
     324       
     325       
     326        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     327                if (a.parts.sign)
     328                        return UINT64_MIN;
     329               
     330                return UINT64_MAX;
     331        }
     332       
     333        return _float32_to_uint64_helper(a);
    334334}
    335335
    … …  
    340340int64_t float32_to_int64(float32 a)
    341341{
    342         if (isFloat32NaN(a)) {
    343                 return MAX_INT64;
    344         }
    345        
    346         if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
    347                 if (a.parts.sign) {
    348                         return (MIN_INT64);
    349                 }
    350                 return MAX_INT64;
    351         }
     342        if (isFloat32NaN(a))
     343                return INT64_MAX;
     344       
     345        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
     346                if (a.parts.sign)
     347                        return INT64_MIN;
     348               
     349                return INT64_MAX;
     350        }
     351       
    352352        return _float32_to_uint64_helper(a);
    353 }       
     353}
    354354
    355355
    … …  
    360360uint32_t float64_to_uint32(float64 a)
    361361{
    362         if (isFloat64NaN(a)) {
    363                 return MAX_UINT32;
    364         }
    365        
    366         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
    367                 if (a.parts.sign) {
    368                         return MIN_UINT32;
    369                 }
    370                 return MAX_UINT32;
    371         }
    372        
    373         return (uint32_t)_float64_to_uint64_helper(a); 
     362        if (isFloat64NaN(a))
     363                return UINT32_MAX;
     364       
     365       
     366        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     367                if (a.parts.sign)
     368                        return UINT32_MIN;
     369               
     370                return UINT32_MAX;
     371        }
     372       
     373        return (uint32_t) _float64_to_uint64_helper(a);
    374374}
    375375
    … …  
    380380int32_t float64_to_int32(float64 a)
    381381{
    382         if (isFloat64NaN(a)) {
    383                 return MAX_INT32;
    384         }
    385        
    386         if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
    387                 if (a.parts.sign) {
    388                         return MIN_INT32;
    389                 }
    390                 return MAX_INT32;
    391         }
    392         return (int32_t)_float64_to_uint64_helper(a);
    393 }       
     382        if (isFloat64NaN(a))
     383                return INT32_MAX;
     384       
     385       
     386        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
     387                if (a.parts.sign)
     388                        return INT32_MIN;
     389               
     390                return INT32_MAX;
     391        }
     392       
     393        return (int32_t) _float64_to_uint64_helper(a);
     394}
    394395
    395396/** Convert unsigned integer to float32

  • uspace/lib/softint/generic/multiplication.c

    r402eda5 r9539be6  
    2929/** @addtogroup softint
    3030 * @{
    31  */ 
     31 */
    3232/**
    3333 * @file
    … …  
    3636
    3737#include <multiplication.h>
    38 #include <stdint.h> 
     38#include <stdint.h>
    3939
    40 /** Set 1 to return MAX_INT64 or MIN_INT64 on overflow */
     40/** Set 1 to return INT64_MAX or INT64_MIN on overflow */
    4141#ifndef SOFTINT_CHECK_OF
    42 # define SOFTINT_CHECK_OF 0
     42        #define SOFTINT_CHECK_OF 0
    4343#endif
    4444
    45 /**
    46  * Multiply two integers and return long long as result.
     45/** Multiply two integers and return long long as result.
     46 *
    4747 * This function is overflow safe.
    48  * @param a
    49  * @param b
    50  * @result
     48 *
    5149 */
    5250static unsigned long long mul(unsigned int a, unsigned int b) {
    53         unsigned int a1, a2, b1, b2;
    54         unsigned long long t1, t2, t3; 
    55 
    56         a1 = a >> 16;
    57         a2 = a & MAX_UINT16;
    58         b1 = b >> 16;
    59         b2 = b & MAX_UINT16;
    60 
    61         t1 = a1 * b1;
    62         t2 = a1*b2;
    63         t2 += a2*b1;
    64         t3 = a2*b2;
    65 
    66         t3 = (((t1 << 16) + t2) << 16) + t3;
    67 
     51        unsigned int a1 = a >> 16;
     52        unsigned int a2 = a & UINT16_MAX;
     53        unsigned int b1 = b >> 16;
     54        unsigned int b2 = b & UINT16_MAX;
     55       
     56        unsigned long long t1 = a1 * b1;
     57        unsigned long long t2 = a1 * b2;
     58        t2 += a2 * b1;
     59        unsigned long long t3 = a2 * b2;
     60       
     61        t3 = (((t1 << 16) + t2) << 16) + t3;
     62       
    6863        return t3;
    6964}
    … …  
    7469long long __muldi3 (long long a, long long b)
    7570{
    76         long long result;
    77         unsigned long long t1,t2;
    78         unsigned long long a1, a2, b1, b2;
    7971        char neg = 0;
    80 
     72       
    8173        if (a < 0) {
    8274                neg = !neg;
    8375                a = -a;
    8476        }
    85 
     77       
    8678        if (b < 0) {
    8779                neg = !neg;
    8880                b = -b;
    8981        }
    90 
    91         a1 = a >> 32;
    92         b1 = b >> 32;
    93 
    94         a2 = a & (MAX_UINT32);
    95         b2 = b & (MAX_UINT32);
    96 
     82       
     83        unsigned long long a1 = a >> 32;
     84        unsigned long long b1 = b >> 32;
     85       
     86        unsigned long long a2 = a & (UINT32_MAX);
     87        unsigned long long b2 = b & (UINT32_MAX);
     88       
    9789        if (SOFTINT_CHECK_OF && (a1 != 0) && (b1 != 0)) {
    98                 // error, overflow
    99                 return (neg?MIN_INT64:MAX_INT64);
     90                /* Error (overflow) */
     91                return (neg ? INT64_MIN : INT64_MAX);
    10092        }
    101 
    102         // (if OF checked) a1 or b1 is zero => result fits in 64 bits, no need to another overflow check
    103         t1 = mul(a1,b2) + mul(b1,a2);   
    104 
    105         if (SOFTINT_CHECK_OF && t1 > MAX_UINT32) {
    106                 // error, overflow
    107                 return (neg?MIN_INT64:MAX_INT64);
     93       
     94        /* (if OF checked) a1 or b1 is zero => result fits in 64 bits,
     95         * no need to another overflow check
     96         */
     97        unsigned long long t1 = mul(a1, b2) + mul(b1, a2);
     98       
     99        if ((SOFTINT_CHECK_OF) && (t1 > UINT32_MAX)) {
     100                /* Error (overflow) */
     101                return (neg ? INT64_MIN : INT64_MAX);
    108102        }
    109 
     103       
    110104        t1 = t1 << 32;
    111         t2 = mul(a2,b2);
     105        unsigned long long t2 = mul(a2, b2);
    112106        t2 += t1;
    113 
     107       
    114108        /* t2 & (1ull << 63) - if this bit is set in unsigned long long,
    115109         * result does not fit in signed one */
    116110        if (SOFTINT_CHECK_OF && ((t2 < t1) || (t2 & (1ull << 63)))) {
    117111                // error, overflow
    118                 return (neg?MIN_INT64:MAX_INT64);
     112                return (neg ? INT64_MIN : INT64_MAX);
    119113        }
    120 
    121         result = t2;
    122 
    123         if (neg) {
     114       
     115        long long result = t2;
     116        if (neg)
    124117                result = -result;
    125         }
    126 
     118       
    127119        return result;
    128 }       
     120}
    129121
    130122/** @}
Note: See TracChangeset for help on using the changeset viewer.