Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/Common/utility.h (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -261,8 +261,8 @@ template< typename T > -struct ReverseIter { +struct reverseIterate_t { T& ref; - ReverseIter( T & ref ) : ref(ref) {} + reverseIterate_t( T & ref ) : ref(ref) {} typedef typename T::reverse_iterator iterator; @@ -272,6 +272,6 @@ template< typename T > -ReverseIter< T > ReverseIterate( T & ref ) { - return ReverseIter< T >( ref ); +reverseIterate_t< T > reverseIterate( T & ref ) { + return reverseIterate_t< T >( ref ); } Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/GenPoly/Box.cc (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -158,4 +158,7 @@ class PolyGenericCalculator : public PolyMutator { public: + typedef PolyMutator Parent; + using Parent::mutate; + template< typename DeclClass > DeclClass *handleDecl( DeclClass *decl, Type *type ); @@ -1675,21 +1678,27 @@ DeclClass * PolyGenericCalculator::handleDecl( DeclClass *decl, Type *type ) { beginTypeScope( type ); + // knownLayouts.beginScope(); + // knownOffsets.beginScope(); + + DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) ); + + // knownOffsets.endScope(); + // knownLayouts.endScope(); + endTypeScope(); + return ret; + } + + ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) { + return handleDecl( objectDecl, objectDecl->get_type() ); + } + + DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) { knownLayouts.beginScope(); knownOffsets.beginScope(); - DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) ); - + DeclarationWithType * decl = handleDecl( functionDecl, functionDecl->get_functionType() ); knownOffsets.endScope(); knownLayouts.endScope(); - endTypeScope(); - return ret; - } - - ObjectDecl * PolyGenericCalculator::mutate( ObjectDecl *objectDecl ) { - return handleDecl( objectDecl, objectDecl->get_type() ); - } - - DeclarationWithType * PolyGenericCalculator::mutate( FunctionDecl *functionDecl ) { - return handleDecl( functionDecl, functionDecl->get_functionType() ); + return decl; } @@ -1700,5 +1709,5 @@ TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) { scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind(); - return Mutator::mutate( typeDecl ); + return Parent::mutate( typeDecl ); } @@ -1706,5 +1715,5 @@ beginTypeScope( pointerType ); - Type *ret = Mutator::mutate( pointerType ); + Type *ret = Parent::mutate( pointerType ); endTypeScope(); @@ -1724,5 +1733,5 @@ } - Type *ret = Mutator::mutate( funcType ); + Type *ret = Parent::mutate( funcType ); endTypeScope(); @@ -1745,5 +1754,5 @@ } } - return Mutator::mutate( declStmt ); + return Parent::mutate( declStmt ); } @@ -1787,5 +1796,5 @@ Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) { // mutate, exiting early if no longer MemberExpr - Expression *expr = Mutator::mutate( memberExpr ); + Expression *expr = Parent::mutate( memberExpr ); memberExpr = dynamic_cast< MemberExpr* >( expr ); if ( ! memberExpr ) return expr; @@ -1972,5 +1981,5 @@ Expression *PolyGenericCalculator::mutate( OffsetofExpr *offsetofExpr ) { // mutate, exiting early if no longer OffsetofExpr - Expression *expr = Mutator::mutate( offsetofExpr ); + Expression *expr = Parent::mutate( offsetofExpr ); offsetofExpr = dynamic_cast< OffsetofExpr* >( expr ); if ( ! offsetofExpr ) return expr; Index: src/GenPoly/PolyMutator.h =================================================================== --- src/GenPoly/PolyMutator.h (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/GenPoly/PolyMutator.h (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -5,5 +5,5 @@ // file "LICENCE" distributed with Cforall. // -// PolyMutator.h -- +// PolyMutator.h -- // // Author : Richard C. Bilson @@ -30,4 +30,7 @@ class PolyMutator : public Mutator { public: + typedef Mutator Parent; + using Parent::mutate; + PolyMutator(); @@ -42,5 +45,5 @@ virtual Statement* mutate(ExprStmt *catchStmt); virtual Statement* mutate(ReturnStmt *catchStmt); - + virtual Expression* mutate(UntypedExpr *untypedExpr); @@ -54,5 +57,5 @@ Statement* mutateStatement( Statement *stmt ); Expression* mutateExpression( Expression *expr ); - + TyVarMap scopeTyVars; TypeSubstitution *env; @@ -60,5 +63,5 @@ std::list< Statement* > stmtsToAddAfter; }; -} // namespace +} // namespace #endif // _POLYMUTATOR_H Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/InitTweak/FixInit.cc (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -787,5 +787,5 @@ // need to iterate through members in reverse in order for // ctor/dtor statements to come out in the right order - for ( Declaration * member : ReverseIterate( structDecl->get_members() ) ) { + for ( Declaration * member : reverseIterate( structDecl->get_members() ) ) { DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ); // skip non-DWT members Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/InitTweak/GenInit.cc (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -25,6 +25,8 @@ #include "SynTree/Mutator.h" #include "SymTab/Autogen.h" +#include "SymTab/Mangler.h" #include "GenPoly/PolyMutator.h" #include "GenPoly/DeclMutator.h" +#include "GenPoly/ScopedSet.h" namespace InitTweak { @@ -55,4 +57,6 @@ class CtorDtor : public GenPoly::PolyMutator { public: + typedef GenPoly::PolyMutator Parent; + using Parent::mutate; /// create constructor and destructor statements for object declarations. /// the actual call statements will be added in after the resolver has run @@ -65,5 +69,5 @@ // 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( StructDecl *aggregateDecl ); virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; } virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; } @@ -74,5 +78,15 @@ virtual Type * mutate( FunctionType *funcType ) { return funcType; } - protected: + virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ); + + private: + // set of mangled type names for which a constructor or destructor exists in the current scope. + // these types require a ConstructorInit node to be generated, anything else is a POD type and thus + // should not have a ConstructorInit generated. + + bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed + void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor + GenPoly::ScopedSet< std::string > managedTypes; + bool inFunction = false; }; @@ -142,6 +156,6 @@ DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) { - std::list oldReturnVals = returnVals; - std::string oldFuncName = funcName; + ValueGuard< std::list > oldReturnVals( returnVals ); + ValueGuard< std::string > oldFuncName( funcName ); FunctionType * type = functionDecl->get_functionType(); @@ -149,6 +163,4 @@ funcName = functionDecl->get_name(); DeclarationWithType * decl = Mutator::mutate( functionDecl ); - returnVals = oldReturnVals; - funcName = oldFuncName; return decl; } @@ -197,8 +209,7 @@ DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) { - bool oldInFunc = inFunction; + ValueGuard< bool > oldInFunc( inFunction ); inFunction = true; DeclarationWithType * decl = Parent::mutate( functionDecl ); - inFunction = oldInFunc; return decl; } @@ -209,7 +220,31 @@ } + bool CtorDtor::isManaged( ObjectDecl * objDecl ) const { + Type * type = objDecl->get_type(); + while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) { + type = at->get_base(); + } + return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end(); + } + + void CtorDtor::handleDWT( DeclarationWithType * dwt ) { + // if this function is a user-defined constructor or destructor, mark down the type as "managed" + if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) { + std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters(); + assert( ! params.empty() ); + PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() ); + managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) ); + } + } + DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) { - // hands off if designated, if @=, or if extern - if ( tryConstruct( objDecl ) ) { + handleDWT( objDecl ); + // hands off if @=, extern, builtin, etc. + // if global but initializer is not constexpr, always try to construct, since this is not legal C + if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) { + // constructed objects cannot be designated + if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl ); + // xxx - constructed objects should not have initializers nested too deeply + // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor // for each constructable object @@ -241,13 +276,49 @@ } } - return Mutator::mutate( objDecl ); + return Parent::mutate( objDecl ); } DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) { + ValueGuard< bool > oldInFunc = inFunction; + inFunction = true; + + handleDWT( functionDecl ); + + managedTypes.beginScope(); + // go through assertions and recursively add seen ctor/dtors + for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) { + for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) { + assertion = assertion->acceptMutator( *this ); + } + } // parameters should not be constructed and destructed, so don't mutate FunctionType mutateAll( functionDecl->get_oldDecls(), *this ); functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + + managedTypes.endScope(); return functionDecl; } + + Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) { + // don't construct members, but need to take note if there is a managed member, + // because that means that this type is also managed + for ( Declaration * member : aggregateDecl->get_members() ) { + if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) { + if ( isManaged( field ) ) { + managedTypes.insert( SymTab::Mangler::mangle( aggregateDecl ) ); + break; + } + } + } + return aggregateDecl; + } + + CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) { + managedTypes.beginScope(); + CompoundStmt * stmt = Parent::mutate( compoundStmt ); + managedTypes.endScope(); + return stmt; + } + } // namespace InitTweak Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/InitTweak/InitTweak.cc (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -232,6 +232,5 @@ return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) && (objDecl->get_init() == NULL || - ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) && - ! isDesignated( objDecl->get_init() ) + ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) && objDecl->get_storageClass() != DeclarationNode::Extern; } @@ -391,11 +390,18 @@ 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( NameExpr *nameExpr ) { + // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today + if ( nameExpr->get_name() != "0" && nameExpr->get_name() != "1" ) isConstExpr = false; + } + // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; } + virtual void visit( AddressExpr *addressExpr ) { + // address of a variable or member expression is constexpr + Expression * arg = addressExpr->get_arg(); + if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) 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 ); Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/ResolvExpr/Resolver.cc (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -528,13 +528,7 @@ void Resolver::visit( ConstructorInit *ctorInit ) { - try { - maybeAccept( ctorInit->get_ctor(), *this ); - maybeAccept( ctorInit->get_dtor(), *this ); - } catch ( SemanticError ) { - // no alternatives for the constructor initializer - fallback on C-style initializer - // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation? - fallbackInit( ctorInit ); - return; - } + // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit + maybeAccept( ctorInit->get_ctor(), *this ); + maybeAccept( ctorInit->get_dtor(), *this ); // found a constructor - can get rid of C-style initializer Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/SymTab/Indexer.cc (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -21,4 +21,5 @@ #include #include +#include #include "Mangler.h" @@ -33,4 +34,6 @@ #include "SynTree/Initializer.h" #include "SynTree/Statement.h" + +#include "InitTweak/InitTweak.h" #define debugPrint(x) if ( doDebug ) { std::cout << x; } @@ -99,4 +102,66 @@ if ( --toFree->refCount == 0 ) delete toFree; + } + + void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const { + // only need to perform this step for constructors and destructors + if ( ! InitTweak::isCtorDtor( id ) ) return; + + // helpful data structure + struct ValueType { + struct DeclBall { + FunctionDecl * decl; + bool isUserDefinedFunc; // properties for this particular decl + bool isDefaultFunc; + bool isCopyFunc; + }; + // properties for this type + bool userDefinedFunc = false; // any user defined function found + bool userDefinedDefaultFunc = false; // user defined default ctor found + bool userDefinedCopyFunc = false; // user defined copy ctor found + std::list< DeclBall > decls; + + // another FunctionDecl for the current type was found - determine + // if it has special properties and update data structure accordingly + ValueType & operator+=( FunctionDecl * function ) { + bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() ); + bool isDefaultFunc = function->get_functionType()->get_parameters().size() == 1; + bool isCopyFunc = InitTweak::isCopyConstructor( function ); + decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultFunc, isCopyFunc } ); + userDefinedFunc = userDefinedFunc || isUserDefinedFunc; + userDefinedDefaultFunc = userDefinedDefaultFunc || (isUserDefinedFunc && isDefaultFunc); + userDefinedCopyFunc = userDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc); + return *this; + } + }; // ValueType + + std::list< DeclarationWithType * > copy; + copy.splice( copy.end(), out ); + + // organize discovered declarations by type + std::unordered_map< std::string, ValueType > funcMap; + for ( DeclarationWithType * decl : copy ) { + if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) { + std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters(); + assert( ! params.empty() ); + funcMap[ Mangler::mangle( params.front()->get_type() ) ] += function; + } else { + out.push_back( decl ); + } + } + + // if a type contains user defined ctor/dtors, then special rules trigger, which determine + // the set of ctor/dtors that are seen by the requester. In particular, if the user defines + // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor + // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen. + for ( std::pair< const std::string, ValueType > & pair : funcMap ) { + ValueType & val = pair.second; + for ( ValueType::DeclBall ball : val.decls ) { + if ( ! val.userDefinedFunc || ball.isUserDefinedFunc || (! val.userDefinedDefaultFunc && ball.isDefaultFunc) || (! val.userDefinedCopyFunc && ball.isCopyFunc) ) { + // decl conforms to the rules described above, so it should be seen by the requester + out.push_back( ball.decl ); + } + } + } } @@ -461,4 +526,9 @@ searchTables = searchTables->base.tables; } + + // some special functions, e.g. constructors and destructors + // remove autogenerated functions when they are defined so that + // they can never be matched + removeSpecialOverrides( id, out ); } Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/SymTab/Indexer.h (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -128,4 +128,9 @@ static void deleteRef( Impl *toFree ); + // Removes matching autogenerated constructors and destructors + // so that they will not be selected + // void removeSpecialOverrides( FunctionDecl *decl ); + void removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const; + /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope) void makeWritable(); Index: src/tests/.expect/64/declarationSpecifier.txt =================================================================== --- src/tests/.expect/64/declarationSpecifier.txt (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/tests/.expect/64/declarationSpecifier.txt (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -530,38 +530,2 @@ return ((int )_retVal0); } -__attribute__ ((constructor(),)) static void _init_declarationSpecifier(void){ - ((void)___constructor__F_P13s__anonymous0_autogen___1(((struct __anonymous0 *)(&__x10__CV13s__anonymous0_1)))); - ((void)___constructor__F_P13s__anonymous1_autogen___1(((struct __anonymous1 *)(&__x11__CV13s__anonymous1_1)))); - ((void)___constructor__F_P13s__anonymous2_autogen___1(((struct __anonymous2 *)(&__x12__CV13s__anonymous2_1)))); - ((void)___constructor__F_P13s__anonymous3_autogen___1(((struct __anonymous3 *)(&__x13__CV13s__anonymous3_1)))); - ((void)___constructor__F_P13s__anonymous4_autogen___1(((struct __anonymous4 *)(&__x14__CV13s__anonymous4_1)))); - ((void)___constructor__F_P13s__anonymous5_autogen___1(((struct __anonymous5 *)(&__x15__CV13s__anonymous5_1)))); - ((void)___constructor__F_P13s__anonymous6_autogen___1(((struct __anonymous6 *)(&__x16__CV13s__anonymous6_1)))); - ((void)___constructor__F_P13s__anonymous7_autogen___1(((struct __anonymous7 *)(&__x17__CV13s__anonymous7_1)))); - ((void)___constructor__F_P13s__anonymous8_autogen___1(((struct __anonymous8 *)(&__x29__CV13s__anonymous8_1)))); - ((void)___constructor__F_P13s__anonymous9_autogen___1(((struct __anonymous9 *)(&__x30__CV13s__anonymous9_1)))); - ((void)___constructor__F_P14s__anonymous10_autogen___1(((struct __anonymous10 *)(&__x31__CV14s__anonymous10_1)))); - ((void)___constructor__F_P14s__anonymous11_autogen___1(((struct __anonymous11 *)(&__x32__CV14s__anonymous11_1)))); - ((void)___constructor__F_P14s__anonymous12_autogen___1(((struct __anonymous12 *)(&__x33__CV14s__anonymous12_1)))); - ((void)___constructor__F_P14s__anonymous13_autogen___1(((struct __anonymous13 *)(&__x34__CV14s__anonymous13_1)))); - ((void)___constructor__F_P14s__anonymous14_autogen___1(((struct __anonymous14 *)(&__x35__CV14s__anonymous14_1)))); - ((void)___constructor__F_P14s__anonymous15_autogen___1(((struct __anonymous15 *)(&__x36__CV14s__anonymous15_1)))); -} -__attribute__ ((destructor(),)) static void _destroy_declarationSpecifier(void){ - ((void)___destructor__F_P14s__anonymous15_autogen___1(((struct __anonymous15 *)(&__x36__CV14s__anonymous15_1)))); - ((void)___destructor__F_P14s__anonymous14_autogen___1(((struct __anonymous14 *)(&__x35__CV14s__anonymous14_1)))); - ((void)___destructor__F_P14s__anonymous13_autogen___1(((struct __anonymous13 *)(&__x34__CV14s__anonymous13_1)))); - ((void)___destructor__F_P14s__anonymous12_autogen___1(((struct __anonymous12 *)(&__x33__CV14s__anonymous12_1)))); - ((void)___destructor__F_P14s__anonymous11_autogen___1(((struct __anonymous11 *)(&__x32__CV14s__anonymous11_1)))); - ((void)___destructor__F_P14s__anonymous10_autogen___1(((struct __anonymous10 *)(&__x31__CV14s__anonymous10_1)))); - ((void)___destructor__F_P13s__anonymous9_autogen___1(((struct __anonymous9 *)(&__x30__CV13s__anonymous9_1)))); - ((void)___destructor__F_P13s__anonymous8_autogen___1(((struct __anonymous8 *)(&__x29__CV13s__anonymous8_1)))); - ((void)___destructor__F_P13s__anonymous7_autogen___1(((struct __anonymous7 *)(&__x17__CV13s__anonymous7_1)))); - ((void)___destructor__F_P13s__anonymous6_autogen___1(((struct __anonymous6 *)(&__x16__CV13s__anonymous6_1)))); - ((void)___destructor__F_P13s__anonymous5_autogen___1(((struct __anonymous5 *)(&__x15__CV13s__anonymous5_1)))); - ((void)___destructor__F_P13s__anonymous4_autogen___1(((struct __anonymous4 *)(&__x14__CV13s__anonymous4_1)))); - ((void)___destructor__F_P13s__anonymous3_autogen___1(((struct __anonymous3 *)(&__x13__CV13s__anonymous3_1)))); - ((void)___destructor__F_P13s__anonymous2_autogen___1(((struct __anonymous2 *)(&__x12__CV13s__anonymous2_1)))); - ((void)___destructor__F_P13s__anonymous1_autogen___1(((struct __anonymous1 *)(&__x11__CV13s__anonymous1_1)))); - ((void)___destructor__F_P13s__anonymous0_autogen___1(((struct __anonymous0 *)(&__x10__CV13s__anonymous0_1)))); -} Index: src/tests/.expect/64/extension.txt =================================================================== --- src/tests/.expect/64/extension.txt (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/tests/.expect/64/extension.txt (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -86,6 +86,5 @@ __extension__ int __c__i_2; }; - int __i__i_2; - ((void)((*((int *)(&__i__i_2)))=(__extension__ __a__i_1+__extension__ 3)) /* ?{} */); + int __i__i_2 = ((int )(__extension__ __a__i_1+__extension__ 3)); ((void)__extension__ 3); ((void)__extension__ __a__i_1); Index: src/tests/.expect/64/gccExtensions.txt =================================================================== --- src/tests/.expect/64/gccExtensions.txt (revision 85517ddb80a87a5c4695d8b50281ac0813ba271b) +++ src/tests/.expect/64/gccExtensions.txt (revision 1ba88a0e455e57ec77fa646372ffd0c5ef7e999c) @@ -76,6 +76,5 @@ ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=__c__i_2) /* ?{} */); } - int __i__i_2; - ((void)((*((int *)(&__i__i_2)))=__extension__ 3) /* ?{} */); + int __i__i_2 = ((int )__extension__ 3); __extension__ int __a__i_2; __extension__ int __b__i_2; @@ -133,7 +132,5 @@ } struct s3 __x1__3ss3_2; - ((void)___constructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2)))); struct s3 __y1__3ss3_2; - ((void)___constructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2)))); struct s4 { int __i__i_2; @@ -141,6 +138,4 @@ inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){ ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2)); - ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2)))); - ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2)))); return ((struct s4 )___src__3ss4_2); } @@ -158,7 +153,5 @@ } struct s4 __x2__3ss4_2; - ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2)))); struct s4 __y2__3ss4_2; - ((void)___constructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2)))); int __m1__A0i_2[((long unsigned int )10)]; int __m2__A0A0i_2[((long unsigned int )10)][((long unsigned int )10)]; @@ -166,12 +159,4 @@ int _retVal0 = { 0 }; ((void)(_retVal0=0) /* ?{} */); - ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2)))); - ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2)))); - ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2)))); - ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2)))); return ((int )_retVal0); - ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__y2__3ss4_2)))); - ((void)___destructor__F_P3ss4_autogen___2(((struct s4 *)(&__x2__3ss4_2)))); - ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__y1__3ss3_2)))); - ((void)___destructor__F_P3ss3_autogen___2(((struct s3 *)(&__x1__3ss3_2)))); }