Ignore:
Timestamp:
Aug 4, 2020, 12:53:48 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
Children:
954821df
Parents:
8395152 (diff), 2ff42f4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:
1 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/stdlib.hfa

    r8395152 r71dfe49  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul 21 07:58:05 2020
    13 // Update Count     : 475
     12// Last Modified On : Thu Jul 30 16:14:58 2020
     13// Update Count     : 490
    1414//
    1515
    … …  
    7171        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
    7272                $RE_SPECIALS( ptr, size, malloc, memalign );
    73                 return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
     73                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
     74                else return (T *)(void *)resize( (void *)ptr, _Alignof(T), size ); // CFA resize
    7475        } // resize
    7576
    7677        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
    7778                $RE_SPECIALS( ptr, size, malloc, memalign );
    78                 return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
     79                if ( _Alignof(T) <= libAlign() ) return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
     80                else return (T *)(void *)realloc( (void *)ptr, _Alignof(T), size ); // CFA realloc
    7981        } // realloc
    8082
    … …  
    121123        forall( dtype S | sized(S) )
    122124        T * alloc( S ptr[], size_t dim = 1 ) {                          // singleton/array resize
    123                 size_t len = malloc_usable_size( ptr );                 // current bucket size
    124                 if ( sizeof(T) * dim > len ) {                                  // not enough space ?
    125                         T * temp = alloc( dim );                                        // new storage
    126                         free( ptr );                                                            // free old storage
    127                         return temp;
    128                 } else {
    129                         return (T *)ptr;
    130                 } // if
    131         } // alloc
    132 
    133         T * alloc( T ptr[], size_t dim, bool copy = true ) {
     125                return resize( (T *)ptr, dim * sizeof(T) );             // CFA resize
     126        } // alloc
     127
     128        T * alloc( T ptr[], size_t dim = 1, bool copy = true ) {
    134129                if ( copy ) {
    135130                        return realloc( ptr, dim * sizeof(T) );         // CFA realloc
    … …  
    168163                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
    169164                } // if
    170                 return (T *)nptr;
     165                return nptr;
    171166        } // alloc_set
    172167
    … …  
    181176                        } // for
    182177                } // if
    183                 return (T *)nptr;
     178                return nptr;
    184179        } // alloc_align_set
    185180} // distribution
    … …  
    195190
    196191        T * alloc_align( T * ptr, size_t align ) {                      // aligned realloc array
    197                 return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA realloc
     192                return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA C realloc
    198193        } // alloc_align
    199194
    … …  
    232227                size_t osize = malloc_size( ptr );                              // current allocation
    233228                size_t nsize = dim * sizeof(T);                                 // new allocation
    234                 T * nptr = alloc_align( ptr, align, nsize );    // CFA alloc_align
     229                T * nptr = alloc_align( ptr, align, nsize );
    235230                if ( nsize > osize ) {                                                  // larger ?
    236231                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
    237232                } // if
    238                 return (T *)nptr;
     233                return nptr;
    239234        } // alloc_align_set
    240235
    … …  
    243238                size_t nsize = dim * sizeof(T);                                 // new allocation
    244239                size_t ndim = nsize / sizeof(T);                                // new dimension
    245                 T * nptr = alloc_align( ptr, align, nsize );            // CFA alloc_align
     240                T * nptr = alloc_align( ptr, align, nsize );
    246241                if ( ndim > odim ) {                                                    // larger ?
    247242                        for ( i; odim ~ ndim ) {
    … …  
    249244                        } // for
    250245                } // if
    251                 return (T *)nptr;
     246                return nptr;
    252247        } // alloc_align_set
    253248} // distribution
Note: See TracChangeset for help on using the changeset viewer.