Changeset 1ba88a0 for src

Timestamp:

Sep 4, 2016, 3:25:32 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

b16898e

Parents:

85517ddb

Message:

implement implicit ctor/dtor deletion, track managed types when inserting ConstructorInit? nodes, remove fallbackInit case, update tests

Location:

src

Files:

• Common/utility.h (modified) (2 diffs)
• GenPoly/Box.cc (modified) (8 diffs)
• GenPoly/PolyMutator.h (modified) (5 diffs)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (9 diffs)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• SymTab/Indexer.cc (modified) (4 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• tests/.expect/64/declarationSpecifier.txt (modified) (1 diff)
• tests/.expect/64/extension.txt (modified) (1 diff)
• tests/.expect/64/gccExtensions.txt (modified) (5 diffs)

src/Common/utility.h

@@ -261 +261 @@
 
 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 +272 @@
 
 template< typename T >
-ReverseIter< T > ReverseIterate( T & ref ) {
-        return ReverseIter< T >( ref );
+reverseIterate_t< T > reverseIterate( T & ref ) {
+        return reverseIterate_t< T >( ref );
 }
 

src/GenPoly/Box.cc

@@ -158 +158 @@
                 class PolyGenericCalculator : public PolyMutator {
                 public:
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
+
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -1675 +1678 @@
                 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 +1709 @@
                 TypeDecl * PolyGenericCalculator::mutate( TypeDecl *typeDecl ) {
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-                        return Mutator::mutate( typeDecl );
+                        return Parent::mutate( typeDecl );
                 }
 
@@ -1706 +1715 @@
                         beginTypeScope( pointerType );
 
-                        Type *ret = Mutator::mutate( pointerType );
+                        Type *ret = Parent::mutate( pointerType );
 
                         endTypeScope();
@@ -1724 +1733 @@
                         }
 
-                        Type *ret = Mutator::mutate( funcType );
+                        Type *ret = Parent::mutate( funcType );
 
                         endTypeScope();
@@ -1745 +1754 @@
                                 }
                         }
-                        return Mutator::mutate( declStmt );
+                        return Parent::mutate( declStmt );
                 }
 
@@ -1787 +1796 @@
                 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 +1981 @@
                 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;

src/GenPoly/PolyMutator.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// PolyMutator.h -- 
+// PolyMutator.h --
 //
 // Author           : Richard C. Bilson
@@ -30 +30 @@
         class PolyMutator : public Mutator {
           public:
+                typedef Mutator Parent;
+                using Parent::mutate;
+
                 PolyMutator();
 
@@ -42 +45 @@
                 virtual Statement* mutate(ExprStmt *catchStmt);
                 virtual Statement* mutate(ReturnStmt *catchStmt);
-  
+
                 virtual Expression* mutate(UntypedExpr *untypedExpr);
 
@@ -54 +57 @@
                 Statement* mutateStatement( Statement *stmt );
                 Expression* mutateExpression( Expression *expr );
-  
+
                 TyVarMap scopeTyVars;
                 TypeSubstitution *env;
@@ -60 +63 @@
                 std::list< Statement* > stmtsToAddAfter;
         };
-} // namespace 
+} // namespace
 
 #endif // _POLYMUTATOR_H

src/InitTweak/FixInit.cc

@@ -787 +787 @@
                                 // 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

src/InitTweak/GenInit.cc

@@ -25 +25 @@
 #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 +57 @@
         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 +69 @@
                 // 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 +78 @@
                 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 +156 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                std::list<DeclarationWithType*> oldReturnVals = returnVals;
-                std::string oldFuncName = funcName;
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
+                ValueGuard< std::string > oldFuncName( funcName );
 
                 FunctionType * type = functionDecl->get_functionType();
@@ -149 +163 @@
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
-                returnVals = oldReturnVals;
-                funcName = oldFuncName;
                 return decl;
         }
@@ -197 +209 @@
 
         DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                bool oldInFunc = inFunction;
+                ValueGuard< bool > oldInFunc( inFunction );
                 inFunction = true;
                 DeclarationWithType * decl = Parent::mutate( functionDecl );
-                inFunction = oldInFunc;
                 return decl;
         }
@@ -209 +220 @@
         }
 
+        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 +276 @@
                         }
                 }
-                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
 

src/InitTweak/InitTweak.cc

@@ -232 +232 @@
                 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 +390 @@
                 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 );

src/ResolvExpr/Resolver.cc

@@ -528 +528 @@
 
         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

src/SymTab/Indexer.cc

@@ -21 +21 @@
 #include <unordered_set>
 #include <utility>
+#include <algorithm>
 
 #include "Mangler.h"
@@ -33 +34 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
+
+#include "InitTweak/InitTweak.h"
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
@@ -99 +102 @@
 
                 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 +526 @@
                         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 );
         }
 

src/SymTab/Indexer.h

@@ -128 +128 @@
                 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();

src/tests/.expect/64/declarationSpecifier.txt

@@ -530 +530 @@
     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))));
-}

src/tests/.expect/64/extension.txt

@@ -86 +86 @@
         __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);

src/tests/.expect/64/gccExtensions.txt

@@ -76 +76 @@
         ((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 +132 @@
     }
     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 +138 @@
     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 +153 @@
     }
     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 +159 @@
     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))));
 }