Ignore:
Timestamp:
Jan 20, 2021, 4:49:40 PM (9 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
454f478
Parents:
92bfda0 (diff), fd54fef (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

    r92bfda0 rdafbde8  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Dec 12 13:52:34 2020
    13 // Update Count     : 536
     12// Last Modified On : Sat Jan 16 09:07:10 2021
     13// Update Count     : 568
    1414//
    1515
     
    4848        else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
    4949
    50 static inline forall( dtype T | sized(T) ) {
     50static inline forall( T & | sized(T) ) {
    5151        // CFA safe equivalents, i.e., implicit size specification
    5252
     
    108108
    109109        1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following:
    110                 forall( dtype T | sized(T) ) {
     110                forall( T & | sized(T) ) {
    111111                        union  U_fill           { char c; T * a; T t; };
    112112                        struct S_fill           { char tag; U_fill(T) fill; };
     
    151151typedef struct S_resize                 { inline void *;  }     T_resize;
    152152
    153 forall( dtype T ) {
     153forall( T & ) {
    154154        struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
    155155        struct S_realloc        { inline T *; };
     
    159159static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
    160160
    161 static inline forall( dtype T | sized(T) ) {
     161static inline forall( T & | sized(T) ) {
    162162        S_fill(T) ?`fill ( T t ) {
    163163                S_fill(T) ret = { 't' };
    164164                size_t size = sizeof(T);
    165                 if(size > sizeof(ret.t)) { printf("ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n"); exit(1); }
     165                if ( size > sizeof(ret.t) ) {
     166                        abort( "ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n" );
     167                } // if
    166168                memcpy( &ret.t, &t, size );
    167169                return ret;
     
    173175        S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
    174176
    175         T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
     177        T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
    176178                T * ptr = NULL;
    177179                size_t size = sizeof(T);
     
    181183                        ptr = (T*) (void *) resize( (void *)Resize, Align, Dim * size );
    182184                } else if ( Realloc ) {
    183                         if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size);
    184                         ptr = (T*) (void *) realloc( (void *)Realloc, Align, Dim * size );
     185                        if ( Fill.tag != '0' ) copy_end = min(malloc_size( Realloc ), Dim * size );
     186                        ptr = (T *) (void *) realloc( (void *)Realloc, Align, Dim * size );
    185187                } else {
    186                         ptr = (T*) (void *) memalign( Align, Dim * size );
    187                 }
    188 
    189                 if(Fill.tag == 'c') {
     188                        ptr = (T *) (void *) memalign( Align, Dim * size );
     189                }
     190
     191                if ( Fill.tag == 'c' ) {
    190192                        memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end );
    191                 } else if(Fill.tag == 't') {
     193                } else if ( Fill.tag == 't' ) {
    192194                        for ( int i = copy_end; i < Dim * size; i += size ) {
    193 #pragma GCC diagnostic push
    194 #pragma GCC diagnostic ignored "-Warray-bounds"
    195 #pragma GCC diagnostic push
    196 #pragma GCC diagnostic ignored "-Wstringop-overflow="
    197                                 memcpy( (char *)ptr + i, &Fill.t, size );
    198 #pragma GCC diagnostic pop
    199 #pragma GCC diagnostic pop
     195                                #pragma GCC diagnostic push
     196                                #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
     197                                memcpy( (char *)ptr + i, &Fill.t, sizeof(Fill.t) );
     198                                #pragma GCC diagnostic pop
    200199                        }
    201                 } else if(Fill.tag == 'a') {
     200                } else if ( Fill.tag == 'a' ) {
    202201                        memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) );
    203                 } else if(Fill.tag == 'T') {
    204                         for ( int i = copy_end; i < Dim * size; i += size ) {
    205                                 memcpy( (char *)ptr + i, Fill.at, size );
    206                         }
     202                } else if ( Fill.tag == 'T' ) {
     203                        memcpy( (char *)ptr + copy_end, Fill.at, Dim * size );
    207204                }
    208205
     
    210207        } // $alloc_internal
    211208
    212         forall( ttype TT | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
     209        forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
    213210
    214211                T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
     
    239236} // distribution T
    240237
    241 static inline forall( dtype T | sized(T) ) {
     238static inline forall( T & | sized(T) ) {
    242239        // CFA safe initialization/copy, i.e., implicit size specification, non-array types
    243240        T * memset( T * dest, char fill ) {
     
    260257
    261258// CFA deallocation for multiple objects
    262 static inline forall( dtype T )                                                 // FIX ME, problems with 0p in list
     259static inline forall( T & )                                                     // FIX ME, problems with 0p in list
    263260void free( T * ptr ) {
    264261        free( (void *)ptr );                                                            // C free
    265262} // free
    266 static inline forall( dtype T, ttype TT | { void free( TT ); } )
     263static inline forall( T &, TT... | { void free( TT ); } )
    267264void free( T * ptr, TT rest ) {
    268265        free( ptr );
     
    271268
    272269// CFA allocation/deallocation and constructor/destructor, non-array types
    273 static inline forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } )
     270static inline forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } )
    274271T * new( TT p ) {
    275272        return &(*(T *)malloc()){ p };                                                  // run constructor
    276273} // new
    277274
    278 static inline forall( dtype T | { void ^?{}( T & ); } )
     275static inline forall( T & | { void ^?{}( T & ); } )
    279276void delete( T * ptr ) {
    280277        // special case for 0-sized object => always call destructor
     
    284281        free( ptr );                                                                            // always call free
    285282} // delete
    286 static inline forall( dtype T, ttype TT | { void ^?{}( T & ); void delete( TT ); } )
     283static inline forall( T &, TT... | { void ^?{}( T & ); void delete( TT ); } )
    287284void delete( T * ptr, TT rest ) {
    288285        delete( ptr );
     
    291288
    292289// CFA allocation/deallocation and constructor/destructor, array types
    293 forall( dtype T | sized(T), ttype TT | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
    294 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
    295 forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype TT | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
     290forall( T & | sized(T), TT... | { void ?{}( T &, TT ); } ) T * anew( size_t dim, TT p );
     291forall( T & | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
     292forall( T & | sized(T) | { void ^?{}( T & ); }, TT... | { void adelete( TT ); } ) void adelete( T arr[], TT rest );
    296293
    297294//---------------------------------------
     
    333330//---------------------------------------
    334331
    335 forall( otype E | { int ?<?( E, E ); } ) {
     332forall( E | { int ?<?( E, E ); } ) {
    336333        E * bsearch( E key, const E * vals, size_t dim );
    337334        size_t bsearch( E key, const E * vals, size_t dim );
     
    342339} // distribution
    343340
    344 forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } ) {
     341forall( K, E | { int ?<?( K, K ); K getKey( const E & ); } ) {
    345342        E * bsearch( K key, const E * vals, size_t dim );
    346343        size_t bsearch( K key, const E * vals, size_t dim );
     
    351348} // distribution
    352349
    353 forall( otype E | { int ?<?( E, E ); } ) {
     350forall( E | { int ?<?( E, E ); } ) {
    354351        void qsort( E * vals, size_t dim );
    355352} // distribution
Note: See TracChangeset for help on using the changeset viewer.