Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Common/PassVisitor.impl.h (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -1,8 +1,13 @@ #pragma once + +#define VISIT_START( node ) \ + call_previsit( node ); \ + +#define VISIT_END( node ) \ + return call_postvisit( node ); \ #define MUTATE_START( node ) \ call_premutate( node ); \ - #define MUTATE_END( type, node ) \ return call_postmutate< type * >( node ); \ @@ -10,7 +15,7 @@ #define VISIT_BODY( node ) \ - call_previsit( node ); \ + VISIT_START( node ); \ Visitor::visit( node ); \ - call_postvisit( node ); \ + VISIT_END( node ); \ @@ -39,5 +44,5 @@ if ( !empty( afterStmts ) ) { statements.splice( i, *afterStmts ); } try { - *i = (*i)->accept( *this ); + (*i)->accept( *this ); } catch ( SemanticError &e ) { errors.append( e ); @@ -78,14 +83,14 @@ ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); - Statement *newStmt = maybeVisit( stmt, *this ); + maybeAccept( stmt, *this ); StmtList_t* beforeStmts = get_beforeStmts(); StmtList_t* afterStmts = get_afterStmts(); - if( empty(beforeStmts) && empty(afterStmts) ) { return newStmt; } + if( empty(beforeStmts) && empty(afterStmts) ) { return stmt; } CompoundStmt *compound = new CompoundStmt( noLabels ); if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); } - compound->get_kids().push_back( newStmt ); + compound->get_kids().push_back( stmt ); if( !empty(afterStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *afterStmts ); } return compound; @@ -187,7 +192,15 @@ } +//-------------------------------------------------------------------------- +// CompoundStmt template< typename pass_type > void PassVisitor< pass_type >::visit( CompoundStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + call_beginScope(); + + visitStatementList( node->get_kids() ); + + call_endScope(); + VISIT_END( node ); } @@ -203,7 +216,15 @@ } +//-------------------------------------------------------------------------- +// ExprStmt template< typename pass_type > void PassVisitor< pass_type >::visit( ExprStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + call_beginScope(); + + visitExpression( node->get_expr() ); + + call_endScope(); + VISIT_END( node ); } @@ -222,7 +243,15 @@ } +//-------------------------------------------------------------------------- +// IfStmt template< typename pass_type > void PassVisitor< pass_type >::visit( IfStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + node->set_thenPart ( visitStatement( node->get_thenPart() ) ); + node->set_elsePart ( visitStatement( node->get_elsePart() ) ); + + VISIT_END( node ); } @@ -238,7 +267,14 @@ } +//-------------------------------------------------------------------------- +// WhileStmt template< typename pass_type > void PassVisitor< pass_type >::visit( WhileStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + node->set_body( visitStatement( node->get_body() ) ); + + VISIT_END( node ); } @@ -253,8 +289,16 @@ } - +//-------------------------------------------------------------------------- +// WhileStmt template< typename pass_type > void PassVisitor< pass_type >::visit( ForStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + acceptAll( node->get_initialization(), *this ); + visitExpression( node->get_condition() ); + visitExpression( node->get_increment() ); + node->set_body( visitStatement( node->get_body() ) ); + + VISIT_END( node ); } @@ -264,14 +308,21 @@ mutateAll( node->get_initialization(), *this ); - node->set_condition( mutateExpression( node->get_condition() ) ); - node->set_increment( mutateExpression( node->get_increment() ) ); - node->set_body( mutateStatement( node->get_body() ) ); + node->set_condition( mutateExpression( node->get_condition() ) ); + node->set_increment( mutateExpression( node->get_increment() ) ); + node->set_body( mutateStatement( node->get_body() ) ); MUTATE_END( Statement, node ); } +//-------------------------------------------------------------------------- +// SwitchStmt template< typename pass_type > void PassVisitor< pass_type >::visit( SwitchStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + visitStatementList( node->get_statements() ); + + VISIT_END( node ); } @@ -286,7 +337,14 @@ } +//-------------------------------------------------------------------------- +// SwitchStmt template< typename pass_type > void PassVisitor< pass_type >::visit( CaseStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_condition() ); + visitStatementList( node->get_statements() ); + + VISIT_END( node ); } @@ -306,7 +364,13 @@ } +//-------------------------------------------------------------------------- +// ReturnStmt template< typename pass_type > void PassVisitor< pass_type >::visit( ReturnStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_expr() ); + + VISIT_END( node ); } @@ -320,7 +384,14 @@ } +//-------------------------------------------------------------------------- +// TryStmt template< typename pass_type > void PassVisitor< pass_type >::visit( TryStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + maybeAccept( node->get_block(), *this ); + acceptAll( node->get_catchers(), *this ); + + VISIT_END( node ); } @@ -335,7 +406,14 @@ } +//-------------------------------------------------------------------------- +// CatchStmt template< typename pass_type > void PassVisitor< pass_type >::visit( CatchStmt * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + node->set_body( visitStatement( node->get_body() ) ); + maybeAccept( node->get_decl(), *this ); + + VISIT_END( node ); } @@ -375,7 +453,15 @@ } +//-------------------------------------------------------------------------- +// UntypedExpr template< typename pass_type > void PassVisitor< pass_type >::visit( UntypedExpr * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + for ( auto expr : node->get_args() ) { + visitExpression( expr ); + } + + VISIT_END( node ); } @@ -536,7 +622,18 @@ } +//-------------------------------------------------------------------------- +// UntypedExpr template< typename pass_type > void PassVisitor< pass_type >::visit( StmtExpr * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + // don't want statements from outer CompoundStmts to be added to this StmtExpr + ValueGuardPtr< TypeSubstitution * > oldEnv ( get_env_ptr() ); + ValueGuardPtr< std::list< Statement* > > oldBeforeStmts( get_beforeStmts() ); + ValueGuardPtr< std::list< Statement* > > oldAfterStmts ( get_afterStmts () ); + + Visitor::visit( node ); + + VISIT_END( node ); } @@ -640,7 +737,13 @@ } +//-------------------------------------------------------------------------- +// UntypedExpr template< typename pass_type > void PassVisitor< pass_type >::visit( SingleInit * node ) { - VISIT_BODY( node ); + VISIT_START( node ); + + visitExpression( node->get_value() ); + + VISIT_END( node ); } Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Makefile.am (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -43,5 +43,5 @@ driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Makefile.in (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -447,5 +447,5 @@ driver_cfa_cpp_SOURCES = ${SRC} driver_cfa_cpp_LDADD = ${LEXLIB} -ldl # yywrap -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -Werror -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include -DYY_NO_INPUT -O2 -g -std=c++14 driver_cfa_cpp_LDFLAGS = -Xlinker -export-dynamic all: $(BUILT_SOURCES) Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/Parser/lex.ll (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -5,11 +5,11 @@ * file "LICENCE" distributed with Cforall. * - * lex.l -- + * lex.ll -- * * Author : Peter A. Buhr * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Mon May 22 07:46:30 2017 - * Update Count : 525 + * Last Modified On : Tue May 30 22:00:48 2017 + * Update Count : 527 */ @@ -235,5 +235,5 @@ long { KEYWORD_RETURN(LONG); } lvalue { KEYWORD_RETURN(LVALUE); } // CFA -monitor { KEYWORD_RETURN(MONITOR); } // CFA +monitor { KEYWORD_RETURN(MONITOR); } // CFA mutex { KEYWORD_RETURN(MUTEX); } // CFA _Noreturn { KEYWORD_RETURN(NORETURN); } // C11 Index: src/libcfa/stdlib =================================================================== --- src/libcfa/stdlib (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/libcfa/stdlib (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:35 2017 -// Update Count : 164 +// Last Modified On : Fri Jun 2 15:51:03 2017 +// Update Count : 218 // @@ -28,6 +28,4 @@ //--------------------------------------- -extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * - // allocation, non-array types static inline forall( dtype T | sized(T) ) T * malloc( void ) { @@ -35,83 +33,83 @@ return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc } // malloc -static inline forall( dtype T | sized(T) ) T * malloc( char fill ) { + +extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine +static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { //printf( "X2\n" ); + return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc +} + +extern "C" { void * realloc( void * ptr, size_t size ); } // default C routine for void * +static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { + //printf( "X3\n" ); + return (T *)(void *)realloc( (void *)ptr, size ); +} + +extern "C" { void * memalign( size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) T * memalign( size_t align ) { + //printf( "X4\n" ); + return (T *)memalign( align, sizeof(T) ); +} // memalign + +static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t align ) { + //printf( "X5\n" ); + return (T *)memalign( align, sizeof(T) ); +} // aligned_alloc + +extern "C" { int posix_memalign( void ** ptr, size_t align, size_t size ); } // use default C routine for void * +static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t align ) { + //printf( "X6\n" ); + return posix_memalign( (void **)ptr, align, sizeof(T) ); +} // posix_memalign + + +extern "C" { void * memset( void * dest, int c, size_t size ); } // use default C routine for void * + +static inline forall( dtype T | sized(T) ) T * alloc( void ) { + //printf( "X7\n" ); + return (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( char fill ) { + //printf( "X8\n" ); T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, sizeof(T) ); // initial with fill value -} // malloc - -// allocation, array types -extern "C" { void * calloc( size_t dim, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * calloc( size_t dim ) { - //printf( "X3\n" ); - return (T *)(void *)calloc( dim, sizeof(T) ); // C cmalloc -} -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim ) { // alternative name - //printf( "X4\n" ); +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim ) { + //printf( "X9\n" ); return (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( size_t dim, char fill ) { // alternative name - //printf( "X5\n" ); +} // alloc +static inline forall( dtype T | sized(T) ) T * alloc( size_t dim, char fill ) { + //printf( "X10\n" ); T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amalloc - -// resize, non-array types -extern "C" { void * realloc( void * ptr, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size ) { - //printf( "X5.5\n" ); - return (T *)(void *)realloc( (void *)ptr, size ); -} -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ); -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size ) { // alternative name - //printf( "X7\n" ); - return realloc( ptr, size ); -} // malloc -static inline forall( dtype T | sized(T) ) T * malloc( T * ptr, size_t size, char fill ) { // alternative name - //printf( "X8\n" ); - return realloc( ptr, size, fill ); -} // malloc - -// resize, array types -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim ) { - //printf( "X9\n" ); - return malloc( ptr, dim * (size_t)sizeof(T) ); -} // amalloc -static inline forall( dtype T | sized(T) ) T * amalloc( T * ptr, size_t dim, char fill ) { - //printf( "X10\n" ); - return malloc( ptr, dim * (size_t)sizeof(T), fill ); -} // amalloc - -// alignment, non-array types -extern "C" { void * memalign( size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment ) { +} // alloc + +static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) { //printf( "X11\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * memalign( size_t alignment, char fill ) { - //printf( "X12\n" ); - T * ptr = (T *)memalign( alignment, sizeof(T) ); + return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc +} // alloc +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ); + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align ) { + //printf( "X13\n" ); + return (T *)memalign( align, sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, char fill ) { + //printf( "X14\n" ); + T * ptr = (T *)memalign( align, sizeof(T) ); return memset( ptr, (int)fill, sizeof(T) ); -} // memalign -static inline forall( dtype T | sized(T) ) T * aligned_alloc( size_t alignment ) { - //printf( "X13\n" ); - return (T *)memalign( alignment, sizeof(T) ); -} // aligned_alloc -extern "C" { int posix_memalign( void ** ptr, size_t alignment, size_t size ); } // use default C routine for void * -static inline forall( dtype T | sized(T) ) int posix_memalign( T ** ptr, size_t alignment ) { - //printf( "X14\n" ); - return posix_memalign( (void **)ptr, alignment, sizeof(T) ); -} // posix_memalign - -// alignment, array types -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim ) { +} // align_alloc + +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim ) { //printf( "X15\n" ); - return (T *)memalign( alignment, dim * sizeof(T) ); -} // amemalign -static inline forall( dtype T | sized(T) ) T * amemalign( size_t alignment, size_t dim, char fill ) { + return (T *)memalign( align, dim * sizeof(T) ); +} // align_alloc +static inline forall( dtype T | sized(T) ) T * align_alloc( size_t align, size_t dim, char fill ) { //printf( "X16\n" ); - T * ptr = (T *)memalign( alignment, dim * sizeof(T) ); + T * ptr = (T *)memalign( align, dim * sizeof(T) ); return memset( ptr, (int)fill, dim * sizeof(T) ); -} // amemalign +} // align_alloc + // data, non-array types @@ -127,17 +125,22 @@ // data, array types -static inline forall( dtype T | sized(T) ) T * amemset( T * dest, size_t dim, char c ) { +static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) { //printf( "X19\n" ); - return memset( dest, c, dim * sizeof(T) ); -} // amemset -static inline forall( dtype T | sized(T) ) T * amemcpy( T * dest, const T * src, size_t dim ) { + return (void *)memset( dest, c, dim * sizeof(T) ); // C memset +} // memset +static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) { //printf( "X20\n" ); - return memcpy( dest, src, dim * sizeof(T) ); -} // amemcpy - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } ) T * new( Params p ); + return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy +} // memcpy + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ); forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ); forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ); + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p ); +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] ); +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest ); //--------------------------------------- Index: src/libcfa/stdlib.c =================================================================== --- src/libcfa/stdlib.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/libcfa/stdlib.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:10:29 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 30 09:07:56 2017 -// Update Count : 237 +// Last Modified On : Thu Jun 1 21:52:57 2017 +// Update Count : 280 // @@ -28,8 +28,7 @@ // resize, non-array types -forall( dtype T | sized(T) ) T * realloc( T * ptr, size_t size, char fill ) { // alternative realloc with fill value - //printf( "X6\n" ); +forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill ) { size_t olen = malloc_usable_size( ptr ); // current allocation - char * nptr = (void *)realloc( (void *)ptr, size ); // C realloc + char * nptr = (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc size_t nlen = malloc_usable_size( nptr ); // new allocation if ( nlen > olen ) { // larger ? @@ -37,15 +36,15 @@ } // return (T *)nptr; -} // realloc - -// allocation/deallocation and constructor/destructor -forall( dtype T, ttype Params | sized(T) | { void ?{}( T *, Params ); } ) +} // alloc + +// allocation/deallocation and constructor/destructor, non-array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p ) { - return ((T *)malloc()){ p }; + return (malloc()){ p }; // run constructor } // new forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -55,5 +54,5 @@ forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest ) { - if ( ptr ) { + if ( ptr ) { // ignore null ^ptr{}; // run destructor free( ptr ); @@ -61,4 +60,36 @@ delete( rest ); } // delete + + +// allocation/deallocation and constructor/destructor, array types +forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) +T * anew( size_t dim, Params p ) { + T *arr = alloc( dim ); + for ( unsigned int i = 0; i < dim; i += 1 ) { + (&arr[i]){ p }; // run constructor + } // for + return arr; +} // anew + +forall( dtype T | sized(T) | { void ^?{}( T * ); } ) +void adelete( size_t dim, T arr[] ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if +} // adelete + +forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) +void adelete( size_t dim, T arr[], Params rest ) { + if ( arr ) { // ignore null + for ( int i = dim - 1; i >= 0; i -= 1 ) { // reverse allocation order, must be unsigned + ^(&arr[i]){}; // run destructor + } // for + free( arr ); + } // if + adelete( rest ); +} // adelete //--------------------------------------- Index: src/tests/.expect/alloc.txt =================================================================== --- src/tests/.expect/alloc.txt (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/tests/.expect/alloc.txt (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -1,56 +1,63 @@ -C malloc deadbeef -CFA malloc 0 -CFA malloc, fill 01010101 +C malloc 0xdeadbeef +CFA malloc 0xdeadbeef +CFA alloc 0xdeadbeef +CFA alloc, fill 01010101 -C calloc +C array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA calloc +CFA array calloc, fill 0 0 0 0 0 0 0 0 0 0 0 -CFA array malloc -0 0 deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA array malloc -1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 +CFA array alloc, no fill +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA array alloc, fill 0x1 +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 C realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA realloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 0 0 0 0 0 0 0 0 0 0 -CFA resize array malloc -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 1010101 -CFA resize array malloc, fill -deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef deadbeef +CFA resize alloc +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc +0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef +CFA resize array alloc, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 +CFA resize array alloc, fill +0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 -CFA aligned_alloc 42 42.5 +C memalign 42 42.5 CFA memalign 42 42.5 CFA posix_memalign 42 42.5 -CFA memalign fill 16843009 7.7486e-304 +CFA posix_memalign 42 42.5 +CFA aligned_alloc 42 42.5 +CFA align_alloc 42 42.5 +CFA align_alloc fill 0x1010101 0x1.1010101010101p-1007 -CFA memalign array -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, -CFA memalign array -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, +CFA array align_alloc +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, +CFA array align_alloc, fill +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, -CFA memset ffffffff -nan -CFA memcpy ffffffff -nan +CFA memset 0x1010101 0x1.1010101010101p-1007 +CFA memcpy 0x1010101 0x1.1010101010101p-1007 CFA array memset -ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, ffffffff -nan, +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, CFA memcpy -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, +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, + +CFA new initialize +42 42.5 42 42.5 +CFA array new initialize +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, +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, + pointer arithmetic 0 -CFA deep malloc deadbeef +CFA deep malloc 0xdeadbeef SHOULD FAIL Index: src/tests/alloc.c =================================================================== --- src/tests/alloc.c (revision 2164637ef5db4fef8aefb4475ec11f7d46cc49a9) +++ src/tests/alloc.c (revision f94ca7ea5a1653637b80ac0a0d965178dbd30798) @@ -10,6 +10,6 @@ // Created On : Wed Feb 3 07:56:22 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon May 29 11:33:15 2017 -// Update Count : 228 +// Last Modified On : Fri Jun 2 15:13:03 2017 +// Update Count : 316 // @@ -18,4 +18,5 @@ #include // malloc_usable_size #include // uintptr_t +#include // posix_memalign } // extern #include @@ -28,6 +29,6 @@ int main( void ) { size_t dim = 10; - struct S { int x; double y; } * s; int * p; + char fill = '\1'; // allocation, non-array types @@ -35,13 +36,19 @@ p = (void *)malloc( sizeof(*p) ); // C malloc, type unsafe *p = 0xdeadbeef; - printf( "C malloc %x\n", *p ); + printf( "C malloc %#x\n", *p ); free( p ); p = malloc(); // CFA malloc, type safe - printf( "CFA malloc %d\n", *p ); - free( p ); - - p = malloc( '\1' ); // CFA malloc, fill - printf( "CFA malloc, fill %08x\n", *p ); + *p = 0xdeadbeef; + printf( "CFA malloc %#x\n", *p ); + free( p ); + + p = alloc(); // CFA alloc, type safe + *p = 0xdeadbeef; + printf( "CFA alloc %#x\n", *p ); + free( p ); + + p = alloc( fill ); // CFA alloc, fill + printf( "CFA alloc, fill %08x\n", *p ); @@ -50,24 +57,25 @@ p = calloc( dim, sizeof( *p ) ); // C array calloc, type unsafe - printf( "C calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "C array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); free( p ); p = calloc( dim ); // CFA array calloc, type safe - printf( "CFA calloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( dim ); // CFA array malloc, type safe - printf( "CFA array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - free( p ); - - p = amalloc( 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + printf( "CFA array calloc, fill 0\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( dim ); // CFA array alloc, type safe + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA array alloc, no fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); + + p = alloc( 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA array alloc, fill %#x\n", fill ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -77,32 +85,14 @@ printf( "\n" ); - p = (void *)realloc( p, dim * sizeof(*p) ); // CFA realloc + p = (void *)realloc( p, dim * sizeof(*p) ); // C realloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } printf( "C realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); p = realloc( p, 2 * dim * sizeof(*p) ); // CFA realloc + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } printf( "CFA realloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = realloc( p, dim * sizeof(*p), '\1' ); // CFA realloc - printf( "CFA realloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p) ); // CFA malloc - printf( "CFA resize malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, 2 * dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = malloc( p, dim * sizeof(*p), '\1' ); // CFA malloc, fill - printf( "CFA resize malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } printf( "\n" ); // do not free @@ -112,43 +102,62 @@ printf( "\n" ); - p = amalloc( p, 2 * dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim ); // CFA array malloc - printf( "CFA resize array malloc\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, 2 * dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } - printf( "\n" ); - - p = amalloc( p, dim, '\1' ); // CFA array malloc, fill - printf( "CFA resize array malloc, fill\n" ); - for ( int i = 0; i < dim; i += 1 ) { printf( "%x ", p[i] ); p[i] = 0Xdeadbeef; } + p = alloc( p, dim ); // CFA resize array alloc + for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; } + printf( "CFA resize alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim ); // CFA resize array alloc + for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; } + printf( "CFA resize array alloc\n" ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim ); // CFA array alloc + printf( "CFA resize array alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + free( p ); - printf( "\n" ); + p = 0; + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, 2 * dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc, fill\n" ); + for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } + printf( "\n" ); + + p = alloc( p, dim, fill ); // CFA array alloc, fill + printf( "CFA resize array alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; } + printf( "\n" ); + free( p ); + struct Struct { int x; double y; }; - Struct st, st1, sta[dim], sta1[dim], * stp; - + Struct st, st1, sta[dim], sta1[dim], * stp, * stp1; // alignment, non-array types printf( "\n" ); - enum { Alignment = 128 }; - stp = aligned_alloc( Alignment ); // CFA aligned_alloc + + stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "C memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (memalign( Alignment )){ 42, 42.5 }; // CFA memalign + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA memalign %d %g\n", stp->x, stp->y ); + free( stp ); + + posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign *stp = (Struct){ 42, 42.5 }; assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); - free( stp ); - - stp = memalign( Alignment ); // CFA memalign - *stp = (Struct){ 42, 42.5 }; - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign %d %g\n", stp->x, stp->y ); + printf( "CFA posix_memalign %d %g\n", stp->x, stp->y ); free( stp ); @@ -159,7 +168,17 @@ free( stp ); - stp = memalign( Alignment, '\1' ); // CFA memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign fill %d %g\n", stp->x, stp->y ); + stp = (aligned_alloc( Alignment )){ 42, 42.5 }; // CFA aligned_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = (align_alloc( Alignment )){ 42, 42.5 }; // CFA align_alloc + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc %d %g\n", stp->x, stp->y ); + free( stp ); + + stp = align_alloc( Alignment, fill ); // CFA memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y ); free( stp ); @@ -168,15 +187,16 @@ printf( "\n" ); - stp = amemalign( Alignment, 2 * dim ); // CFA array memalign - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - 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; } - printf( "\n" ); - free( stp ); - - stp = amemalign( Alignment, dim, '\1' ); // CFA array memalign, fill - assert( (uintptr_t)stp % Alignment == 0 ); - printf( "CFA memalign array\n" ); - 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; } + stp = align_alloc( Alignment, dim ); // CFA array memalign + assert( (uintptr_t)stp % Alignment == 0 ); + for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; } + printf( "CFA array align_alloc\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + free( stp ); + + stp = align_alloc( Alignment, dim, fill ); // CFA array memalign, fill + assert( (uintptr_t)stp % Alignment == 0 ); + printf( "CFA array align_alloc, fill\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); } printf( "\n" ); free( stp ); @@ -186,8 +206,8 @@ printf( "\n" ); - stp = memset( &st, '\xff' ); // CFA memset, type safe - printf( "CFA memset %x %g\n", st.x, st.y ); - stp = memcpy( &st1, &st ); // CFA memcpy, type safe - printf( "CFA memcpy %x %g\n", st1.x, st1.y ); + memset( &st, fill ); // CFA memset, type safe + printf( "CFA memset %#x %a\n", st.x, st.y ); + memcpy( &st1, &st ); // CFA memcpy, type safe + printf( "CFA memcpy %#x %a\n", st1.x, st1.y ); @@ -195,12 +215,34 @@ printf( "\n" ); - stp = amemset( sta, dim, '\xff' ); // CFA array memset, type safe + memset( sta, dim, fill ); // CFA array memset, type safe printf( "CFA array memset\n" ); - 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; } - printf( "\n" ); - - stp = amemcpy( sta1, sta, dim ); // CFA array memcpy, type safe + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); } + printf( "\n" ); + + memcpy( sta1, sta, dim ); // CFA array memcpy, type safe printf( "CFA memcpy\n" ); - 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; } + for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); } + printf( "\n" ); + + + // new, non-array types + printf( "\n" ); + + stp = new( 42, 42.5 ); + stp1 = new( 42, 42.5 ); + printf( "CFA new initialize\n%d %g %d %g\n", stp->x, stp->y, stp1->x, stp1->y ); + delete( stp, stp1 ); + + // new, array types + stp = anew( dim, 42, 42.5 ); + printf( "CFA array new initialize\n" ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); } + printf( "\n" ); + stp1 = anew( dim, 42, 42.5 ); + for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); } + printf( "\n" ); + adelete( dim, stp, dim, stp1 ); + + // extras printf( "\n" ); @@ -211,10 +253,10 @@ p = foo( bar( baz( malloc(), 0 ), 0 ), 0 ); *p = 0xdeadbeef; - printf( "CFA deep malloc %x\n", *p ); + printf( "CFA deep malloc %#x\n", *p ); free( p ); stp = malloc(); printf( "\nSHOULD FAIL\n" ); - p = malloc( stp, dim * sizeof(*stp) ); + p = alloc( stp, dim * sizeof(*stp) ); p = memset( stp, 10 ); p = memcpy( &st1, &st );