Changeset 6065b3aa for src/tests


Ignore:
Timestamp:
Jun 1, 2017, 10:58:18 PM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
49c9773
Parents:
6016c87
Message:

second attempt at memory-allocation routines

Location:
src/tests
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • src/tests/.expect/alloc.txt

    r6016c87 r6065b3aa  
    1 C   malloc deadbeef
    2 CFA malloc 0
    3 CFA malloc, fill 01010101
     1C   malloc 0xdeadbeef
     2CFA malloc 0xdeadbeef
     3CFA alloc 0xdeadbeef
     4CFA alloc, fill 01010101
    45
    5 C   calloc
     6C   array calloc, fill 0
    670 0 0 0 0 0 0 0 0 0
    7 CFA calloc
     8CFA array calloc, fill 0
    890 0 0 0 0 0 0 0 0 0
    9 CFA array malloc
    10 0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    11 CFA array malloc
    12 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
     10CFA array alloc, no fill
     110xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     12CFA array alloc, fill 0x1
     130x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    1314
    14 C   realloc
    15 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    16 CFA realloc
    17 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0
    18 CFA realloc
    19 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    20 CFA resize malloc
    21 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    22 CFA resize malloc, fill
    23 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
    24 CFA resize malloc, fill
    25 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     15C   realloc 40
     160xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     17CFA realloc 88
     180xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    2619
    27 CFA resize array malloc
    28 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0
    29 CFA resize array malloc
    30 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
    31 CFA resize array malloc, fill
    32 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101
    33 CFA resize array malloc, fill
    34 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef
     20CFA resize alloc 40
     210xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     22CFA resize array alloc 88
     230xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     24CFA resize array alloc 40
     250xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef
     26CFA resize array alloc 40, fill
     270x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     28CFA resize array alloc 88, fill
     290x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
     30CFA resize array alloc 40, fill
     310x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101
    3532
    36 CFA aligned_alloc 42 42.5
     33C   memalign 42 42.5
    3734CFA memalign 42 42.5
    3835CFA posix_memalign 42 42.5
    39 CFA memalign fill 16843009 7.7486e-304
     36CFA posix_memalign 42 42.5
     37CFA aligned_alloc 42 42.5
     38CFA align_alloc 42 42.5
     39CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007
    4040
    41 CFA memalign array
    42 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0, 0 0,
    43 CFA memalign array
    44 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304, 1010101 7.7486e-304,
     41CFA array align_alloc
     4242 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
     43CFA array align_alloc, fill
     440x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,
    4545
    46 CFA memset ffffffff -nan
    47 CFA memcpy ffffffff -nan
     46CFA memset 0x1010101 0x1.1010101010101p-1007
     47CFA memcpy 0x1010101 0x1.1010101010101p-1007
    4848
    4949CFA array memset
    50 ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan,
     500x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,
    5151CFA memcpy
    52 deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2, deadbeef -17.2,
     520x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,
     53
     54CFA new initialize
     5542 42.5 42 42.5
     56CFA array new initialize
     5742 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
     5842 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5,
     59
    5360pointer arithmetic 0
    54 CFA deep malloc deadbeef
     61CFA deep malloc 0xdeadbeef
    5562
    5663SHOULD FAIL

  • src/tests/alloc.c

    r6016c87 r6065b3aa  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon May 29 11:33:15 2017
    13 // Update Count     : 228
     12// Last Modified On : Thu Jun  1 21:33:49 2017
     13// Update Count     : 315
    1414//
    1515
    … …  
    1818#include <malloc.h>                                                                             // malloc_usable_size
    1919#include <stdint.h>                                                                             // uintptr_t
     20#include <stdlib.h>                                                                             // posix_memalign
    2021} // extern
    2122#include <fstream>
    … …  
    2829int main( void ) {
    2930    size_t dim = 10;
    30     struct S { int x; double y; } * s;
    3131    int * p;
     32        char fill = '\1';
    3233
    3334        // allocation, non-array types
    … …  
    3536    p = (void *)malloc( sizeof(*p) );                                   // C malloc, type unsafe
    3637        *p = 0xdeadbeef;
    37         printf( "C   malloc %x\n", *p );
     38        printf( "C   malloc %#x\n", *p );
    3839    free( p );
    3940
    4041    p = malloc();                                                                               // CFA malloc, type safe
    41         printf( "CFA malloc %d\n", *p );
    42     free( p );
    43 
    44     p = malloc( '\1' );                                                                 // CFA malloc, fill
    45         printf( "CFA malloc, fill %08x\n", *p );
     42        *p = 0xdeadbeef;
     43        printf( "CFA malloc %#x\n", *p );
     44    free( p );
     45
     46    p = alloc();                                                                                // CFA alloc, type safe
     47        *p = 0xdeadbeef;
     48        printf( "CFA alloc %#x\n", *p );
     49    free( p );
     50
     51    p = alloc( fill );                                                                  // CFA alloc, fill
     52        printf( "CFA alloc, fill %08x\n", *p );
    4653
    4754
    … …  
    5057
    5158    p = calloc( dim, sizeof( *p ) );                                    // C array calloc, type unsafe
    52         printf( "C   calloc\n" );
    53         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     59        printf( "C   array calloc, fill 0\n" );
     60        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    5461        printf( "\n" );
    5562    free( p );
    5663
    5764    p = calloc( dim );                                                                  // CFA array calloc, type safe
    58         printf( "CFA calloc\n" );
    59         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    60         printf( "\n" );
    61     free( p );
    62 
    63     p = amalloc( dim );                                                                 // CFA array malloc, type safe
    64         printf( "CFA array malloc\n" );
    65         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    66         printf( "\n" );
    67     free( p );
    68 
    69     p = amalloc( 2 * dim, '\1' );                                               // CFA array malloc, fill
    70         printf( "CFA array malloc\n" );
    71         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     65        printf( "CFA array calloc, fill 0\n" );
     66        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     67        printf( "\n" );
     68    free( p );
     69
     70    p = alloc( dim );                                                                   // CFA array alloc, type safe
     71        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     72        printf( "CFA array alloc, no fill\n" );
     73        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     74        printf( "\n" );
     75    free( p );
     76
     77    p = alloc( 2 * dim, fill );                                                 // CFA array alloc, fill
     78        printf( "CFA array alloc, fill %#x\n", fill );
     79        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    7280        printf( "\n" );
    7381        // do not free
    … …  
    7785        printf( "\n" );
    7886
    79     p = (void *)realloc( p, dim * sizeof(*p) );                 // CFA realloc
    80         printf( "C   realloc\n" );
    81         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     87    p = (void *)realloc( p, dim * sizeof(*p) );                 // C realloc
     88        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     89        printf( "C   realloc %ld\n", malloc_usable_size( p ) );
     90        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    8291        printf( "\n" );
    8392
    8493    p = realloc( p, 2 * dim * sizeof(*p) );                             // CFA realloc
    85         printf( "CFA realloc\n" );
    86         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    87         printf( "\n" );
    88 
    89     p = realloc( p, dim * sizeof(*p), '\1' );                   // CFA realloc
    90         printf( "CFA realloc\n" );
    91         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    92         printf( "\n" );
    93 
    94     p = malloc( p, dim * sizeof(*p) );                                  // CFA malloc
    95         printf( "CFA resize malloc\n" );
    96         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    97         printf( "\n" );
    98 
    99     p = malloc( p, 2 * dim * sizeof(*p), '\1' );                // CFA malloc, fill
    100         printf( "CFA resize malloc, fill\n" );
    101         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    102         printf( "\n" );
    103 
    104     p = malloc( p, dim * sizeof(*p), '\1' );                    // CFA malloc, fill
    105         printf( "CFA resize malloc, fill\n" );
    106         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     94        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     95        printf( "CFA realloc %ld\n", malloc_usable_size( p ) );
     96        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
    10797        printf( "\n" );
    10898        // do not free
    … …  
    112102        printf( "\n" );
    113103
    114     p = amalloc( p, 2 * dim );                                                  // CFA array malloc
    115         printf( "CFA resize array malloc\n" );
    116         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    117         printf( "\n" );
    118 
    119     p = amalloc( p, dim );                                                              // CFA array malloc
    120         printf( "CFA resize array malloc\n" );
    121         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    122         printf( "\n" );
    123 
    124     p = amalloc( p, 2 * dim, '\1' );                                    // CFA array malloc, fill
    125         printf( "CFA resize array malloc, fill\n" );
    126         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
    127         printf( "\n" );
    128 
    129     p = amalloc( p, dim, '\1' );                                                // CFA array malloc, fill
    130         printf( "CFA resize array malloc, fill\n" );
    131         for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; }
     104    p = alloc( p, dim );                                                                // CFA resize array alloc
     105        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
     106        printf( "CFA resize alloc %ld\n", malloc_usable_size( p ) );
     107        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     108        printf( "\n" );
     109
     110    p = alloc( p, 2 * dim );                                                    // CFA resize array alloc
     111        for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
     112        printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
     113        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     114        printf( "\n" );
     115
     116    p = alloc( p, dim );                                                                // CFA array alloc
     117        printf( "CFA resize array alloc %ld\n", malloc_usable_size( p ) );
     118        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     119        printf( "\n" );
     120
    132121        free( p );
    133         printf( "\n" );
     122        p = 0;
     123
     124    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     125        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
     126        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
     127        printf( "\n" );
     128
     129    p = alloc( p, 2 * dim, fill );                                              // CFA array alloc, fill
     130        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
     131        for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
     132        printf( "\n" );
     133
     134    p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
     135        printf( "CFA resize array alloc %ld, fill\n", malloc_usable_size( p ) );
     136        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
     137        printf( "\n" );
     138        free( p );
     139
    134140
    135141    struct Struct { int x; double y; };
    136     Struct st, st1, sta[dim], sta1[dim], * stp;
    137 
     142    Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
    138143
    139144        // alignment, non-array types
    140145        printf( "\n" );
    141 
    142146        enum { Alignment = 128 };
    143     stp = aligned_alloc( Alignment );                                   // CFA aligned_alloc
     147
     148    stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
     149        assert( (uintptr_t)stp % Alignment == 0 );
     150        printf( "C   memalign %d %g\n", stp->x, stp->y );
     151    free( stp );
     152
     153    stp = (memalign( Alignment )){ 42, 42.5 };                  // CFA memalign
     154        assert( (uintptr_t)stp % Alignment == 0 );
     155        printf( "CFA memalign %d %g\n", stp->x, stp->y );
     156    free( stp );
     157
     158    posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
    144159        *stp = (Struct){ 42, 42.5 };
    145160        assert( (uintptr_t)stp % Alignment == 0 );
    146         printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
    147     free( stp );
    148 
    149     stp = memalign( Alignment );                                                // CFA memalign
    150         *stp = (Struct){ 42, 42.5 };
    151         assert( (uintptr_t)stp % Alignment == 0 );
    152         printf( "CFA memalign %d %g\n", stp->x, stp->y );
     161        printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
    153162    free( stp );
    154163
    … …  
    159168    free( stp );
    160169
    161     stp = memalign( Alignment, '\1' );                                  // CFA memalign, fill
    162         assert( (uintptr_t)stp % Alignment == 0 );
    163         printf( "CFA memalign fill %d %g\n", stp->x, stp->y );
     170    stp = (aligned_alloc( Alignment )){ 42, 42.5 };             // CFA aligned_alloc
     171        assert( (uintptr_t)stp % Alignment == 0 );
     172        printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
     173    free( stp );
     174
     175    stp = (align_alloc( Alignment )){ 42, 42.5 };               // CFA align_alloc
     176        assert( (uintptr_t)stp % Alignment == 0 );
     177        printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
     178    free( stp );
     179
     180    stp = align_alloc( Alignment, fill );                               // CFA memalign, fill
     181        assert( (uintptr_t)stp % Alignment == 0 );
     182        printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
    164183    free( stp );
    165184
    … …  
    168187        printf( "\n" );
    169188
    170     stp = amemalign( Alignment, 2 * dim );                              // CFA array memalign
    171         assert( (uintptr_t)stp % Alignment == 0 );
    172         printf( "CFA memalign array\n" );
    173         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; }
    174         printf( "\n" );
    175     free( stp );
    176 
    177     stp = amemalign( Alignment, dim, '\1' );                    // CFA array memalign, fill
    178         assert( (uintptr_t)stp % Alignment == 0 );
    179         printf( "CFA memalign array\n" );
    180         for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", stp[i].x, stp[i].y ); stp[i].x = 0Xdeadbeef, stp[i].y = -17.2; }
     189    stp = align_alloc( Alignment, dim );                                // CFA array memalign
     190        assert( (uintptr_t)stp % Alignment == 0 );
     191        for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
     192        printf( "CFA array align_alloc\n" );
     193        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     194        printf( "\n" );
     195    free( stp );
     196
     197    stp = align_alloc( Alignment, dim, fill );                  // CFA array memalign, fill
     198        assert( (uintptr_t)stp % Alignment == 0 );
     199        printf( "CFA array align_alloc, fill\n" );
     200        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
    181201        printf( "\n" );
    182202    free( stp );
    … …  
    186206        printf( "\n" );
    187207
    188     stp = memset( &st, '\xff' );                                                // CFA memset, type safe
    189         printf( "CFA memset %x %g\n", st.x, st.y );
    190     stp = memcpy( &st1, &st );                                                  // CFA memcpy, type safe
    191         printf( "CFA memcpy %x %g\n", st1.x, st1.y );
     208    memset( &st, fill );                                                                // CFA memset, type safe
     209        printf( "CFA memset %#x %a\n", st.x, st.y );
     210    memcpy( &st1, &st );                                                                // CFA memcpy, type safe
     211        printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
    192212
    193213
    … …  
    195215        printf( "\n" );
    196216
    197     stp = amemset( sta, dim, '\xff' );                                  // CFA array memset, type safe
     217    memset( sta, dim, fill );                                                   // CFA array memset, type safe
    198218        printf( "CFA array memset\n" );
    199         for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta[i].x, sta[i].y ); sta[i].x = 0Xdeadbeef, sta[i].y = -17.2; }
    200         printf( "\n" );
    201 
    202     stp = amemcpy( sta1, sta, dim );                                    // CFA array memcpy, type safe
     219        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
     220        printf( "\n" );
     221
     222    memcpy( sta1, sta, dim );                                                   // CFA array memcpy, type safe
    203223        printf( "CFA memcpy\n" );
    204         for ( int i = 0; i < dim; i += 1 ) { printf( "%x %g, ", sta1[i].x, sta1[i].y ); sta1[i].x = 0Xdeadbeef, sta1[i].y = -17.2; }
     224        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
     225        printf( "\n" );
     226
     227
     228        // new, non-array types
     229        printf( "\n" );
     230
     231        stp = new( 42, 42.5 );
     232        stp1 = new( 42, 42.5 );
     233        printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y );
     234        delete( stp, stp1 );
     235
     236        // new, array types
     237        stp = anew( dim, 42, 42.5 );
     238        printf( "CFA array new initialize\n" );
     239        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
     240        printf( "\n" );
     241        stp1 = anew( dim, 42, 42.5 );
     242        for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
     243        printf( "\n" );
     244        adelete( dim, stp, dim, stp1 );
     245
     246        // extras
    205247        printf( "\n" );
    206248
    … …  
    211253    p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
    212254        *p = 0xdeadbeef;
    213         printf( "CFA deep malloc %x\n", *p );
     255        printf( "CFA deep malloc %#x\n", *p );
    214256    free( p );
    215257
    216258        stp = malloc();
    217259        printf( "\nSHOULD FAIL\n" );
    218     p = malloc( stp, dim * sizeof(*stp) );
     260    p = alloc( stp, dim * sizeof(*stp) );
    219261    p = memset( stp, 10 );
    220262    p = memcpy( &st1, &st );
Note: See TracChangeset for help on using the changeset viewer.