Changeset cfbc703 for tests/alloc.cfa


Ignore:
Timestamp:
Apr 1, 2020, 9:32:21 PM (19 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast, new-ast-unique-expr
Children:
6d43cdde
Parents:
5137f9f
Message:

add resize and more "alloc" routines

File:
1 edited

Legend:

Unmodified
Added
Removed
  • tests/alloc.cfa

    r5137f9f rcfbc703  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Feb 16 09:21:13 2020
    13 // Update Count     : 405
     12// Last Modified On : Wed Apr  1 10:58:35 2020
     13// Update Count     : 424
    1414//
    1515
     
    2828        size_t dim = 10;
    2929        char fill = '\xde';
    30         int * p, * p1;
     30        int * ip, * ip1;
    3131
    3232        // allocation, non-array types
    3333
    34         p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
    35         *p = 0xdeadbeef;
    36         printf( "C   malloc %#x\n", *p );
    37         free( p );
    38 
    39         p = malloc();                                       // CFA malloc, type safe
    40         *p = 0xdeadbeef;
    41         printf( "CFA malloc %#x\n", *p );
    42         free( p );
    43 
    44         p = alloc();                                        // CFA alloc, type safe
    45         *p = 0xdeadbeef;
    46         printf( "CFA alloc %#x\n", *p );
    47         free( p );
    48 
    49         p = alloc_set( fill );                                                          // CFA alloc, fill
    50         printf( "CFA alloc, fill %08x\n", *p );
    51         free( p );
    52 
    53         p = alloc_set( 3 );                                                                     // CFA alloc, fill
    54         printf( "CFA alloc, fill %d\n", *p );
    55         free( p );
     34        ip = (int *)malloc( sizeof(*ip) );                                      // C malloc, type unsafe
     35        *ip = 0xdeadbeef;
     36        printf( "C   malloc %#x\n", *ip );
     37        free( ip );
     38
     39        ip = malloc();                                                                          // CFA malloc, type safe
     40        *ip = 0xdeadbeef;
     41        printf( "CFA malloc %#x\n", *ip );
     42        free( ip );
     43
     44        ip = alloc();                                                                           // CFA alloc, type safe
     45        *ip = 0xdeadbeef;
     46        printf( "CFA alloc %#x\n", *ip );
     47        free( ip );
     48
     49        ip = alloc_set( fill );                                                         // CFA alloc, fill
     50        printf( "CFA alloc, fill %08x\n", *ip );
     51        free( ip );
     52
     53        ip = alloc_set( 3 );                                                            // CFA alloc, fill
     54        printf( "CFA alloc, fill %d\n", *ip );
     55        free( ip );
    5656
    5757
     
    5959        printf( "\n" );
    6060
    61         p = (int *)calloc( dim, sizeof( *p ) );                         // C array calloc, type unsafe
     61        ip = (int *)calloc( dim, sizeof( *ip ) );                       // C array calloc, type unsafe
    6262        printf( "C   array calloc, fill 0\n" );
    63         for ( i; dim ) { printf( "%#x ", p[i] ); }
    64         printf( "\n" );
    65         free( p );
    66 
    67         p = calloc( dim );                                  // CFA array calloc, type safe
     63        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     64        printf( "\n" );
     65        free( ip );
     66
     67        ip = calloc( dim );                                                                     // CFA array calloc, type safe
    6868        printf( "CFA array calloc, fill 0\n" );
    69         for ( i; dim ) { printf( "%#x ", p[i] ); }
    70         printf( "\n" );
    71         free( p );
    72 
    73         p = alloc( dim );                                   // CFA array alloc, type safe
    74         for ( i; dim ) { p[i] = 0xdeadbeef; }
     69        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     70        printf( "\n" );
     71        free( ip );
     72
     73        ip = alloc( dim );                                                                      // CFA array alloc, type safe
     74        for ( i; dim ) { ip[i] = 0xdeadbeef; }
    7575        printf( "CFA array alloc, no fill\n" );
    76         for ( i; dim ) { printf( "%#x ", p[i] ); }
    77         printf( "\n" );
    78         free( p );
    79 
    80         p = alloc_set( 2 * dim, fill );                                         // CFA array alloc, fill
     76        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     77        printf( "\n" );
     78        free( ip );
     79
     80        ip = alloc_set( 2 * dim, fill );                                        // CFA array alloc, fill
    8181        printf( "CFA array alloc, fill %#hhx\n", fill );
    82         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    83         printf( "\n" );
    84         free( p );
    85 
    86         p = alloc_set( 2 * dim, 0xdeadbeef );                           // CFA array alloc, fill
     82        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     83        printf( "\n" );
     84        free( ip );
     85
     86        ip = alloc_set( 2 * dim, 0xdeadbeef );                          // CFA array alloc, fill
    8787        printf( "CFA array alloc, fill %#hhx\n", 0xdeadbeef );
    88         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    89         printf( "\n" );
    90         // do not free
    91 
    92         p1 = alloc_set( 2 * dim, p );                                           // CFA array alloc, fill
     88        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     89        printf( "\n" );
     90        // do not free
     91
     92        ip1 = alloc_set( 2 * dim, ip );                                         // CFA array alloc, fill
    9393        printf( "CFA array alloc, fill from array\n" );
    94         for ( i; 2 * dim ) { printf( "%#x %#x, ", p[i], p1[i] ); }
    95         free( p1 );
    96         printf( "\n" );
     94        for ( i; 2 * dim ) { printf( "%#x %#x, ", ip[i], ip1[i] ); }
     95        free( ip1 );
     96        printf( "\n" );
     97
     98
     99        // realloc, non-array types
     100        printf( "\n" );
     101
     102        ip = (int *)realloc( ip, dim * sizeof(*ip) );           // C realloc
     103        printf( "C realloc\n" );
     104        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     105        printf( "\n" );
     106        // do not free
     107
     108        ip = realloc( ip, 2 * dim * sizeof(*ip) );                      // CFA realloc
     109        for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }
     110        printf( "CFA realloc\n" );
     111        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     112        printf( "\n" );
     113        // do not free
     114
     115
     116        // realloc, array types
     117        printf( "\n" );
     118
     119        ip = alloc( ip, dim );                                                          // CFA realloc array alloc
     120        for ( i; dim ) { ip[i] = 0xdeadbeef; }
     121        printf( "CFA realloc array alloc\n" );
     122        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     123        printf( "\n" );
     124        // do not free
     125
     126        ip = alloc( ip, 2 * dim );                                                      // CFA realloc array alloc
     127        for ( i; dim ~ 2 * dim ) { ip[i] = 0x1010101; }         // fill upper part
     128        printf( "CFA realloc array alloc\n" );
     129        for ( i; 2 * dim ) { printf( "%#x ", ip[i] ); }
     130        printf( "\n" );
     131        // do not free
     132
     133        ip = alloc( ip, dim );                                                          // CFA realloc array alloc
     134        printf( "CFA realloc array alloc\n" );
     135        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     136        printf( "\n" );
     137        // do not free
     138
     139        ip = alloc_set( ip, 3 * dim, fill );                            // CFA realloc array alloc, fill
     140        printf( "CFA realloc array alloc, fill\n" );
     141        for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
     142        printf( "\n" );
     143        // do not free
     144
     145        ip = alloc_set( ip, dim, fill );                                        // CFA realloc array alloc, fill
     146        printf( "CFA realloc array alloc, fill\n" );
     147        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     148        printf( "\n" );
     149        // do not free
     150
     151        ip = alloc_set( ip, 3 * dim, fill );                            // CFA realloc array alloc, fill
     152        printf( "CFA realloc array alloc, fill\n" );
     153        for ( i; 3 * dim ) { printf( "%#x ", ip[i] );; }
     154        printf( "\n" );
     155        // do not free
     156
     157        ip = alloc_set( ip, 3 * dim, 5 );                                       // CFA realloc array alloc, 5
     158        printf( "CFA realloc array alloc, 5\n" );
     159        for ( i; 3 * dim ) { printf( "%#x ", ip[i] ); }
     160        printf( "\n" );
     161        // do not free
     162
     163        ip = alloc_set( ip, dim, 5 );                                           // CFA realloc array alloc, 5
     164        printf( "CFA realloc array alloc, 5\n" );
     165        for ( i; dim ) { printf( "%#x ", ip[i] ); }
     166        printf( "\n" );
     167        // do not free
     168
     169        ip = alloc_set( ip, 3 * dim, 5 );                                       // CFA realloc array alloc, 5
     170        printf( "CFA realloc array alloc, 5\n" );
     171        for ( i; 3 * dim ) { printf( "%#x ", ip[i] );; }
     172        printf( "\n" );
     173        free( ip );
    97174
    98175
    99176        // resize, non-array types
    100         printf( "\n" );
    101 
    102         p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
    103         printf( "C realloc\n" );
    104         for ( i; dim ) { printf( "%#x ", p[i] ); }
    105         printf( "\n" );
    106         // do not free
    107 
    108         p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
    109         for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }
    110         printf( "CFA realloc\n" );
    111         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    112         printf( "\n" );
    113         // do not free
     177
     178        struct S {
     179                int a[5];
     180        };
     181
     182    ip = alloc();
     183        *ip = 5;
     184    double * dp = alloc( ip );
     185        *dp = 5.5;
     186    S * sp = alloc( dp );
     187        *sp = (S){ {0, 1, 2, 3, 4} };
     188    ip = alloc( sp );
     189        *ip = 3;
     190    free( ip );
    114191
    115192
    116193        // resize, array types
    117         printf( "\n" );
    118 
    119         p = alloc( p, dim );                                // CFA resize array alloc
    120         for ( i; dim ) { p[i] = 0xdeadbeef; }
    121         printf( "CFA resize array alloc\n" );
    122         for ( i; dim ) { printf( "%#x ", p[i] ); }
    123         printf( "\n" );
    124         // do not free
    125 
    126         p = alloc( p, 2 * dim );                            // CFA resize array alloc
    127         for ( i; dim ~ 2 * dim ) { p[i] = 0x1010101; }          // fill upper part
    128         printf( "CFA resize array alloc\n" );
    129         for ( i; 2 * dim ) { printf( "%#x ", p[i] ); }
    130         printf( "\n" );
    131         // do not free
    132 
    133         p = alloc( p, dim );                                // CFA resize array alloc
    134         printf( "CFA resize array alloc\n" );
    135         for ( i; dim ) { printf( "%#x ", p[i] ); }
    136         printf( "\n" );
    137         // do not free
    138 
    139         p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
    140         printf( "CFA resize array alloc\n" );
    141         for ( i; 3 * dim ) { printf( "%#x ", p[i] ); }
    142         printf( "\n" );
    143         // do not free
    144 
    145         p = alloc_set( p, dim, fill );                                          // CFA resize array alloc, fill
    146         printf( "CFA resize array alloc\n" );
    147         for ( i; dim ) { printf( "%#x ", p[i] ); }
    148         printf( "\n" );
    149         // do not free
    150 
    151         p = alloc_set( p, 3 * dim, fill );                                      // CFA resize array alloc, fill
    152         printf( "CFA resize array alloc, fill\n" );
    153         for ( i; 3 * dim ) { printf( "%#x ", p[i] );; }
    154         printf( "\n" );
    155         free( p );
     194
     195    ip = alloc( 5 );
     196        for ( i; 5 ) { ip[i] = 5; }
     197    dp = alloc( ip, 5 );
     198        for ( i; 5 ) { dp[i] = 5.5; }
     199    sp = alloc( dp, 5 );
     200        for ( i; 5 ) { sp[i] = (S){ {0, 1, 2, 3, 4} }; }
     201    ip = alloc( sp, 3 );
     202        for ( i; 3 ) { ip[i] = 3; }
     203    ip = alloc( ip, 7 );
     204        for ( i; 7 ) { ip[i] = 7; }
     205    ip = alloc( ip, 7, false );
     206        for ( i; 7 ) { ip[i] = 7; }
     207    free( ip );
    156208
    157209
     
    168220        free( stp );
    169221
    170         stp = &(*memalign( Alignment )){ 42, 42.5 };          // CFA memalign
     222        stp = &(*memalign( Alignment )){ 42, 42.5 };            // CFA memalign
    171223        assert( (uintptr_t)stp % Alignment == 0 );
    172224        printf( "CFA memalign %d %g\n", stp->x, stp->y );
     
    300352        free( fp - 1 );
    301353
    302         p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    303         *p = 0xdeadbeef;
    304         printf( "CFA deep malloc %#x\n", *p );
    305         free( p );
     354        ip = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
     355        *ip = 0xdeadbeef;
     356        printf( "CFA deep malloc %#x\n", *ip );
     357        free( ip );
    306358
    307359#ifdef ERR1
    308360        stp = malloc();
    309361        printf( "\nSHOULD FAIL\n" );
    310         p = realloc( stp, dim * sizeof( *stp ) );
    311         p = alloc( stp, dim * sizeof( *stp ) );
    312         p = memset( stp, 10 );
    313         p = memcpy( &st1, &st );
     362        ip = realloc( stp, dim * sizeof( *stp ) );
     363        ip = memset( stp, 10 );
     364        ip = memcpy( &st1, &st );
    314365#endif
    315366} // main
Note: See TracChangeset for help on using the changeset viewer.