Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 436c0deab931c3644feb0da7d5a23034b5e7cfd3) +++ src/SymTab/Autogen.h (revision d56e5bcda08aa6816d20a750cfe4087387b7681f) @@ -10,6 +10,6 @@ // Created On : Sun May 17 21:53:34 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Mar 17 09:10:41 2017 -// Update Count : 9 +// Last Modified On : Wed Jun 21 17:25:26 2017 +// Update Count : 14 // @@ -25,153 +25,153 @@ namespace SymTab { - /// Generates assignment operators, constructors, and destructor for aggregate types as required - void autogenerateRoutines( std::list< Declaration * > &translationUnit ); + /// Generates assignment operators, constructors, and destructor for aggregate types as required + void autogenerateRoutines( std::list< Declaration * > &translationUnit ); - /// returns true if obj's name is the empty string and it has a bitfield width - bool isUnnamedBitfield( ObjectDecl * obj ); + /// returns true if obj's name is the empty string and it has a bitfield width + bool isUnnamedBitfield( ObjectDecl * obj ); - /// size_t type - set when size_t typedef is seen. Useful in a few places, - /// such as in determining array dimension type - extern Type * SizeType; + /// size_t type - set when size_t typedef is seen. Useful in a few places, + /// such as in determining array dimension type + extern Type * SizeType; - /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. + template< typename OutputIterator > Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true ); - /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types. - /// optionally returns a statement which must be inserted prior to the containing loop, if there is one - template< typename OutputIterator > + /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types. + /// optionally returns a statement which must be inserted prior to the containing loop, if there is one + template< typename OutputIterator > Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) { - // want to be able to generate assignment, ctor, and dtor generically, - // so fname is either ?=?, ?{}, or ^?{} - UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) ); + // want to be able to generate assignment, ctor, and dtor generically, + // so fname is either ?=?, ?{}, or ^?{} + UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) ); - // do something special for unnamed members - dstParam = new AddressExpr( dstParam ); - if ( addCast ) { - // cast to T* with qualifiers removed, so that qualified objects can be constructed - // and destructed with the same functions as non-qualified objects. - // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument - // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever - // remove lvalue as a qualifier, this can change to - // type->get_qualifiers() = Type::Qualifiers(); - assert( type ); - Type * castType = type->clone(); + // do something special for unnamed members + dstParam = new AddressExpr( dstParam ); + if ( addCast ) { + // cast to T* with qualifiers removed, so that qualified objects can be constructed + // and destructed with the same functions as non-qualified objects. + // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument + // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever + // remove lvalue as a qualifier, this can change to + // type->get_qualifiers() = Type::Qualifiers(); + assert( type ); + Type * castType = type->clone(); // castType->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, false); - castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); - castType->set_lvalue( true ); // xxx - might not need this - dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); - } - fExpr->get_args().push_back( dstParam ); + castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic ); + castType->set_lvalue( true ); // xxx - might not need this + dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) ); + } + fExpr->get_args().push_back( dstParam ); - Statement * listInit = srcParam.buildListInit( fExpr ); + Statement * listInit = srcParam.buildListInit( fExpr ); - std::list< Expression * > args = *++srcParam; - fExpr->get_args().splice( fExpr->get_args().end(), args ); + std::list< Expression * > args = *++srcParam; + fExpr->get_args().splice( fExpr->get_args().end(), args ); - *out++ = new ExprStmt( noLabels, fExpr ); + *out++ = new ExprStmt( noLabels, fExpr ); - srcParam.clearArrayIndices(); + srcParam.clearArrayIndices(); - return listInit; + return listInit; + } + + /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments. + /// If forward is true, loop goes from 0 to N-1, else N-1 to 0 + template< typename OutputIterator > + void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) { + static UniqueName indexName( "_index" ); + + // for a flexible array member nothing is done -- user must define own assignment + if ( ! array->get_dimension() ) return ; + + Expression * begin, * end, * update, * cmp; + if ( forward ) { + // generate: for ( int i = 0; i < N; ++i ) + begin = new ConstantExpr( Constant::from_int( 0 ) ); + end = array->get_dimension()->clone(); + cmp = new NameExpr( "?= 0; --i ) + begin = new UntypedExpr( new NameExpr( "?-?" ) ); + ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); + ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) ); + end = new ConstantExpr( Constant::from_int( 0 ) ); + cmp = new NameExpr( "?>=?" ); + update = new NameExpr( "--?" ); } - /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments. - /// If forward is true, loop goes from 0 to N-1, else N-1 to 0 - template< typename OutputIterator > - void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) { - static UniqueName indexName( "_index" ); + ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); - // for a flexible array member nothing is done -- user must define own assignment - if ( ! array->get_dimension() ) return ; + UntypedExpr *cond = new UntypedExpr( cmp ); + cond->get_args().push_back( new VariableExpr( index ) ); + cond->get_args().push_back( end ); - Expression * begin, * end, * update, * cmp; - if ( forward ) { - // generate: for ( int i = 0; i < 0; ++i ) - begin = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) ); - end = array->get_dimension()->clone(); - cmp = new NameExpr( "?= 0; --i ) - begin = new UntypedExpr( new NameExpr( "?-?" ) ); - ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() ); - ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant( new OneType( emptyQualifiers ), "1" ) ) ); - end = new ConstantExpr( Constant( new ZeroType( emptyQualifiers ), "0" ) ); - cmp = new NameExpr( "?>=?" ); - update = new NameExpr( "--?" ); - } + UntypedExpr *inc = new UntypedExpr( update ); + inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); - ObjectDecl *index = new ObjectDecl( indexName.newName(), Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list() ) ); + UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); + dstIndex->get_args().push_back( dstParam ); + dstIndex->get_args().push_back( new VariableExpr( index ) ); + dstParam = dstIndex; - UntypedExpr *cond = new UntypedExpr( cmp ); - cond->get_args().push_back( new VariableExpr( index ) ); - cond->get_args().push_back( end ); + // srcParam must keep track of the array indices to build the + // source parameter and/or array list initializer + srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); - UntypedExpr *inc = new UntypedExpr( update ); - inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) ); + // for stmt's body, eventually containing call + CompoundStmt * body = new CompoundStmt( noLabels ); + Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); - UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) ); - dstIndex->get_args().push_back( dstParam ); - dstIndex->get_args().push_back( new VariableExpr( index ) ); - dstParam = dstIndex; + // block containing for stmt and index variable + std::list initList; + CompoundStmt * block = new CompoundStmt( noLabels ); + block->get_kids().push_back( new DeclStmt( noLabels, index ) ); + if ( listInit ) block->get_kids().push_back( listInit ); + block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); - // srcParam must keep track of the array indices to build the - // source parameter and/or array list initializer - srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() ); + *out++ = block; + } - // for stmt's body, eventually containing call - CompoundStmt * body = new CompoundStmt( noLabels ); - Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward ); + template< typename OutputIterator > + Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) { + if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); + return 0; + } else { + return genScalarCall( srcParam, dstParam, fname, out, type, addCast ); + } + } - // block containing for stmt and index variable - std::list initList; - CompoundStmt * block = new CompoundStmt( noLabels ); - block->get_kids().push_back( new DeclStmt( noLabels, index ) ); - if ( listInit ) block->get_kids().push_back( listInit ); - block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) ); + /// inserts into out a generated call expression to function fname with arguments dstParam + /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the + /// object being constructed. The function wraps constructor and destructor calls in an + /// ImplicitCtorDtorStmt node. + template< typename OutputIterator > + void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) { + ObjectDecl *obj = dynamic_cast( decl ); + assert( obj ); + // unnamed bit fields are not copied as they cannot be accessed + if ( isUnnamedBitfield( obj ) ) return; - *out++ = block; + bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ); + std::list< Statement * > stmts; + genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); + + // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call + assert( stmts.size() <= 1 ); + if ( stmts.size() == 1 ) { + Statement * callStmt = stmts.front(); + if ( addCast ) { + // implicitly generated ctor/dtor calls should be wrapped + // so that later passes are aware they were generated. + // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield, + // because this causes the address to be taken at codegen, which is illegal in C. + callStmt = new ImplicitCtorDtorStmt( callStmt ); + } + *out++ = callStmt; } - - template< typename OutputIterator > - Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) { - if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { - genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward ); - return 0; - } else { - return genScalarCall( srcParam, dstParam, fname, out, type, addCast ); - } - } - - /// inserts into out a generated call expression to function fname with arguments dstParam - /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the - /// object being constructed. The function wraps constructor and destructor calls in an - /// ImplicitCtorDtorStmt node. - template< typename OutputIterator > - void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) { - ObjectDecl *obj = dynamic_cast( decl ); - assert( obj ); - // unnamed bit fields are not copied as they cannot be accessed - if ( isUnnamedBitfield( obj ) ) return; - - bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && obj->get_bitfieldWidth() == NULL ) ); - std::list< Statement * > stmts; - genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward ); - - // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call - assert( stmts.size() <= 1 ); - if ( stmts.size() == 1 ) { - Statement * callStmt = stmts.front(); - if ( addCast ) { - // implicitly generated ctor/dtor calls should be wrapped - // so that later passes are aware they were generated. - // xxx - don't mark as an implicit ctor/dtor if obj is a bitfield, - // because this causes the address to be taken at codegen, which is illegal in C. - callStmt = new ImplicitCtorDtorStmt( callStmt ); - } - *out++ = callStmt; - } - } + } } // namespace SymTab #endif // AUTOGEN_H