- Timestamp:
- Jun 2, 2017, 5:42:10 PM (8 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:
- 0db6fc0
- Parents:
- 2164637 (diff), 2c6c893 (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. - Location:
- src
- Files:
-
- 8 edited
-
Common/PassVisitor.impl.h (modified) (17 diffs)
-
Makefile.am (modified) (1 diff)
-
Makefile.in (modified) (1 diff)
-
Parser/lex.ll (modified) (2 diffs)
-
libcfa/stdlib (modified) (4 diffs)
-
libcfa/stdlib.c (modified) (5 diffs)
-
tests/.expect/alloc.txt (modified) (1 diff)
-
tests/alloc.c (modified) (12 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/Common/PassVisitor.impl.h
r2164637 rf94ca7e 1 1 #pragma once 2 3 #define VISIT_START( node ) \ 4 call_previsit( node ); \ 5 6 #define VISIT_END( node ) \ 7 return call_postvisit( node ); \ 2 8 3 9 #define MUTATE_START( node ) \ 4 10 call_premutate( node ); \ 5 11 6 7 12 #define MUTATE_END( type, node ) \ 8 13 return call_postmutate< type * >( node ); \ … … 10 15 11 16 #define VISIT_BODY( node ) \ 12 call_previsit( node ); \17 VISIT_START( node ); \ 13 18 Visitor::visit( node ); \ 14 call_postvisit( node ); \19 VISIT_END( node ); \ 15 20 16 21 … … 39 44 if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); } 40 45 try { 41 *i =(*i)->accept( *this );46 (*i)->accept( *this ); 42 47 } catch ( SemanticError &e ) { 43 48 errors.append( e ); … … 78 83 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); 79 84 80 Statement *newStmt = maybeVisit( stmt, *this );85 maybeAccept( stmt, *this ); 81 86 82 87 StmtList_t* beforeStmts = get_beforeStmts(); 83 88 StmtList_t* afterStmts = get_afterStmts(); 84 89 85 if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; }90 if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; } 86 91 87 92 CompoundStmt *compound = new CompoundStmt( noLabels ); 88 93 if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); } 89 compound->get_kids().push_back( newStmt );94 compound->get_kids().push_back( stmt ); 90 95 if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); } 91 96 return compound; … … 187 192 } 188 193 194 //-------------------------------------------------------------------------- 195 // CompoundStmt 189 196 template< typename pass_type > 190 197 void PassVisitor< pass_type >::visit( CompoundStmt * node ) { 191 VISIT_BODY( node ); 198 VISIT_START( node ); 199 call_beginScope(); 200 201 visitStatementList( node->get_kids() ); 202 203 call_endScope(); 204 VISIT_END( node ); 192 205 } 193 206 … … 203 216 } 204 217 218 //-------------------------------------------------------------------------- 219 // ExprStmt 205 220 template< typename pass_type > 206 221 void PassVisitor< pass_type >::visit( ExprStmt * node ) { 207 VISIT_BODY( node ); 222 VISIT_START( node ); 223 call_beginScope(); 224 225 visitExpression( node->get_expr() ); 226 227 call_endScope(); 228 VISIT_END( node ); 208 229 } 209 230 … … 222 243 } 223 244 245 //-------------------------------------------------------------------------- 246 // IfStmt 224 247 template< typename pass_type > 225 248 void PassVisitor< pass_type >::visit( IfStmt * node ) { 226 VISIT_BODY( node ); 249 VISIT_START( node ); 250 251 visitExpression( node->get_condition() ); 252 node->set_thenPart ( visitStatement( node->get_thenPart() ) ); 253 node->set_elsePart ( visitStatement( node->get_elsePart() ) ); 254 255 VISIT_END( node ); 227 256 } 228 257 … … 238 267 } 239 268 269 //-------------------------------------------------------------------------- 270 // WhileStmt 240 271 template< typename pass_type > 241 272 void PassVisitor< pass_type >::visit( WhileStmt * node ) { 242 VISIT_BODY( node ); 273 VISIT_START( node ); 274 275 visitExpression( node->get_condition() ); 276 node->set_body( visitStatement( node->get_body() ) ); 277 278 VISIT_END( node ); 243 279 } 244 280 … … 253 289 } 254 290 255 291 //-------------------------------------------------------------------------- 292 // WhileStmt 256 293 template< typename pass_type > 257 294 void PassVisitor< pass_type >::visit( ForStmt * node ) { 258 VISIT_BODY( node ); 295 VISIT_START( node ); 296 297 acceptAll( node->get_initialization(), *this ); 298 visitExpression( node->get_condition() ); 299 visitExpression( node->get_increment() ); 300 node->set_body( visitStatement( node->get_body() ) ); 301 302 VISIT_END( node ); 259 303 } 260 304 … … 264 308 265 309 mutateAll( node->get_initialization(), *this ); 266 node->set_condition( 267 node->set_increment( 268 node->set_body( 310 node->set_condition( mutateExpression( node->get_condition() ) ); 311 node->set_increment( mutateExpression( node->get_increment() ) ); 312 node->set_body( mutateStatement( node->get_body() ) ); 269 313 270 314 MUTATE_END( Statement, node ); 271 315 } 272 316 317 //-------------------------------------------------------------------------- 318 // SwitchStmt 273 319 template< typename pass_type > 274 320 void PassVisitor< pass_type >::visit( SwitchStmt * node ) { 275 VISIT_BODY( node ); 321 VISIT_START( node ); 322 323 visitExpression( node->get_condition() ); 324 visitStatementList( node->get_statements() ); 325 326 VISIT_END( node ); 276 327 } 277 328 … … 286 337 } 287 338 339 //-------------------------------------------------------------------------- 340 // SwitchStmt 288 341 template< typename pass_type > 289 342 void PassVisitor< pass_type >::visit( CaseStmt * node ) { 290 VISIT_BODY( node ); 343 VISIT_START( node ); 344 345 visitExpression( node->get_condition() ); 346 visitStatementList( node->get_statements() ); 347 348 VISIT_END( node ); 291 349 } 292 350 … … 306 364 } 307 365 366 //-------------------------------------------------------------------------- 367 // ReturnStmt 308 368 template< typename pass_type > 309 369 void PassVisitor< pass_type >::visit( ReturnStmt * node ) { 310 VISIT_BODY( node ); 370 VISIT_START( node ); 371 372 visitExpression( node->get_expr() ); 373 374 VISIT_END( node ); 311 375 } 312 376 … … 320 384 } 321 385 386 //-------------------------------------------------------------------------- 387 // TryStmt 322 388 template< typename pass_type > 323 389 void PassVisitor< pass_type >::visit( TryStmt * node ) { 324 VISIT_BODY( node ); 390 VISIT_START( node ); 391 392 maybeAccept( node->get_block(), *this ); 393 acceptAll( node->get_catchers(), *this ); 394 395 VISIT_END( node ); 325 396 } 326 397 … … 335 406 } 336 407 408 //-------------------------------------------------------------------------- 409 // CatchStmt 337 410 template< typename pass_type > 338 411 void PassVisitor< pass_type >::visit( CatchStmt * node ) { 339 VISIT_BODY( node ); 412 VISIT_START( node ); 413 414 node->set_body( visitStatement( node->get_body() ) ); 415 maybeAccept( node->get_decl(), *this ); 416 417 VISIT_END( node ); 340 418 } 341 419 … … 375 453 } 376 454 455 //-------------------------------------------------------------------------- 456 // UntypedExpr 377 457 template< typename pass_type > 378 458 void PassVisitor< pass_type >::visit( UntypedExpr * node ) { 379 VISIT_BODY( node ); 459 VISIT_START( node ); 460 461 for ( auto expr : node->get_args() ) { 462 visitExpression( expr ); 463 } 464 465 VISIT_END( node ); 380 466 } 381 467 … … 536 622 } 537 623 624 //-------------------------------------------------------------------------- 625 // UntypedExpr 538 626 template< typename pass_type > 539 627 void PassVisitor< pass_type >::visit( StmtExpr * node ) { 540 VISIT_BODY( node ); 628 VISIT_START( node ); 629 630 // don't want statements from outer CompoundStmts to be added to this StmtExpr 631 ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); 632 ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() ); 633 ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); 634 635 Visitor::visit( node ); 636 637 VISIT_END( node ); 541 638 } 542 639 … … 640 737 } 641 738 739 //-------------------------------------------------------------------------- 740 // UntypedExpr 642 741 template< typename pass_type > 643 742 void PassVisitor< pass_type >::visit( SingleInit * node ) { 644 VISIT_BODY( node ); 743 VISIT_START( node ); 744 745 visitExpression( node->get_value() ); 746 747 VISIT_END( node ); 645 748 } 646 749 -
src/Makefile.am
r2164637 rf94ca7e 43 43 driver_cfa_cpp_SOURCES = ${SRC} 44 44 driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap 45 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall - Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++1445 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 46 46 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic 47 47 -
src/Makefile.in
r2164637 rf94ca7e 447 447 driver_cfa_cpp_SOURCES = ${SRC} 448 448 driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap 449 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall - Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14449 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 450 450 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic 451 451 all: $(BUILT_SOURCES) -
src/Parser/lex.ll
r2164637 rf94ca7e 5 5 * file "LICENCE" distributed with Cforall. 6 6 * 7 * lex.l --7 * lex.ll -- 8 8 * 9 9 * Author : Peter A. Buhr 10 10 * Created On : Sat Sep 22 08:58:10 2001 11 11 * Last Modified By : Peter A. Buhr 12 * Last Modified On : Mon May 22 07:46:30201713 * Update Count : 52 512 * Last Modified On : Tue May 30 22:00:48 2017 13 * Update Count : 527 14 14 */ 15 15 … … 235 235 long { KEYWORD_RETURN(LONG); } 236 236 lvalue { KEYWORD_RETURN(LVALUE); } // CFA 237 monitor { KEYWORD_RETURN(MONITOR); } // CFA237 monitor { KEYWORD_RETURN(MONITOR); } // CFA 238 238 mutex { KEYWORD_RETURN(MUTEX); } // CFA 239 239 _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 -
src/libcfa/stdlib
r2164637 rf94ca7e 10 10 // Created On : Thu Jan 28 17:12:35 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Tue May 30 09:07:35201713 // Update Count : 16412 // Last Modified On : Fri Jun 2 15:51:03 2017 13 // Update Count : 218 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 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 ) {129 return (void *)memset( dest, c, dim * sizeof(T) ); // C memset 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
r2164637 rf94ca7e 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
r2164637 rf94ca7e 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 15 C realloc 15 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeefdeadbeef16 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 16 17 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 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 21 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 22 CFA resize array alloc 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 25 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 26 CFA resize array alloc, fill 27 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 28 CFA resize array alloc, 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, 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
r2164637 rf94ca7e 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 : Fri Jun 2 15:13:03 2017 13 // Update Count : 316 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 87 p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc 88 for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } 80 89 printf( "C realloc\n" ); 81 for ( int i = 0; i < dim; i += 1 ) { printf( "% x ", p[i] ); p[i] = 0Xdeadbeef; }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 94 for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } 85 95 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; } 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\n" ); 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\n" ); 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\n" ); 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, fill\n" ); 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, fill\n" ); 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, fill\n" ); 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.
