Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/CodeGen/CodeGenerator.cc (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -148,4 +148,6 @@ void CodeGenerator::visit( ObjectDecl * objectDecl ) { extension( objectDecl ); + genAttributes( objectDecl->get_attributes() ); + handleStorageClass( objectDecl ); output << genType( objectDecl->get_type(), mangleName( objectDecl ) ); @@ -271,9 +273,9 @@ printDesignators( init->get_designators() ); output << "{ "; - if ( init->begin_initializers() == init->end_initializers() ) { + if ( init->begin() == init->end() ) { // illegal to leave initializer list empty for scalar initializers, but always legal to have 0 output << "0"; } else { - genCommaList( init->begin_initializers(), init->end_initializers() ); + genCommaList( init->begin(), init->end() ); } // if output << " }"; Index: src/GenPoly/DeclMutator.h =================================================================== --- src/GenPoly/DeclMutator.h (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/GenPoly/DeclMutator.h (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -28,7 +28,10 @@ class DeclMutator : public Mutator { public: + typedef Mutator Parent; + DeclMutator(); virtual ~DeclMutator(); - + + using Parent::mutate; virtual CompoundStmt* mutate(CompoundStmt *compoundStmt); virtual Statement* mutate(IfStmt *ifStmt); @@ -42,5 +45,5 @@ /// Mutates a list of declarations with this visitor void mutateDeclarationList(std::list< Declaration* >& decls); - + /// Called on entry to a new scope; overriders should call this as a super-class call virtual void doBeginScope(); Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/GenPoly/Specialize.cc (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -31,4 +31,5 @@ #include "Common/UniqueName.h" #include "Common/utility.h" +#include "InitTweak/InitTweak.h" namespace GenPoly { @@ -184,10 +185,13 @@ mutateAll( appExpr->get_args(), *this ); - // create thunks for the inferred parameters - for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) { - inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() ); - } - - handleExplicitParams( appExpr ); + if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) { + // create thunks for the inferred parameters + // don't need to do this for intrinsic calls, because they aren't actually passed + for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) { + inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() ); + } + + handleExplicitParams( appExpr ); + } return appExpr; Index: src/InitTweak/FixGlobalInit.cc =================================================================== --- src/InitTweak/FixGlobalInit.cc (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/InitTweak/FixGlobalInit.cc (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -46,47 +46,4 @@ FunctionDecl * destroyFunction; }; - - class ConstExprChecker : public Visitor { - public: - ConstExprChecker() : isConstExpr( true ) {} - - virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; } - virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; } - virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; } - virtual void visit( CastExpr *castExpr ) { isConstExpr = false; } - virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; } - virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; } - virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; } - virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; } - virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ } - // these might be okay? - // virtual void visit( SizeofExpr *sizeofExpr ); - // virtual void visit( AlignofExpr *alignofExpr ); - // virtual void visit( UntypedOffsetofExpr *offsetofExpr ); - // virtual void visit( OffsetofExpr *offsetofExpr ); - // virtual void visit( OffsetPackExpr *offsetPackExpr ); - // virtual void visit( AttrExpr *attrExpr ); - // virtual void visit( CommaExpr *commaExpr ); - // virtual void visit( LogicalExpr *logicalExpr ); - // virtual void visit( ConditionalExpr *conditionalExpr ); - virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; } - virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; } - virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; } - virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; } - virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; } - virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; } - - bool isConstExpr; - }; - - bool isConstExpr( Initializer * init ) { - if ( init ) { - ConstExprChecker checker; - init->accept( checker ); - return checker.isConstExpr; - } // if - // for all intents and purposes, no initializer means const expr - return true; - } void fixGlobalInit( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ) { @@ -140,6 +97,4 @@ std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids(); - if ( ! tryConstruct( objDecl ) ) return; // don't construct @= or designated objects - if ( objDecl->get_storageClass() == DeclarationNode::Extern ) return; // C allows you to initialize objects with constant expressions // xxx - this is an optimization. Need to first resolve constructors before we decide @@ -147,22 +102,27 @@ // if ( isConstExpr( objDecl->get_init() ) ) return; - if ( dynamic_cast< ArrayType * > ( objDecl->get_type() ) ) { - // xxx - initialize each element of the array - } else { - // steal initializer from object and attach it to a new temporary - ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, objDecl->get_type()->clone(), objDecl->get_init() ); - objDecl->set_init( NULL ); - initStatements.push_back( new DeclStmt( noLabels, newObj ) ); + if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) { + // a decision should have been made by the resolver, so ctor and init are not both non-NULL + assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); - // copy construct objDecl using temporary - UntypedExpr * init = new UntypedExpr( new NameExpr( "?{}" ) ); - init->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) ); - init->get_args().push_back( new VariableExpr( newObj ) ); - initStatements.push_back( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, init ) ) ); - - // add destructor calls to global destroy function - UntypedExpr * destroy = new UntypedExpr( new NameExpr( "^?{}" ) ); - destroy->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) ); - destroyStatements.push_front( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, destroy ) ) ); + Statement * dtor = ctorInit->get_dtor(); + if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) { + // don't need to call intrinsic dtor, because it does nothing, but + // non-intrinsic dtors must be called + destroyStatements.push_front( dtor ); + ctorInit->set_dtor( NULL ); + } // if + if ( Statement * ctor = ctorInit->get_ctor() ) { + initStatements.push_back( ctor ); + objDecl->set_init( NULL ); + ctorInit->set_ctor( NULL ); + } else if ( Initializer * init = ctorInit->get_init() ) { + objDecl->set_init( init ); + ctorInit->set_init( NULL ); + } else { + // no constructor and no initializer, which is okay + objDecl->set_init( NULL ); + } // if + delete ctorInit; } // if } Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/InitTweak/FixInit.cc (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -18,6 +18,7 @@ #include #include +#include "InitTweak.h" #include "FixInit.h" -#include "InitTweak.h" +#include "FixGlobalInit.h" #include "ResolvExpr/Resolver.h" #include "ResolvExpr/typeops.h" @@ -25,4 +26,5 @@ #include "SynTree/Type.h" #include "SynTree/Expression.h" +#include "SynTree/Attribute.h" #include "SynTree/Statement.h" #include "SynTree/Initializer.h" @@ -83,4 +85,5 @@ }; + // debug struct printSet { typedef ObjDeclCollector::ObjectSet ObjectSet; @@ -159,4 +162,6 @@ virtual DeclarationWithType * mutate( ObjectDecl *objDecl ); + + std::list< Declaration * > staticDtorDecls; }; @@ -171,5 +176,8 @@ } // namespace - void fix( std::list< Declaration * > & translationUnit ) { + void fix( std::list< Declaration * > & translationUnit, const std::string & filename, bool inLibrary ) { + // fixes ConstructorInit for global variables. should happen before fixInitializers. + InitTweak::fixGlobalInit( translationUnit, filename, inLibrary ); + InsertImplicitCalls::insert( translationUnit ); ResolveCopyCtors::resolveImplicitCalls( translationUnit ); @@ -194,5 +202,19 @@ void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) { FixInit fixer; - mutateAll( translationUnit, fixer ); + + // can't use mutateAll, because need to insert declarations at top-level + // can't use DeclMutator, because sometimes need to insert IfStmt, etc. + SemanticError errors; + for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) { + try { + *i = maybeMutate( *i, fixer ); + translationUnit.splice( i, fixer.staticDtorDecls ); + } catch( SemanticError &e ) { + errors.append( e ); + } // try + } // for + if ( ! errors.isEmpty() ) { + throw errors; + } // if } @@ -422,16 +444,27 @@ if ( Statement * ctor = ctorInit->get_ctor() ) { if ( objDecl->get_storageClass() == DeclarationNode::Static ) { + // originally wanted to take advantage of gcc nested functions, but + // we get memory errors with this approach. To remedy this, the static + // variable is hoisted when the destructor needs to be called. + // // generate: - // static bool __objName_uninitialized = true; - // if (__objName_uninitialized) { - // __ctor(__objName); - // void dtor_atexit() { - // __dtor(__objName); + // static T __objName_static_varN; + // void __objName_dtor_atexitN() { + // __dtor__...; + // } + // int f(...) { + // ... + // static bool __objName_uninitialized = true; + // if (__objName_uninitialized) { + // __ctor(__objName); + // __objName_uninitialized = false; + // atexit(__objName_dtor_atexitN); // } - // on_exit(dtorOnExit, &__objName); - // __objName_uninitialized = false; + // ... // } - // generate first line + static UniqueName dtorCallerNamer( "_dtor_atexit" ); + + // static bool __objName_uninitialized = true BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool ); SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators ); @@ -439,13 +472,4 @@ isUninitializedVar->fixUniqueId(); - // void dtor_atexit(...) {...} - FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + "_dtor_atexit", DeclarationNode::NoStorageClass, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false ); - dtorCaller->fixUniqueId(); - dtorCaller->get_statements()->get_kids().push_back( ctorInit->get_dtor()->clone() ); - - // on_exit(dtor_atexit); - UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) ); - callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) ); - // __objName_uninitialized = false; UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) ); @@ -457,6 +481,4 @@ std::list< Statement * > & body = initStmts->get_kids(); body.push_back( ctor ); - body.push_back( new DeclStmt( noLabels, dtorCaller ) ); - body.push_back( new ExprStmt( noLabels, callAtexit ) ); body.push_back( new ExprStmt( noLabels, setTrue ) ); @@ -465,4 +487,43 @@ stmtsToAddAfter.push_back( new DeclStmt( noLabels, isUninitializedVar ) ); stmtsToAddAfter.push_back( ifStmt ); + + if ( ctorInit->get_dtor() ) { + // if the object has a non-trivial destructor, have to + // hoist it and the object into the global space and + // call the destructor function with atexit. + + Statement * dtorStmt = ctorInit->get_dtor()->clone(); + + // void __objName_dtor_atexitN(...) {...} + FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false ); + dtorCaller->fixUniqueId(); + dtorCaller->get_statements()->get_kids().push_back( dtorStmt ); + + // atexit(dtor_atexit); + UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) ); + callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) ); + + body.push_back( new ExprStmt( noLabels, callAtexit ) ); + + // hoist variable and dtor caller decls to list of decls that will be added into global scope + staticDtorDecls.push_back( objDecl ); + staticDtorDecls.push_back( dtorCaller ); + + // need to rename object uniquely since it now appears + // at global scope and there could be multiple function-scoped + // static variables with the same name in different functions. + static UniqueName staticNamer( "_static_var" ); + objDecl->set_mangleName( objDecl->get_mangleName() + staticNamer.newName() ); + + objDecl->set_init( NULL ); + ctorInit->set_ctor( NULL ); + delete ctorInit; + + // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope + // create a new object which is never used + static UniqueName dummyNamer( "_dummy" ); + ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::Static, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } ); + return dummy; + } } else { stmtsToAddAfter.push_back( ctor ); @@ -524,5 +585,5 @@ assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); Statement * dtor = ctorInit->get_dtor(); - if ( dtor && ! isInstrinsicSingleArgCallStmt( dtor ) ) { + if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) { // don't need to call intrinsic dtor, because it does nothing, but // non-intrinsic dtors must be called Index: src/InitTweak/FixInit.h =================================================================== --- src/InitTweak/FixInit.h (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/InitTweak/FixInit.h (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -27,5 +27,5 @@ /// replace constructor initializers with expression statements /// and unwrap basic C-style initializers - void fix( std::list< Declaration * > & translationUnit ); + void fix( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ); } // namespace Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/InitTweak/GenInit.cc (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -26,4 +26,5 @@ #include "SymTab/Autogen.h" #include "GenPoly/PolyMutator.h" +#include "GenPoly/DeclMutator.h" namespace InitTweak { @@ -55,28 +56,57 @@ public: /// create constructor and destructor statements for object declarations. - /// Destructors are inserted directly into the code, whereas constructors - /// will be added in after the resolver has run so that the initializer expression - /// is only removed if a constructor is found + /// the actual call statements will be added in after the resolver has run + /// so that the initializer expression is only removed if a constructor is found + /// and the same destructor call is inserted in all of the appropriate locations. static void generateCtorDtor( std::list< Declaration * > &translationUnit ); - - CtorDtor() : inFunction( false ) {} virtual DeclarationWithType * mutate( ObjectDecl * ); virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); - virtual Declaration* mutate( StructDecl *aggregateDecl ); - virtual Declaration* mutate( UnionDecl *aggregateDecl ); - virtual Declaration* mutate( EnumDecl *aggregateDecl ); - virtual Declaration* mutate( TraitDecl *aggregateDecl ); - virtual TypeDecl* mutate( TypeDecl *typeDecl ); - virtual Declaration* mutate( TypedefDecl *typeDecl ); - - virtual Type * mutate( FunctionType *funcType ); + // should not traverse into any of these declarations to find objects + // that need to be constructed or destructed + virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; } + virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; } + virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; } + virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; } + virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; } + virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; } + + virtual Type * mutate( FunctionType *funcType ) { return funcType; } protected: - bool inFunction; + }; + + class HoistArrayDimension : public GenPoly::DeclMutator { + public: + typedef GenPoly::DeclMutator Parent; + + /// hoist dimension from array types in object declaration so that it uses a single + /// const variable of type size_t, so that side effecting array dimensions are only + /// computed once. + static void hoistArrayDimension( std::list< Declaration * > & translationUnit ); + + private: + virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ); + virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); + // should not traverse into any of these declarations to find objects + // that need to be constructed or destructed + virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; } + virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; } + virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; } + virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; } + virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; } + virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; } + + virtual Type* mutate( FunctionType *funcType ) { return funcType; } + + void hoist( Type * type ); + + DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass; + bool inFunction = false; }; void genInit( std::list< Declaration * > & translationUnit ) { ReturnFixer::makeReturnTemp( translationUnit ); + HoistArrayDimension::hoistArrayDimension( translationUnit ); CtorDtor::generateCtorDtor( translationUnit ); } @@ -124,4 +154,53 @@ } + // precompute array dimension expression, because constructor generation may duplicate it, + // which would be incorrect if it is a side-effecting computation. + void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) { + HoistArrayDimension hoister; + hoister.mutateDeclarationList( translationUnit ); + } + + DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) { + storageclass = objectDecl->get_storageClass(); + DeclarationWithType * temp = Parent::mutate( objectDecl ); + hoist( objectDecl->get_type() ); + storageclass = DeclarationNode::NoStorageClass; + return temp; + } + + void HoistArrayDimension::hoist( Type * type ) { + // if in function, generate const size_t var + static UniqueName dimensionName( "_array_dim" ); + + // C doesn't allow variable sized arrays at global scope or for static variables, + // so don't hoist dimension. + if ( ! inFunction ) return; + if ( storageclass == DeclarationNode::Static ) return; + + if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) { + if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist? + + // don't need to hoist dimension if it's a constexpr - only need to if there's potential + // for side effects. + if ( isConstExpr( arrayType->get_dimension() ) ) return; + + ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) ); + arrayDimension->get_type()->set_isConst( true ); + + arrayType->set_dimension( new VariableExpr( arrayDimension ) ); + addDeclaration( arrayDimension ); + + hoist( arrayType->get_base() ); + return; + } + } + + DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) { + bool oldInFunc = inFunction; + inFunction = true; + DeclarationWithType * decl = Parent::mutate( functionDecl ); + inFunction = oldInFunc; + return decl; + } void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) { @@ -130,60 +209,34 @@ } - namespace { - Expression * makeCtorDtorExpr( std::string name, ObjectDecl * objDecl, std::list< Expression * > args ) { - UntypedExpr * expr = new UntypedExpr( new NameExpr( name ) ); - expr->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) ); - expr->get_args().splice( expr->get_args().end(), args ); - return expr; - } - } - DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) { - // hands off if designated or if @= + // hands off if designated, if @=, or if extern if ( tryConstruct( objDecl ) ) { - if ( inFunction ) { - if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) { - // call into makeArrayFunction from validate.cc to generate calls to ctor/dtor for each element of array - // TODO: walk initializer and generate appropriate copy ctor if element has initializer - std::list< Expression * > args = makeInitList( objDecl->get_init() ); - if ( args.empty() ) { - std::list< Statement * > ctor; - std::list< Statement * > dtor; - - SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "?{}", back_inserter( ctor ) ); - SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "^?{}", front_inserter( dtor ), false ); - - // Currently makeArrayFunction produces a single Statement - a CompoundStmt - // which wraps everything that needs to happen. As such, it's technically - // possible to use a Statement ** in the above calls, but this is inherently - // unsafe, so instead we take the slightly less efficient route, but will be - // immediately informed if somehow the above assumption is broken. In this case, - // we could always wrap the list of statements at this point with a CompoundStmt, - // but it seems reasonable at the moment for this to be done by makeArrayFunction - // itself - assert( ctor.size() == 1 && dynamic_cast< ImplicitCtorDtorStmt * >( ctor.front() ) ); - assert( dtor.size() == 1 && dynamic_cast< ImplicitCtorDtorStmt * >( dtor.front() ) ); - objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) ); - } else { - // array came with an initializer list: initialize each element - // may have more initializers than elements in the array - need to check at each index that - // we haven't exceeded size. This requires precomputing the size because it might be a side-effecting - // computation. - // may have fewer initializers than eleemnts in the array - need to default construct - // remaining elements. - // might be able to merge this with the case above. - } - } else { - // it's sufficient to attempt to call the ctor/dtor for the given object and its initializer - Expression * ctor = makeCtorDtorExpr( "?{}", objDecl, makeInitList( objDecl->get_init() ) ); - Expression * dtor = makeCtorDtorExpr( "^?{}", objDecl, std::list< Expression * >() ); - - // need to remember init expression, in case no ctors exist - // if ctor does exist, want to use ctor expression instead of init - // push this decision to the resolver - ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor ); - ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor ); - objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) ); - } + // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor + // for each constructable object + std::list< Statement * > ctor; + std::list< Statement * > dtor; + + InitExpander srcParam( objDecl->get_init() ); + InitExpander nullParam( (Initializer *)NULL ); + SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl ); + SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false ); + + // Currently genImplicitCall produces a single Statement - a CompoundStmt + // which wraps everything that needs to happen. As such, it's technically + // possible to use a Statement ** in the above calls, but this is inherently + // unsafe, so instead we take the slightly less efficient route, but will be + // immediately informed if somehow the above assumption is broken. In this case, + // we could always wrap the list of statements at this point with a CompoundStmt, + // but it seems reasonable at the moment for this to be done by genImplicitCall + // itself. It is possible that genImplicitCall produces no statements (e.g. if + // an array type does not have a dimension). In this case, it's fine to ignore + // the object for the purposes of construction. + assert( ctor.size() == dtor.size() && ctor.size() <= 1 ); + if ( ctor.size() == 1 ) { + // need to remember init expression, in case no ctors exist + // if ctor does exist, want to use ctor expression instead of init + // push this decision to the resolver + assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) ); + objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) ); } } @@ -193,22 +246,8 @@ DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) { // parameters should not be constructed and destructed, so don't mutate FunctionType - bool oldInFunc = inFunction; mutateAll( functionDecl->get_oldDecls(), *this ); - inFunction = true; functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); - inFunction = oldInFunc; return functionDecl; } - - // should not traverse into any of these declarations to find objects - // that need to be constructed or destructed - Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) { return aggregateDecl; } - Declaration* CtorDtor::mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; } - Declaration* CtorDtor::mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; } - Declaration* CtorDtor::mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; } - TypeDecl* CtorDtor::mutate( TypeDecl *typeDecl ) { return typeDecl; } - Declaration* CtorDtor::mutate( TypedefDecl *typeDecl ) { return typeDecl; } - Type* CtorDtor::mutate( FunctionType *funcType ) { return funcType; } - } // namespace InitTweak Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision dae881f61dcc6f8cfd54c3e290f737e7bbd9212f) +++ src/InitTweak/InitTweak.cc (revision 1b0020a936c9eda0e3b3c47045c62fc5c51b82ce) @@ -1,2 +1,3 @@ +#include #include "InitTweak.h" #include "SynTree/Visitor.h" @@ -4,4 +5,5 @@ #include "SynTree/Initializer.h" #include "SynTree/Expression.h" +#include "SynTree/Attribute.h" #include "GenPoly/GenPoly.h" @@ -20,7 +22,6 @@ }; - class InitExpander : public Visitor { + class InitFlattener : public Visitor { public: - InitExpander() {} virtual void visit( SingleInit * singleInit ); virtual void visit( ListInit * listInit ); @@ -28,12 +29,12 @@ }; - void InitExpander::visit( SingleInit * singleInit ) { + void InitFlattener::visit( SingleInit * singleInit ) { argList.push_back( singleInit->get_value()->clone() ); } - void InitExpander::visit( ListInit * listInit ) { - // xxx - for now, assume no nested list inits - std::list::iterator it = listInit->begin_initializers(); - for ( ; it != listInit->end_initializers(); ++it ) { + void InitFlattener::visit( ListInit * listInit ) { + // flatten nested list inits + std::list::iterator it = listInit->begin(); + for ( ; it != listInit->end(); ++it ) { (*it)->accept( *this ); } @@ -42,7 +43,7 @@ std::list< Expression * > makeInitList( Initializer * init ) { - InitExpander expander; - maybeAccept( init, expander ); - return expander.argList; + InitFlattener flattener; + maybeAccept( init, flattener ); + return flattener.argList; } @@ -53,48 +54,254 @@ } + class InitExpander::ExpanderImpl { + public: + virtual std::list< Expression * > next( std::list< Expression * > & indices ) = 0; + virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ) = 0; + }; + + class InitImpl : public InitExpander::ExpanderImpl { + public: + InitImpl( Initializer * init ) : init( init ) {} + + virtual std::list< Expression * > next( std::list< Expression * > & indices ) { + // this is wrong, but just a placeholder for now + // if ( ! flattened ) flatten( indices ); + // return ! inits.empty() ? makeInitList( inits.front() ) : std::list< Expression * >(); + return makeInitList( init ); + } + + virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ); + private: + Initializer * init; + }; + + class ExprImpl : public InitExpander::ExpanderImpl { + public: + ExprImpl( Expression * expr ) : arg( expr ) {} + + virtual std::list< Expression * > next( std::list< Expression * > & indices ) { + std::list< Expression * > ret; + Expression * expr = maybeClone( arg ); + if ( expr ) { + for ( std::list< Expression * >::reverse_iterator it = indices.rbegin(); it != indices.rend(); ++it ) { + // go through indices and layer on subscript exprs ?[?] + ++it; + UntypedExpr * subscriptExpr = new UntypedExpr( new NameExpr( "?[?]") ); + subscriptExpr->get_args().push_back( expr ); + subscriptExpr->get_args().push_back( (*it)->clone() ); + expr = subscriptExpr; + } + ret.push_back( expr ); + } + return ret; + } + + virtual Statement * buildListInit( UntypedExpr * callExpr, std::list< Expression * > & indices ); + private: + Expression * arg; + }; + + InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {} + + InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {} + + std::list< Expression * > InitExpander::operator*() { + return cur; + } + + InitExpander & InitExpander::operator++() { + cur = expander->next( indices ); + return *this; + } + + // use array indices list to build switch statement + void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) { + indices.push_back( index ); + indices.push_back( dimension ); + } + + void InitExpander::clearArrayIndices() { + indices.clear(); + } + + namespace { + /// given index i, dimension d, initializer init, and callExpr f, generates + /// if (i < d) f(..., init) + /// ++i; + /// so that only elements within the range of the array are constructed + template< typename OutIterator > + void buildCallExpr( UntypedExpr * callExpr, Expression * index, Expression * dimension, Initializer * init, OutIterator out ) { + UntypedExpr * cond = new UntypedExpr( new NameExpr( "?get_args().push_back( index->clone() ); + cond->get_args().push_back( dimension->clone() ); + + std::list< Expression * > args = makeInitList( init ); + callExpr->get_args().splice( callExpr->get_args().end(), args ); + + *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL ); + + UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) ); + increment->get_args().push_back( new AddressExpr( index->clone() ) ); + *out++ = new ExprStmt( noLabels, increment ); + } + + template< typename OutIterator > + void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) { + if ( idx == idxEnd ) return; + Expression * index = *idx++; + assert( idx != idxEnd ); + Expression * dimension = *idx++; + + // xxx - may want to eventually issue a warning here if we can detect + // that the number of elements exceeds to dimension of the array + if ( idx == idxEnd ) { + if ( ListInit * listInit = dynamic_cast< ListInit * >( init ) ) { + for ( Initializer * init : *listInit ) { + buildCallExpr( callExpr->clone(), index, dimension, init, out ); + } + } else { + buildCallExpr( callExpr->clone(), index, dimension, init, out ); + } + } else { + std::list< Statement * > branches; + + unsigned long cond = 0; + ListInit * listInit = dynamic_cast< ListInit * >( init ); + if ( ! listInit ) { + // xxx - this shouldn't be an error, but need a way to + // terminate without creating output, so should catch this error + throw SemanticError( "unbalanced list initializers" ); + } + + static UniqueName targetLabel( "L__autogen__" ); + Label switchLabel( targetLabel.newName(), 0, std::list< Attribute * >{ new Attribute("unused") } ); + for ( Initializer * init : *listInit ) { + Expression * condition; + // check for designations + // if ( init-> ) { + condition = new ConstantExpr( Constant::from_ulong( cond ) ); + ++cond; + // } else { + // condition = // ... take designation + // cond = // ... take designation+1 + // } + std::list< Statement * > stmts; + build( callExpr, idx, idxEnd, init, back_inserter( stmts ) ); + stmts.push_back( new BranchStmt( noLabels, switchLabel, BranchStmt::Break ) ); + CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts ); + branches.push_back( caseStmt ); + } + *out++ = new SwitchStmt( noLabels, index->clone(), branches ); + *out++ = new NullStmt( std::list