Changeset 191a190


Ignore:
Timestamp:
Aug 31, 2020, 5:20:49 PM (14 months ago)
Author:
m3zulfiq <m3zulfiq@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
49a980b
Parents:
b26144d
Message:

Removed a fill bug from alloc interface, changed pervious alloc tests (alloc.cfa) to comply with new alloc interface, added new tests for memory allocation (malloc.cfa and alloc2.cfa).

Files:
2 added
2 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/stdlib.hfa

    rb26144d r191a190  
    201201                        memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end );
    202202                } else if(Fill.tag == 't') {
    203                         for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
     203                        for ( int i = copy_end; i < Dim * size; i += size ) {
    204204                                memcpy( (char *)ptr + i, &Fill.t, size );
    205205                        }
     
    207207                        memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) );
    208208                } else if(Fill.tag == 'T') {
    209                         for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
     209                        for ( int i = copy_end; i < Dim * size; i += size ) {
    210210                                memcpy( (char *)ptr + i, Fill.at, size );
    211211                        }
  • tests/alloc.cfa

    rb26144d r191a190  
    4747        free( ip );
    4848
    49         ip = alloc_set( fill );                                                         // CFA alloc, fill
     49        ip = alloc( fill`fill );                                                                // CFA alloc, fill
    5050        printf( "CFA alloc, fill %08x\n", *ip );
    5151        free( ip );
    5252
    53         ip = alloc_set( 3 );                                                            // CFA alloc, fill
     53        ip = alloc( 3`fill );                                                           // CFA alloc, fill
    5454        printf( "CFA alloc, fill %d\n", *ip );
    5555        free( ip );
     
    7878        free( ip );
    7979
    80         ip = alloc_set( 2 * dim, fill );                                        // CFA array alloc, fill
     80        ip = alloc( 2 * dim, fill`fill );                                       // CFA array alloc, fill
    8181        printf( "CFA array alloc, fill %#hhx\n", fill );
    8282        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     
    8484        free( ip );
    8585
    86         ip = alloc_set( 2 * dim, 0xdeadbeef );                          // CFA array alloc, fill
     86        ip = alloc( 2 * dim, ((int)0xdeadbeef)`fill );                          // CFA array alloc, fill
    8787        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
    8888        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     
    9090        // do not free
    9191
    92         ip1 = alloc_set( 2 * dim, ip, 2 * dim );                                // CFA array alloc, fill
     92        ip1 = alloc( 2 * dim, [ip, 2 * dim]`fill );                             // CFA array alloc, fill
    9393        printf( "CFA array alloc, fill from array\n" );
    9494        for ( i; 2 * dim ) { printf( "%#x %#x, ", ip[i], ip1[i] ); }
     
    117117        printf( "\n" );
    118118
    119         ip = alloc( ip, dim );                                                          // CFA realloc array alloc
     119        ip = alloc( dim, ip`realloc );                                                          // CFA realloc array alloc
    120120        for ( i; dim ) { ip[i] = 0xdeadbeef; }
    121121        printf( "CFA realloc array alloc\n" );
     
    124124        // do not free
    125125
    126         ip = alloc( ip, 2 * dim );                                                      // CFA realloc array alloc
     126        ip = alloc( 2 * dim, ip`realloc );                                                      // CFA realloc array alloc
    127127        for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }         // fill upper part
    128128        printf( "CFA realloc array alloc\n" );
     
    131131        // do not free
    132132
    133         ip = alloc( ip, dim );                                                          // CFA realloc array alloc
     133        ip = alloc( dim, ip`realloc );                                                          // CFA realloc array alloc
    134134        printf( "CFA realloc array alloc\n" );
    135135        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     
    137137        // do not free
    138138
    139         ip = alloc_set( ip, 3 * dim, fill );                            // CFA realloc array alloc, fill
     139        ip = alloc( 3 * dim, ip`realloc, fill`fill );                           // CFA realloc array alloc, fill
    140140        printf( "CFA realloc array alloc, fill\n" );
    141141        for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
     
    143143        // do not free
    144144
    145         ip = alloc_set( ip, dim, fill );                                        // CFA realloc array alloc, fill
     145        ip = alloc( dim, ip`realloc, fill`fill );                                       // CFA realloc array alloc, fill
    146146        printf( "CFA realloc array alloc, fill\n" );
    147147        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     
    149149        // do not free
    150150
    151         ip = alloc_set( ip, 3 * dim, fill );                            // CFA realloc array alloc, fill
     151        ip = alloc( 3 * dim, ip`realloc, fill`fill );                           // CFA realloc array alloc, fill
    152152        printf( "CFA realloc array alloc, fill\n" );
    153153        for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
     
    155155        // do not free
    156156#if 0 // FIX ME
    157         ip = alloc_set( ip, 5 * dim, 5 );                                       // CFA realloc array alloc, 5
     157        ip = alloc( 5 * dim, ip`realloc, 5`fill );                                      // CFA realloc array alloc, 5
    158158        printf( "CFA realloc array alloc, 5\n" );
    159159        for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); }
     
    161161        // do not free
    162162
    163         ip = alloc_set( ip, dim, 5 );                                           // CFA realloc array alloc, 5
     163        ip = alloc( dim, ip`realloc, 5`fill );                                          // CFA realloc array alloc, 5
    164164        printf( "CFA realloc array alloc, 5\n" );
    165165        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     
    167167        // do not free
    168168
    169         ip = alloc_set( ip, 5 * dim, 5 );                                       // CFA realloc array alloc, 5
     169        ip = alloc( 5 * dim, ip`realloc, 5`fill );                                      // CFA realloc array alloc, 5
    170170        printf( "CFA realloc array alloc, 5\n" );
    171171        for ( i; 5 * dim ) { printf( "%#x ", ip[i] ); }
     
    182182    ip = alloc();
    183183        *ip = 5;
    184     double * dp = alloc( ip );
     184    double * dp = alloc( ip`resize );
    185185        *dp = 5.5;
    186     S * sp = alloc( dp );
     186    S * sp = alloc( dp`resize );
    187187        *sp = (S){ {0, 1, 2, 3, 4} };
    188     ip = alloc( sp );
     188    ip = alloc( sp`resize );
    189189        *ip = 3;
    190190    free( ip );
     
    195195    ip = alloc( 5 );
    196196        for ( i; 5 ) { ip[i] = 5; }
    197     dp = alloc( ip, 5 );
     197    dp = alloc( 5, ip`resize );
    198198        for ( i; 5 ) { dp[i] = 5.5; }
    199     sp = alloc( dp, 5 );
     199    sp = alloc( 5, dp`resize );
    200200        for ( i; 5 ) { sp[i] = (S){ {0, 1, 2, 3, 4} }; }
    201     ip = alloc( sp, 3 );
     201    ip = alloc( 3, sp`resize );
    202202        for ( i; 3 ) { ip[i] = 3; }
    203     ip = alloc( ip, 7 );
     203    ip = alloc( 7, ip`realloc );
    204204        for ( i; 7 ) { ip[i] = 7; }
    205     ip = alloc( ip, 7, false );
     205    ip = alloc( 7, ip`resize );
    206206        for ( i; 7 ) { ip[i] = 7; }
    207207    free( ip );
     
    237237        free( stp );
    238238
    239         stp = &(*alloc_align( Alignment)){ 42, 42.5 };          // CFA alloc_align
     239        stp = &(*alloc( Alignment`align)){ 42, 42.5 };          // CFA alloc_align
    240240        assert( (uintptr_t)stp % Alignment == 0 );
    241241        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    242242        free( stp );
    243243
    244         stp = &(*alloc_align( Alignment )){ 42, 42.5 };         // CFA alloc_align
     244        stp = &(*alloc( Alignment`align )){ 42, 42.5 };         // CFA alloc_align
    245245        assert( (uintptr_t)stp % Alignment == 0 );
    246246        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
    247247        free( stp );
    248248
    249         stp = alloc_align_set( Alignment, fill );                       // CFA memalign, fill
     249        stp = alloc( Alignment`align, fill`fill );                      // CFA memalign, fill
    250250        assert( (uintptr_t)stp % Alignment == 0 );
    251251        printf( "CFA alloc_align fill %#x %a\n", stp->x, stp->y );
    252252        free( stp );
    253253
    254         stp = alloc_align_set( Alignment, (Struct){ 42, 42.5 } ); // CFA memalign, fill
     254        stp = alloc( Alignment`align, (Struct){ 42, 42.5 }`fill ); // CFA memalign, fill
    255255        assert( (uintptr_t)stp % Alignment == 0 );
    256256        printf( "CFA alloc_align fill %d %g\n", stp->x, stp->y );
    257257        // do not free
    258258
    259         stp = &(*alloc_align( stp, 4096 )){ 42, 42.5 };         // CFA realign
     259        stp = &(*alloc( stp`realloc, 4096`align )){ 42, 42.5 };         // CFA realign
    260260        assert( (uintptr_t)stp % 4096 == 0 );
    261261        printf( "CFA alloc_align %d %g\n", stp->x, stp->y );
     
    266266        printf( "\n" );
    267267
    268         stp = alloc_align( Alignment, dim );                // CFA array memalign
     268        stp = alloc( dim, Alignment`align );                // CFA array memalign
    269269        assert( (uintptr_t)stp % Alignment == 0 );
    270270        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
     
    274274        free( stp );
    275275
    276         stp = alloc_align_set( Alignment, dim, fill );          // CFA array memalign, fill
     276        stp = alloc( dim, Alignment`align, fill`fill );         // CFA array memalign, fill
    277277        assert( (uintptr_t)stp % Alignment == 0 );
    278278        printf( "CFA array alloc_align, fill\n" );
     
    281281        free( stp );
    282282
    283         stp = alloc_align_set( Alignment, dim, (Struct){ 42, 42.5 } ); // CFA array memalign, fill
     283        stp = alloc( dim, Alignment`align, ((Struct){ 42, 42.5 })`fill ); // CFA array memalign, fill
    284284        assert( (uintptr_t)stp % Alignment == 0 );
    285285        printf( "CFA array alloc_align, fill\n" );
     
    288288        // do not free
    289289
    290         stp1 = alloc_align_set( Alignment, dim, stp, dim );     // CFA array memalign, fill
     290        stp1 = alloc( dim, Alignment`align, [stp, dim]`fill );  // CFA array memalign, fill
    291291        assert( (uintptr_t)stp % Alignment == 0 );
    292292        printf( "CFA array alloc_align, fill array\n" );
     
    295295        free( stp1 );
    296296
    297         stp = alloc_align( stp, 4096, dim );                            // CFA aligned realloc array
     297        stp = alloc( dim, stp`realloc, 4096`align );                            // CFA aligned realloc array
    298298        assert( (uintptr_t)stp % 4096 == 0 );
    299299        for ( i; dim ) { stp[i] = (Struct){ 42, 42.5 }; }
     
    325325        for ( i; dim ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
    326326        printf( "\n" );
    327 
    328327
    329328        // new, non-array types
Note: See TracChangeset for help on using the changeset viewer.