Changeset b89c7c2


Ignore:
Timestamp:
Jul 19, 2020, 8:59:27 PM (14 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
eacf82c
Parents:
e310238
Message:

move realloc special cases into inline routines to access _Alignof, rewrite realloc routines to use malloc_size versus malloc_usable_size

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/stdlib.hfa

    re310238 rb89c7c2  
    99// Author           : Peter A. Buhr
    1010// Created On       : Thu Jan 28 17:12:35 2016
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Jun  2 16:47:00 2020
    13 // Update Count     : 451
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun Jul 19 18:29:34 2020
     13// Update Count     : 463
    1414//
    1515
     
    5757        } // calloc
    5858
    59         T * resize( T * ptr, size_t size ) {                            // CFA realloc, eliminate return-type cast
    60                 return (T *)(void *)resize( (void *)ptr, size ); // C realloc
     59        T * resize( T * ptr, size_t size ) {                            // CFA resize, eliminate return-type cast
     60                if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { // special cases
     61                        if ( unlikely( size == 0 ) ) free( ptr );
     62                        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
     63                        else return (T *)memalign( _Alignof(T), sizeof(T) );
     64                } // if
     65                return (T *)(void *)resize( (void *)ptr, size ); // CFA resize
    6166        } // resize
    6267
    6368        T * realloc( T * ptr, size_t size ) {                           // CFA realloc, eliminate return-type cast
     69                if ( unlikely( size == 0 ) || unlikely( ptr == 0p ) ) { // special cases
     70                        if ( unlikely( size == 0 ) ) free( ptr );
     71                        if ( _Alignof(T) <= libAlign() ) return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
     72                        else return (T *)memalign( _Alignof(T), sizeof(T) );
     73                } // if
    6474                return (T *)(void *)realloc( (void *)ptr, size ); // C realloc
    6575        } // realloc
     
    118128
    119129        T * alloc( T ptr[], size_t dim, bool copy = true ) {
    120                 if ( copy ) {                                                                   // realloc
    121                         return (T *)(void *)realloc( (void *)ptr, dim * sizeof(T) ); // C realloc
     130                if ( copy ) {
     131                        return realloc( ptr, dim * sizeof(T) );         // CFA realloc
    122132                } else {
    123                         return resize( ptr, dim * sizeof(T) );          // resize
     133                        return resize( ptr, dim * sizeof(T) );          // CFA resize
    124134                } // if
    125135        } // alloc
     
    146156                return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value
    147157        } // alloc
    148 } // distribution
    149 
    150 forall( dtype T | sized(T) ) {
    151         T * alloc_set( T ptr[], size_t dim, char fill );        // realloc array with fill
    152         T * alloc_set( T ptr[], size_t dim, T fill );           // realloc array with fill
     158
     159        T * alloc_set( T ptr[], size_t dim, char fill ) {       // realloc array with fill
     160                size_t osize = malloc_size( ptr );                              // current allocation
     161                T * nptr = realloc( ptr, dim * sizeof(T) );             // CFA realloc
     162                size_t nsize = malloc_size( nptr );                             // new allocation
     163                if ( nsize > osize ) {                                                  // larger ?
     164                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
     165                } // if
     166                return (T *)nptr;
     167        } // alloc_set
     168
     169        T * alloc_set( T ptr[], size_t dim, T & fill ) {        // realloc array with fill
     170                size_t odim = malloc_size( ptr ) / sizeof(T);   // current allocation
     171                T * nptr = realloc( ptr, dim * sizeof(T) );             // CFA realloc
     172                size_t ndim = malloc_size( nptr ) / sizeof(T);  // new allocation
     173                if ( ndim > odim ) {                                                    // larger ?
     174                        for ( i; odim ~ ndim ) {
     175                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
     176                        } // for
     177                } // if
     178                return (T *)nptr;
     179        } // alloc_align_set
    153180} // distribution
    154181
     
    196223                return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) );
    197224        } // alloc_align
    198 } // distribution
    199 
    200 forall( dtype T | sized(T) ) {
    201         T * alloc_align_set( T ptr[], size_t align, char fill ); // aligned realloc with fill
    202         T * alloc_align_set( T ptr[], size_t align, T fill ); // aligned realloc with fill
    203         T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ); // aligned realloc array with fill
    204         T * alloc_align_set( T ptr[], size_t align, size_t dim, T fill ); // aligned realloc array with fill
     225
     226        T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
     227                size_t osize = malloc_size( ptr );                              // current allocation
     228                T * nptr = realloc( ptr, align, dim * sizeof(T) ); // CFA realloc
     229                size_t nsize = malloc_size( nptr );                             // new allocation
     230                if ( nsize > osize ) {                                                  // larger ?
     231                        memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
     232                } // if
     233                return (T *)nptr;
     234        } // alloc_align_set
     235
     236        T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) {
     237                size_t odim = malloc_size( ptr ) / sizeof(T);   // current allocation
     238                T * nptr = realloc( ptr, align, dim * sizeof(T) ); // CFA realloc
     239                size_t ndim = malloc_size( nptr );                              // new allocation
     240                if ( ndim > odim ) {                                                    // larger ?
     241                        for ( i; odim ~ ndim ) {
     242                                memcpy( &nptr[i], &fill, sizeof(T) );   // initialize with fill value
     243                        } // for
     244                } // if
     245                return (T *)nptr;
     246        } // alloc_align_set
    205247} // distribution
    206248
Note: See TracChangeset for help on using the changeset viewer.