- Timestamp:
- Jun 1, 2017, 10:58:18 PM (7 years ago)
- 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
- Location:
- src
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
src/libcfa/stdlib
r6016c87 r6065b3aa 10 10 // Created On : Thu Jan 28 17:12:35 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : T ue May 30 09:07:35201713 // Update Count : 16412 // Last Modified On : Thu Jun 1 22:46:43 2017 13 // Update Count : 216 14 14 // 15 15 … … 28 28 //--------------------------------------- 29 29 30 extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void *31 32 30 // allocation, non-array types 33 31 static inline forall( dtype T | sized(T) ) T * malloc( void ) { … … 35 33 return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc 36 34 } // malloc 37 static inline forall( dtype T | sized(T) ) T * malloc( char fill ) { 35 36 extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine 37 static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { 38 38 //printf( "X2\n" ); 39 return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc 40 } 41 42 extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void * 43 static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { 44 //printf( "X3\n" ); 45 return (T *)(void *)realloc( (void *)ptr, size ); 46 } 47 48 extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void * 49 static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) { 50 //printf( "X4\n" ); 51 return (T *)memalign( align, sizeof(T) ); 52 } // memalign 53 54 static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) { 55 //printf( "X5\n" ); 56 return (T *)memalign( align, sizeof(T) ); 57 } // aligned_alloc 58 59 extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void * 60 static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) { 61 //printf( "X6\n" ); 62 return posix_memalign( (void **)ptr, align, sizeof(T) ); 63 } // posix_memalign 64 65 66 extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * 67 68 static inline forall( dtype T | sized(T) ) T * alloc( void ) { 69 //printf( "X7\n" ); 70 return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc 71 } // alloc 72 static inline forall( dtype T | sized(T) ) T * alloc( char fill ) { 73 //printf( "X8\n" ); 39 74 T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc 40 75 return memset( ptr, (int)fill, sizeof(T) ); // initial with fill value 41 } // malloc 42 43 // allocation, array types 44 extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void * 45 static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { 46 //printf( "X3\n" ); 47 return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc 48 } 49 static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name 50 //printf( "X4\n" ); 76 } // alloc 77 78 static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) { 79 //printf( "X9\n" ); 51 80 return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc 52 } // a malloc53 static inline forall( dtype T | sized(T) ) T * a malloc( size_t dim, char fill ) { // alternative name54 //printf( "X 5\n" );81 } // alloc 82 static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) { 83 //printf( "X10\n" ); 55 84 T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc 56 85 return memset( ptr, (int)fill, dim * sizeof(T) ); 57 } // amalloc 58 59 // resize, non-array types 60 extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void * 61 static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { 62 //printf( "X5.5\n" ); 63 return (T *)(void *)realloc( (void *)ptr, size ); 64 } 65 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); 66 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name 67 //printf( "X7\n" ); 68 return realloc( ptr, size ); 69 } // malloc 70 static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name 71 //printf( "X8\n" ); 72 return realloc( ptr, size, fill ); 73 } // malloc 74 75 // resize, array types 76 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) { 77 //printf( "X9\n" ); 78 return malloc( ptr, dim * (size_t)sizeof(T) ); 79 } // amalloc 80 static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) { 81 //printf( "X10\n" ); 82 return malloc( ptr, dim * (size_t)sizeof(T), fill ); 83 } // amalloc 84 85 // alignment, non-array types 86 extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void * 87 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) { 86 } // alloc 87 88 static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) { 88 89 //printf( "X11\n" ); 89 return (T *)memalign( alignment, sizeof(T) ); 90 } // memalign 91 static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) { 92 //printf( "X12\n" ); 93 T * ptr = (T *)memalign( alignment, sizeof(T) ); 90 return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc 91 } // alloc 92 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); 93 94 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) { 95 //printf( "X13\n" ); 96 return (T *)memalign( align, sizeof(T) ); 97 } // align_alloc 98 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) { 99 //printf( "X14\n" ); 100 T * ptr = (T *)memalign( align, sizeof(T) ); 94 101 return memset( ptr, (int)fill, sizeof(T) ); 95 } // memalign 96 static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { 97 //printf( "X13\n" ); 98 return (T *)memalign( alignment, sizeof(T) ); 99 } // aligned_alloc 100 extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void * 101 static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) { 102 //printf( "X14\n" ); 103 return posix_memalign( (void **)ptr, alignment, sizeof(T) ); 104 } // posix_memalign 105 106 // alignment, array types 107 static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) { 102 } // align_alloc 103 104 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) { 108 105 //printf( "X15\n" ); 109 return (T *)memalign( align ment, dim * sizeof(T) );110 } // a memalign111 static inline forall( dtype T | sized(T) ) T * a memalign( size_t alignment, size_t dim, char fill ) {106 return (T *)memalign( align, dim * sizeof(T) ); 107 } // align_alloc 108 static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) { 112 109 //printf( "X16\n" ); 113 T * ptr = (T *)memalign( align ment, dim * sizeof(T) );110 T * ptr = (T *)memalign( align, dim * sizeof(T) ); 114 111 return memset( ptr, (int)fill, dim * sizeof(T) ); 115 } // amemalign 112 } // align_alloc 113 116 114 117 115 // data, non-array types … … 127 125 128 126 // data, array types 129 static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) {127 static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) { 130 128 //printf( "X19\n" ); 131 129 return memset( dest, c, dim * sizeof(T) ); 132 } // amemset133 static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) {130 } // memset 131 static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) { 134 132 //printf( "X20\n" ); 135 return memcpy( dest, src, dim * sizeof(T) );136 } // amemcpy137 138 // allocation/deallocation and constructor/destructor 139 forall( dtype T , ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p );133 return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy 134 } // memcpy 135 136 // allocation/deallocation and constructor/destructor, non-array types 137 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); 140 138 forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); 141 139 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); 140 141 // allocation/deallocation and constructor/destructor, array types 142 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); 143 forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); 144 forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); 142 145 143 146 //--------------------------------------- -
src/libcfa/stdlib.c
r6016c87 r6065b3aa 10 10 // Created On : Thu Jan 28 17:10:29 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : T ue May 30 09:07:56201713 // Update Count : 2 3712 // Last Modified On : Thu Jun 1 21:52:57 2017 13 // Update Count : 280 14 14 // 15 15 … … 28 28 29 29 // resize, non-array types 30 forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value 31 //printf( "X6\n" ); 30 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) { 32 31 size_t olen = malloc_usable_size( ptr ); // current allocation 33 char * nptr = (void *)realloc( (void *)ptr, size );// C realloc32 char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc 34 33 size_t nlen = malloc_usable_size( nptr ); // new allocation 35 34 if ( nlen > olen ) { // larger ? … … 37 36 } // 38 37 return (T *)nptr; 39 } // realloc40 41 // allocation/deallocation and constructor/destructor 42 forall( dtype T , ttype Params | sized(T)| { void ?{}( T *, Params ); } )38 } // alloc 39 40 // allocation/deallocation and constructor/destructor, non-array types 41 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) 43 42 T * new( Params p ) { 44 return ( (T *)malloc()){ p };43 return (malloc()){ p }; // run constructor 45 44 } // new 46 45 47 46 forall( dtype T | { void ^?{}( T * ); } ) 48 47 void delete( T * ptr ) { 49 if ( ptr ) { 48 if ( ptr ) { // ignore null 50 49 ^ptr{}; // run destructor 51 50 free( ptr ); … … 55 54 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) 56 55 void delete( T * ptr, Params rest ) { 57 if ( ptr ) { 56 if ( ptr ) { // ignore null 58 57 ^ptr{}; // run destructor 59 58 free( ptr ); … … 61 60 delete( rest ); 62 61 } // delete 62 63 64 // allocation/deallocation and constructor/destructor, array types 65 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) 66 T * anew( size_t dim, Params p ) { 67 T *arr = alloc( dim ); 68 for ( unsigned int i = 0; i < dim; i += 1 ) { 69 (&arr[i]){ p }; // run constructor 70 } // for 71 return arr; 72 } // anew 73 74 forall( dtype T | sized(T) | { void ^?{}( T * ); } ) 75 void adelete( size_t dim, T arr[] ) { 76 if ( arr ) { // ignore null 77 for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned 78 ^(&arr[i]){}; // run destructor 79 } // for 80 free( arr ); 81 } // if 82 } // adelete 83 84 forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) 85 void adelete( size_t dim, T arr[], Params rest ) { 86 if ( arr ) { // ignore null 87 for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned 88 ^(&arr[i]){}; // run destructor 89 } // for 90 free( arr ); 91 } // if 92 adelete( rest ); 93 } // adelete 63 94 64 95 //--------------------------------------- -
src/tests/.expect/alloc.txt
r6016c87 r6065b3aa 1 C malloc deadbeef 2 CFA malloc 0 3 CFA malloc, fill 01010101 1 C malloc 0xdeadbeef 2 CFA malloc 0xdeadbeef 3 CFA alloc 0xdeadbeef 4 CFA alloc, fill 01010101 4 5 5 C calloc6 C array calloc, fill 0 6 7 0 0 0 0 0 0 0 0 0 0 7 CFA calloc8 CFA array calloc, fill 0 8 9 0 0 0 0 0 0 0 0 0 0 9 CFA array malloc10 0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeefdeadbeef11 CFA array malloc12 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101101010110 CFA array alloc, no fill 11 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 12 CFA array alloc, fill 0x1 13 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 13 14 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 15 C realloc 40 16 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 17 CFA realloc 88 18 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 26 19 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 20 CFA resize alloc 40 21 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 22 CFA resize array alloc 88 23 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 24 CFA resize array alloc 40 25 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 26 CFA resize array alloc 40, fill 27 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 28 CFA resize array alloc 88, fill 29 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 30 CFA resize array alloc 40, fill 31 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 35 32 36 C FA aligned_alloc42 42.533 C memalign 42 42.5 37 34 CFA memalign 42 42.5 38 35 CFA posix_memalign 42 42.5 39 CFA memalign fill 16843009 7.7486e-304 36 CFA posix_memalign 42 42.5 37 CFA aligned_alloc 42 42.5 38 CFA align_alloc 42 42.5 39 CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007 40 40 41 CFA memalign array42 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 array44 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,41 CFA array align_alloc 42 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, 42 42.5, 43 CFA array align_alloc, fill 44 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, 0x1010101 0x1.1010101010101p-1007, 45 45 46 CFA memset ffffffff -nan47 CFA memcpy ffffffff -nan46 CFA memset 0x1010101 0x1.1010101010101p-1007 47 CFA memcpy 0x1010101 0x1.1010101010101p-1007 48 48 49 49 CFA array memset 50 ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan,50 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, 0x1010101 0x1.1010101010101p-1007, 51 51 CFA 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, 52 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, 0x1010101 0x1.1010101010101p-1007, 53 54 CFA new initialize 55 42 42.5 42 42.5 56 CFA array new initialize 57 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, 42 42.5, 58 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, 42 42.5, 59 53 60 pointer arithmetic 0 54 CFA deep malloc deadbeef61 CFA deep malloc 0xdeadbeef 55 62 56 63 SHOULD FAIL -
src/tests/alloc.c
r6016c87 r6065b3aa 10 10 // Created On : Wed Feb 3 07:56:22 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon May 29 11:33:15201713 // Update Count : 22812 // Last Modified On : Thu Jun 1 21:33:49 2017 13 // Update Count : 315 14 14 // 15 15 … … 18 18 #include <malloc.h> // malloc_usable_size 19 19 #include <stdint.h> // uintptr_t 20 #include <stdlib.h> // posix_memalign 20 21 } // extern 21 22 #include <fstream> … … 28 29 int main( void ) { 29 30 size_t dim = 10; 30 struct S { int x; double y; } * s;31 31 int * p; 32 char fill = '\1'; 32 33 33 34 // allocation, non-array types … … 35 36 p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe 36 37 *p = 0xdeadbeef; 37 printf( "C malloc % x\n", *p );38 printf( "C malloc %#x\n", *p ); 38 39 free( p ); 39 40 40 41 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 ); 46 53 47 54 … … 50 57 51 58 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] ); } 54 61 printf( "\n" ); 55 62 free( p ); 56 63 57 64 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] ); } 72 80 printf( "\n" ); 73 81 // do not free … … 77 85 printf( "\n" ); 78 86 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] ); } 82 91 printf( "\n" ); 83 92 84 93 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] ); } 107 97 printf( "\n" ); 108 98 // do not free … … 112 102 printf( "\n" ); 113 103 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 132 121 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 134 140 135 141 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; 138 143 139 144 // alignment, non-array types 140 145 printf( "\n" ); 141 142 146 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 144 159 *stp = (Struct){ 42, 42.5 }; 145 160 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 ); 153 162 free( stp ); 154 163 … … 159 168 free( stp ); 160 169 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 ); 164 183 free( stp ); 165 184 … … 168 187 printf( "\n" ); 169 188 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 ); } 181 201 printf( "\n" ); 182 202 free( stp ); … … 186 206 printf( "\n" ); 187 207 188 stp = memset( &st, '\xff' );// CFA memset, type safe189 printf( "CFA memset % x %g\n", st.x, st.y );190 stp = memcpy( &st1, &st );// CFA memcpy, type safe191 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 ); 192 212 193 213 … … 195 215 printf( "\n" ); 196 216 197 stp = amemset( sta, dim, '\xff' );// CFA array memset, type safe217 memset( sta, dim, fill ); // CFA array memset, type safe 198 218 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 safe219 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 203 223 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 205 247 printf( "\n" ); 206 248 … … 211 253 p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); 212 254 *p = 0xdeadbeef; 213 printf( "CFA deep malloc % x\n", *p );255 printf( "CFA deep malloc %#x\n", *p ); 214 256 free( p ); 215 257 216 258 stp = malloc(); 217 259 printf( "\nSHOULD FAIL\n" ); 218 p = malloc( stp, dim * sizeof(*stp) );260 p = alloc( stp, dim * sizeof(*stp) ); 219 261 p = memset( stp, 10 ); 220 262 p = memcpy( &st1, &st );
Note: See TracChangeset
for help on using the changeset viewer.