Changes in / [933f32f:292642a]


Ignore:
Files:
2 deleted
40 edited

Legend:

Unmodified
Added
Removed

  • libcfa/prelude/Makefile.am

    r933f32f r292642a  
    5555# create forward declarations for cfa builtins
    5656builtins.cf : builtins.c ${CC}
    57         ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
     57        ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
    5858        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    5959

  • libcfa/prelude/Makefile.in

    r933f32f r292642a  
    556556# create forward declarations for cfa builtins
    557557builtins.cf : builtins.c ${CC}
    558         ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po -D__cforall
     558        ${AM_V_GEN}gcc ${AM_CFLAGS} -E -P ${<} -o ${@} -MD -MP -MF $(DEPDIR)/builtins.Po
    559559        ${AM_V_at}sed -i 's/builtins.o/builtins.cf/g' $(DEPDIR)/builtins.Po
    560560

  • libcfa/prelude/builtins.c

    r933f32f r292642a  
    1313// Update Count     : 95
    1414//
    15 
    16 // type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions
    17 // Note: needs to occur early, because it is used to generate destructor calls during code generation
    18 forall(dtype T)
    19 struct __Destructor {
    20         T * object;
    21         void (*dtor)(T *);
    22 };
    23 
    24 // defined destructor in the case that non-generated code wants to use __Destructor
    25 forall(dtype T)
    26 static inline void ^?{}(__Destructor(T) & x) {
    27         if (x.object && x.dtor) {
    28                 x.dtor(x.object);
    29         }
    30 }
    31 
    32 // easy interface into __Destructor's destructor for easy codegen purposes
    33 extern "C" {
    34         forall(dtype T)
    35         static inline void __destroy_Destructor(__Destructor(T) * dtor) {
    36                 ^(*dtor){};
    37         }
    38 }
    3915
    4016// exception implementation

  • src/Common/PassVisitor.impl.h

    r933f32f r292642a  
    18061806        VISIT_START( node );
    18071807
    1808         indexerScopedAccept( node->result    , *this );
    1809         maybeAccept_impl   ( node->callExpr  , *this );
     1808        indexerScopedAccept( node->result     , *this );
     1809        maybeAccept_impl   ( node->callExpr   , *this );
     1810        maybeAccept_impl   ( node->tempDecls  , *this );
     1811        maybeAccept_impl   ( node->returnDecls, *this );
     1812        maybeAccept_impl   ( node->dtors      , *this );
    18101813
    18111814        VISIT_END( node );
    … …  
    18161819        MUTATE_START( node );
    18171820
    1818         indexerScopedMutate( node->env       , *this );
    1819         indexerScopedMutate( node->result    , *this );
    1820         maybeMutate_impl   ( node->callExpr  , *this );
     1821        indexerScopedMutate( node->env        , *this );
     1822        indexerScopedMutate( node->result     , *this );
     1823        maybeMutate_impl   ( node->callExpr   , *this );
     1824        maybeMutate_impl   ( node->tempDecls  , *this );
     1825        maybeMutate_impl   ( node->returnDecls, *this );
     1826        maybeMutate_impl   ( node->dtors      , *this );
    18211827
    18221828        MUTATE_END( Expression, node );

  • src/ControlStruct/ExceptTranslate.cc

    r933f32f r292642a  
    319319                        }
    320320
    321                         block->push_back( handler->body );
    322                         handler->body = nullptr;
     321                        block->push_back( handler->get_body() );
     322                        handler->set_body( nullptr );
    323323
    324324                        std::list<Statement *> caseBody

  • src/GenPoly/Box.cc

    r933f32f r292642a  
    657657                                paramExpr = new AddressExpr( paramExpr );
    658658                        } // if
    659                         arg = appExpr->args.insert( arg, paramExpr ); // add argument to function call
     659                        arg = appExpr->get_args().insert( arg, paramExpr ); // add argument to function call
    660660                        arg++;
    661661                        // Build a comma expression to call the function and emulate a normal return.
    662662                        CommaExpr *commaExpr = new CommaExpr( appExpr, retExpr );
    663                         commaExpr->env = appExpr->env;
    664                         appExpr->env = nullptr;
     663                        commaExpr->set_env( appExpr->get_env() );
     664                        appExpr->set_env( 0 );
    665665                        return commaExpr;
    666666                }
    … …  
    708708//                      if ( ! function->get_returnVals().empty() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
    709709                        if ( isDynRet( function, tyVars ) ) {
    710                                 ret = addRetParam( appExpr, function->returnVals.front()->get_type(), arg );
     710                                ret = addRetParam( appExpr, function->get_returnVals().front()->get_type(), arg );
    711711                        } // if
    712712                        std::string mangleName = mangleAdapterName( function, tyVars );
    … …  
    715715                        // cast adaptee to void (*)(), since it may have any type inside a polymorphic function
    716716                        Type * adapteeType = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
    717                         appExpr->get_args().push_front( new CastExpr( appExpr->function, adapteeType ) );
     717                        appExpr->get_args().push_front( new CastExpr( appExpr->get_function(), adapteeType ) );
    718718                        appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
    719719

  • src/GenPoly/GenPoly.cc

    r933f32f r292642a  
    459459
    460460        void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
    461                 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
     461                // xxx - should this actually be insert?
     462                tyVarMap[ tyVar->get_name() ] = TypeDecl::Data{ tyVar };
    462463        }
    463464

  • src/GenPoly/Lvalue.cc

    r933f32f r292642a  
    2121#include "Lvalue.h"
    2222
    23 #include "InitTweak/InitTweak.h"
    2423#include "Parser/LinkageSpec.h"          // for Spec, isBuiltin, Intrinsic
    2524#include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
    2625#include "ResolvExpr/Unify.h"            // for unify
    2726#include "ResolvExpr/typeops.h"
     27#include "SymTab/Autogen.h"
    2828#include "SymTab/Indexer.h"              // for Indexer
    2929#include "SynTree/Declaration.h"         // for Declaration, FunctionDecl
    … …  
    3333#include "SynTree/Type.h"                // for PointerType, Type, FunctionType
    3434#include "SynTree/Visitor.h"             // for Visitor, acceptAll
    35 #include "Validate/FindSpecialDecls.h"   // for dereferenceOperator
    3635
    3736#if 0
    … …  
    4544                // TODO: fold this into the general createDeref function??
    4645                Expression * mkDeref( Expression * arg ) {
    47                         if ( Validate::dereferenceOperator ) {
     46                        if ( SymTab::dereferenceOperator ) {
    4847                                // note: reference depth can be arbitrarily deep here, so peel off the outermost pointer/reference, not just pointer because they are effecitvely equivalent in this pass
    49                                 VariableExpr * deref = new VariableExpr( Validate::dereferenceOperator );
     48                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
    5049                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
    5150                                Type * base = InitTweak::getPointerBase( arg->result );
    … …  
    354353                        Type * destType = castExpr->result;
    355354                        Type * srcType = castExpr->arg->result;
    356                         assertf( destType, "Cast to no type in: %s", toCString( castExpr ) );
    357                         assertf( srcType, "Cast from no type in: %s", toCString( castExpr ) );
    358355                        int depth1 = destType->referenceDepth();
    359356                        int depth2 = srcType->referenceDepth();

  • src/GenPoly/ScopedSet.h

    r933f32f r292642a  
    3838                typedef typename Scope::pointer pointer;
    3939                typedef typename Scope::const_pointer const_pointer;
    40 
     40               
    4141                class iterator : public std::iterator< std::bidirectional_iterator_tag,
    4242                                                       value_type > {
    … …  
    7272                                return *this;
    7373                        }
    74 
     74                       
    7575                        reference operator* () { return *it; }
    7676                        pointer operator-> () { return it.operator->(); }
    … …  
    104104                        bool operator!= (const iterator &that) { return !( *this == that ); }
    105105
    106                         size_type get_level() const { return i; }
    107 
    108106                private:
    109107                        scope_list const *scopes;
    … …  
    182180                        bool operator!= (const const_iterator &that) { return !( *this == that ); }
    183181
    184                         size_type get_level() const { return i; }
    185 
    186182                private:
    187183                        scope_list const *scopes;
    … …  
    189185                        size_type i;
    190186                };
    191 
     187               
    192188                /// Starts a new scope
    193189                void beginScope() {
    … …  
    226222                        return const_iterator( const_cast< ScopedSet< Value >* >(this)->find( key ) );
    227223                }
    228 
     224               
    229225                /// Finds the given key in the outermost scope inside the given scope where it occurs
    230226                iterator findNext( const_iterator &it, const Value &key ) {
    … …  
    246242                        return std::make_pair( iterator(scopes, res.first, scopes.size()-1), res.second );
    247243                }
    248 
     244               
    249245        };
    250246} // namespace GenPoly

  • src/InitTweak/FixInit.cc

    r933f32f r292642a  
    5454#include "SynTree/Type.h"              // for Type, Type::StorageClasses
    5555#include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
    56 #include "SynTree/DeclReplacer.h"      // for DeclReplacer
    5756#include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
    58 #include "Validate/FindSpecialDecls.h" // for dtorStmt, dtorStructDestroy
    5957
    6058bool ctordtorp = false; // print all debug
    … …  
    6866namespace InitTweak {
    6967        namespace {
     68                typedef std::unordered_map< int, int > UnqCount;
     69
    7070                struct SelfAssignChecker {
    7171                        void previsit( ApplicationExpr * appExpr );
    … …  
    8080                };
    8181
    82                 struct ResolveCopyCtors final : public WithStmtsToAdd, public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution, public WithVisitorRef<ResolveCopyCtors> {
     82                struct ResolveCopyCtors final : public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution {
    8383                        /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
    8484                        /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
    8585                        /// arguments and return value temporaries
    86                         static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
    87 
    88                         Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
    89                         void premutate( StmtExpr * stmtExpr );
    90                         void premutate( UniqueExpr * unqExpr );
     86                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount );
     87
     88                        ResolveCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ) {}
     89
     90                        void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr );
     91                        void postvisit( StmtExpr * stmtExpr );
     92                        void previsit( UniqueExpr * unqExpr );
     93                        void postvisit( UniqueExpr * unqExpr );
    9194
    9295                        /// create and resolve ctor/dtor expression: fname(var, [cpArg])
    … …  
    9598                        bool skipCopyConstruct( Type * type );
    9699                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal );
    97                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr, Expression *& arg );
     100                        void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
     101
     102                        UnqCount & unqCount; // count the number of times each unique expr ID appears
     103                        std::unordered_set< int > vars;
    98104                };
    99105
    … …  
    156162                        using Parent::previsit;
    157163
     164                        void previsit( ObjectDecl * objDecl );
    158165                        void previsit( FunctionDecl * funcDecl );
    159166
     167                        void previsit( CompoundStmt * compoundStmt );
     168                        void postvisit( CompoundStmt * compoundStmt );
     169                        void previsit( ReturnStmt * returnStmt );
    160170                        void previsit( BranchStmt * stmt );
    161171                private:
    … …  
    175185
    176186                        std::list< Declaration * > staticDtorDecls;
     187                };
     188
     189                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors>, public WithConstTypeSubstitution {
     190                  public:
     191                        FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
     192                        /// expand ImplicitCopyCtorExpr nodes into the temporary declarations, copy constructors, call expression,
     193                        /// and destructors
     194                        static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
     195
     196                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
     197                        void premutate( StmtExpr * stmtExpr );
     198                        void premutate( UniqueExpr * unqExpr );
     199
     200                        UnqCount & unqCount;
    177201                };
    178202
    … …  
    212236                        Expression * postmutate( ConstructorExpr * ctorExpr );
    213237                };
    214 
    215                 struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
    216                         /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
    217                         static void split( std::list< Declaration * > &translationUnit );
    218 
    219                         Statement * postmutate( ExprStmt * stmt );
    220                         void premutate( TupleAssignExpr * expr );
    221                 };
    222238        } // namespace
    223239
    … …  
    229245                InitTweak::fixGlobalInit( translationUnit, inLibrary );
    230246
    231                 // must happen before ResolveCopyCtors because temporaries have to be inserted into the correct scope
    232                 SplitExpressions::split( translationUnit );
     247                UnqCount unqCount;
    233248
    234249                InsertImplicitCalls::insert( translationUnit );
    235 
    236                 // Needs to happen before ResolveCopyCtors, because argument/return temporaries should not be considered in
    237                 // error checking branch statements
     250                ResolveCopyCtors::resolveImplicitCalls( translationUnit, unqCount );
    238251                InsertDtors::insert( translationUnit );
    239 
    240                 ResolveCopyCtors::resolveImplicitCalls( translationUnit );
    241252                FixInit::fixInitializers( translationUnit );
     253
     254                // FixCopyCtors must happen after FixInit, so that destructors are placed correctly
     255                FixCopyCtors::fixCopyCtors( translationUnit, unqCount );
     256
    242257                GenStructMemberCalls::generate( translationUnit );
    243258
    244                 // Needs to happen after GenStructMemberCalls, since otherwise member constructors exprs
    245                 // don't have the correct form, and a member can be constructed more than once.
     259                // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a
     260                // hack in the way untyped assignments are generated, where the first argument cannot have
     261                // its address taken because of the way codegeneration handles UntypedExpr vs. ApplicationExpr.
     262                // Thus such assignment exprs must never pushed through expression resolution (and thus should
     263                // not go through the FixCopyCtors pass), otherwise they will fail -- guaranteed.
     264                // Also needs to happen after GenStructMemberCalls, since otherwise member constructors exprs
     265                // don't look right, and a member can be constructed more than once.
    246266                FixCtorExprs::fix( translationUnit );
    247267        }
    248268
    249269        namespace {
    250                 /// find and return the destructor used in `input`. If `input` is not a simple destructor call, generate a thunk
    251                 /// that wraps the destructor, insert it into `stmtsToAdd` and return the new function declaration
    252                 DeclarationWithType * getDtorFunc( ObjectDecl * objDecl, Statement * input, std::list< Statement * > & stmtsToAdd ) {
    253                         // unwrap implicit statement wrapper
    254                         Statement * dtor = input;
    255                         if ( ImplicitCtorDtorStmt * implicit = dynamic_cast< ImplicitCtorDtorStmt * >( input ) ) {
    256                                 // dtor = implicit->callStmt;
    257                                 // implicit->callStmt = nullptr;
    258                         }
    259                         assert( dtor );
    260                         std::list< Expression * > matches;
    261                         collectCtorDtorCalls( dtor, matches );
    262 
    263                         if ( dynamic_cast< ExprStmt * >( dtor ) ) {
    264                                 // only one destructor call in the expression
    265                                 if ( matches.size() == 1 ) {
    266                                         DeclarationWithType * func = getFunction( matches.front() );
    267                                         assertf( func, "getFunction failed to find function in %s", toString( matches.front() ).c_str() );
    268 
    269                                         // cleanup argument must be a function, not an object (including function pointer)
    270                                         if ( FunctionDecl * dtorFunc = dynamic_cast< FunctionDecl * > ( func ) ) {
    271                                                 if ( dtorFunc->type->forall.empty() ) {
    272                                                         // simple case where the destructor is a monomorphic function call - can simply
    273                                                         // use that function as the cleanup function.
    274                                                         delete dtor;
    275                                                         return func;
    276                                                 }
    277                                         }
    278                                 }
    279                         }
    280 
    281                         // otherwise the cleanup is more complicated - need to build a single argument cleanup function that
    282                         // wraps the more complicated code.
    283                         static UniqueName dtorNamer( "__cleanup_dtor" );
    284                         FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type->stripReferences(), false ), new CompoundStmt() );
    285                         stmtsToAdd.push_back( new DeclStmt( dtorFunc ) );
    286 
    287                         // the original code contains uses of objDecl - replace them with the newly generated 'this' parameter.
    288                         ObjectDecl * thisParam = getParamThis( dtorFunc->type );
    289                         Expression * replacement = new VariableExpr( thisParam );
    290 
    291                         Type * base = replacement->result->stripReferences();
    292                         if ( dynamic_cast< ArrayType * >( base ) || dynamic_cast< TupleType * > ( base ) ) {
    293                                 // need to cast away reference for array types, since the destructor is generated without the reference type,
    294                                 // and for tuple types since tuple indexing does not work directly on a reference
    295                                 replacement = new CastExpr( replacement, base->clone() );
    296                         }
    297                         DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } );
    298                         dtorFunc->statements->push_back( strict_dynamic_cast<Statement *>( dtor ) );
    299 
    300                         return dtorFunc;
    301                 }
    302 
    303                 void SplitExpressions::split( std::list< Declaration * > & translationUnit ) {
    304                         PassVisitor<SplitExpressions> splitter;
    305                         mutateAll( translationUnit, splitter );
    306                 }
    307 
    308270                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
    309271                        PassVisitor<InsertImplicitCalls> inserter;
    … …  
    311273                }
    312274
    313                 void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) {
    314                         PassVisitor<ResolveCopyCtors> resolver;
    315                         mutateAll( translationUnit, resolver );
     275                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
     276                        PassVisitor<ResolveCopyCtors> resolver( unqCount );
     277                        acceptAll( translationUnit, resolver );
    316278                }
    317279
    … …  
    341303                }
    342304
     305                void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
     306                        PassVisitor<FixCopyCtors> fixer( unqCount );
     307                        mutateAll( translationUnit, fixer );
     308                }
     309
    343310                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
    344311                        PassVisitor<GenStructMemberCalls> warner;
    … …  
    351318                }
    352319
    353                 Statement * SplitExpressions::postmutate( ExprStmt * stmt ) {
    354                         // wrap each top-level ExprStmt in a block so that destructors for argument and return temporaries are destroyed
    355                         // in the correct places
    356                         CompoundStmt * ret = new CompoundStmt( { stmt } );
    357                         return ret;
    358                 }
    359 
    360                 void SplitExpressions::premutate( TupleAssignExpr * ) {
    361                         // don't do this within TupleAssignExpr, since it is already broken up into multiple expressions
    362                         visit_children = false;
    363                 }
    364 
    365                 // Relatively simple structural comparison for expressions, needed to determine
    366                 // if two expressions are "the same" (used to determine if self assignment occurs)
    367                 struct StructuralChecker {
    368                         Expression * stripCasts( Expression * expr ) {
    369                                 // this might be too permissive. It's possible that only particular casts are relevant.
    370                                 while ( CastExpr * cast = dynamic_cast< CastExpr * >( expr ) ) {
    371                                         expr = cast->arg;
    372                                 }
    373                                 return expr;
    374                         }
    375 
    376                         void previsit( Expression * ) {
    377                                 // anything else does not qualify
    378                                 isSimilar = false;
    379                         }
    380 
    381                         template<typename T>
    382                         T * cast( Expression * node ) {
    383                                 // all expressions need to ignore casts, so this bit has been factored out
    384                                 return dynamic_cast< T * >( stripCasts( node ) );
    385                         }
    386 
    387                         // ignore casts
    388                         void previsit( CastExpr * ) {}
    389 
    390                         void previsit( MemberExpr * memExpr ) {
    391                                 if ( MemberExpr * otherMember = cast< MemberExpr >( other ) ) {
    392                                         if ( otherMember->member == memExpr->member ) {
    393                                                 other = otherMember->aggregate;
     320                namespace {
     321                        // Relatively simple structural comparison for expressions, needed to determine
     322                        // if two expressions are "the same" (used to determine if self assignment occurs)
     323                        struct StructuralChecker {
     324                                Expression * stripCasts( Expression * expr ) {
     325                                        // this might be too permissive. It's possible that only particular casts are relevant.
     326                                        while ( CastExpr * cast = dynamic_cast< CastExpr * >( expr ) ) {
     327                                                expr = cast->arg;
     328                                        }
     329                                        return expr;
     330                                }
     331
     332                                void previsit( Expression * ) {
     333                                        // anything else does not qualify
     334                                        isSimilar = false;
     335                                }
     336
     337                                template<typename T>
     338                                T * cast( Expression * node ) {
     339                                        // all expressions need to ignore casts, so this bit has been factored out
     340                                        return dynamic_cast< T * >( stripCasts( node ) );
     341                                }
     342
     343                                // ignore casts
     344                                void previsit( CastExpr * ) {}
     345
     346                                void previsit( MemberExpr * memExpr ) {
     347                                        if ( MemberExpr * otherMember = cast< MemberExpr >( other ) ) {
     348                                                if ( otherMember->member == memExpr->member ) {
     349                                                        other = otherMember->aggregate;
     350                                                        return;
     351                                                }
     352                                        }
     353                                        isSimilar = false;
     354                                }
     355
     356                                void previsit( VariableExpr * varExpr ) {
     357                                        if ( VariableExpr * otherVar = cast< VariableExpr >( other ) ) {
     358                                                if ( otherVar->var == varExpr->var ) {
     359                                                        return;
     360                                                }
     361                                        }
     362                                        isSimilar = false;
     363                                }
     364
     365                                void previsit( AddressExpr * ) {
     366                                        if ( AddressExpr * addrExpr = cast< AddressExpr >( other ) ) {
     367                                                other = addrExpr->arg;
    394368                                                return;
    395369                                        }
    396                                 }
    397                                 isSimilar = false;
    398                         }
    399 
    400                         void previsit( VariableExpr * varExpr ) {
    401                                 if ( VariableExpr * otherVar = cast< VariableExpr >( other ) ) {
    402                                         if ( otherVar->var == varExpr->var ) {
    403                                                 return;
    404                                         }
    405                                 }
    406                                 isSimilar = false;
    407                         }
    408 
    409                         void previsit( AddressExpr * ) {
    410                                 if ( AddressExpr * addrExpr = cast< AddressExpr >( other ) ) {
    411                                         other = addrExpr->arg;
    412                                         return;
    413                                 }
    414                                 isSimilar = false;
    415                         }
    416 
    417                         Expression * other = nullptr;
    418                         bool isSimilar = true;
    419                 };
    420 
    421                 bool structurallySimilar( Expression * e1, Expression * e2 ) {
    422                         PassVisitor<StructuralChecker> checker;
    423                         checker.pass.other = e2;
    424                         e1->accept( checker );
    425                         return checker.pass.isSimilar;
     370                                        isSimilar = false;
     371                                }
     372
     373                                Expression * other = nullptr;
     374                                bool isSimilar = true;
     375                        };
     376
     377                        bool structurallySimilar( Expression * e1, Expression * e2 ) {
     378                                PassVisitor<StructuralChecker> checker;
     379                                checker.pass.other = e2;
     380                                e1->accept( checker );
     381                                return checker.pass.isSimilar;
     382                        }
    426383                }
    427384
    … …  
    500457                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
    501458                                // fix newly generated StmtExpr
    502                                 premutate( assign->stmtExpr );
     459                                postvisit( assign->stmtExpr );
    503460                        }
    504461                        return resolved;
    … …  
    532489                                        // so that the object isn't changed inside of the polymorphic function
    533490                                        if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
    534                                         // xxx - leaking tmp
    535491                                }
    536492                        }
    … …  
    540496
    541497                        // replace argument to function call with temporary
    542                         stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
    543                         arg = cpCtor;
    544                         destructRet( tmp, impCpCtorExpr, arg );
    545 
    546                         // impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
    547                 }
    548 
    549                 void ResolveCopyCtors::destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * /*impCpCtorExpr*/, Expression *& arg ) {
    550                         // TODO: refactor code for generating cleanup attribute, since it's common and reused in ~3-4 places
    551                         // check for existing cleanup attribute before adding another(?)
    552                         // need to add __Destructor for _tmp_cp variables as well
    553 
    554                         assertf( Validate::dtorStruct && Validate::dtorStruct->members.size() == 2, "Destructor generation requires __Destructor definition." );
    555                         assertf( Validate::dtorStructDestroy, "Destructor generation requires __destroy_Destructor." );
    556 
    557                         // generate a __Destructor for ret that calls the destructor
    558                         Expression * dtor = makeCtorDtor( "^?{}", ret );
    559 
    560                         // if the chosen destructor is intrinsic, elide the generated dtor handler
    561                         if ( arg && isIntrinsicCallExpr( dtor ) ) {
    562                                 arg = new CommaExpr( arg, new VariableExpr( ret ) );
    563                                 return;
    564                         }
    565 
    566                         if ( ! dtor->env ) dtor->env = maybeClone( env );
    567                         DeclarationWithType * dtorFunc = getDtorFunc( ret, new ExprStmt( dtor ), stmtsToAddBefore );
    568 
    569                         StructInstType * dtorStructType = new StructInstType( Type::Qualifiers(), Validate::dtorStruct );
    570                         dtorStructType->parameters.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
    571 
    572                         // cast destructor pointer to void (*)(void *), to silence GCC incompatible pointer warnings
    573                         FunctionType * dtorFtype = new FunctionType( Type::Qualifiers(), false );
    574                         dtorFtype->parameters.push_back( ObjectDecl::newObject( "", new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), nullptr ) );
    575                         Type * dtorType = new PointerType( Type::Qualifiers(), dtorFtype );
    576 
    577                         static UniqueName namer( "_ret_dtor" );
    578                         ObjectDecl * retDtor = ObjectDecl::newObject( namer.newName(), dtorStructType, new ListInit( { new SingleInit( new ConstantExpr( Constant::null() ) ), new SingleInit( new CastExpr( new VariableExpr( dtorFunc ), dtorType ) ) } ) );
    579                         retDtor->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( Validate::dtorStructDestroy ) } ) );
    580                         stmtsToAddBefore.push_back( new DeclStmt( retDtor ) );
    581 
    582                         if ( arg ) {
    583                                 Expression * member = new MemberExpr( strict_dynamic_cast<DeclarationWithType *>( Validate::dtorStruct->members.front() ), new VariableExpr( retDtor ) );
    584                                 Expression * object = new CastExpr( new AddressExpr( new VariableExpr( ret ) ), new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ) );
    585                                 Expression * assign = createBitwiseAssignment( member, object );
    586                                 arg = new CommaExpr( new CommaExpr( arg, assign ), new VariableExpr( ret ) );
    587                         }
    588 
    589                         // impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
    590                 }
    591 
    592                 Expression * ResolveCopyCtors::postmutate( ImplicitCopyCtorExpr *impCpCtorExpr ) {
     498                        arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
     499                        impCpCtorExpr->tempDecls.push_back( tmp );
     500                        impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
     501                }
     502
     503                void ResolveCopyCtors::destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
     504                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
     505                }
     506
     507                void ResolveCopyCtors::postvisit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
    593508                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
    594509
    595510                        ApplicationExpr * appExpr = impCpCtorExpr->callExpr;
    596                         ObjectDecl * returnDecl = nullptr;
    597511
    598512                        // take each argument and attempt to copy construct it.
    … …  
    603517                        for ( Expression * & arg : appExpr->args ) {
    604518                                Type * formal = nullptr;
    605                                 if ( iter != params.end() ) { // does not copy construct C-style variadic arguments
     519                                if ( iter != params.end() ) {
    606520                                        DeclarationWithType * param = *iter++;
    607521                                        formal = param->get_type();
    … …  
    621535                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
    622536                                ret->type->set_const( false );
    623                                 returnDecl = ret;
    624                                 stmtsToAddBefore.push_back( new DeclStmt( ret ) );
     537                                impCpCtorExpr->returnDecls.push_back( ret );
    625538                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
     539                                if ( ! dynamic_cast< ReferenceType * >( result ) ) {
     540                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
     541                                        destructRet( ret, impCpCtorExpr );
     542                                }
    626543                        } // for
    627544                        CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
    628                         // ------------------------------------------------------
    629 
    630                         CP_CTOR_PRINT( std::cerr << "Coming out the back..." << impCpCtorExpr << std::endl; )
    631 
    632                         // detach fields from wrapper node so that it can be deleted without deleting too much
    633                         impCpCtorExpr->callExpr = nullptr;
    634                         std::swap( impCpCtorExpr->env, appExpr->env );
    635                         assert( impCpCtorExpr->env == nullptr );
    636                         delete impCpCtorExpr;
    637 
    638                         if ( returnDecl ) {
    639                                 Expression * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), appExpr );
    640                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
    641                                         // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
    642                                         destructRet( returnDecl, impCpCtorExpr, assign );
    643                                 } else {
    644                                         assign = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    645                                 }
    646                                 // move env from appExpr to retExpr
    647                                 std::swap( assign->env, appExpr->env );
    648                                 return assign;
    649                         } else {
    650                                 return appExpr;
    651                         } // if
    652                 }
    653 
    654                 void ResolveCopyCtors::premutate( StmtExpr * stmtExpr ) {
    655                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
    656                         // since temporaries can be shared across sub-expressions, e.g.
    657                         //   [A, A] f();
    658                         //   g([A] x, [A] y);
    659                         //   g(f());
    660                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
    661                         // Explicitly mutating children instead of mutating the inner compound statement forces the temporaries to be added
    662                         // to the outer context, rather than inside of the statement expression.
    663                         visit_children = false;
    664 
     545                }
     546
     547                void ResolveCopyCtors::postvisit( StmtExpr * stmtExpr ) {
    665548                        assert( env );
    666 
    667                         // visit all statements
    668                         std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
    669                         for ( Statement *& stmt : stmts ) {
    670                                 stmt = stmt->acceptMutator( *visitor );
    671                         } // for
    672 
    673                         assert( stmtExpr->result );
    674                         Type * result = stmtExpr->result;
     549                        assert( stmtExpr->get_result() );
     550                        Type * result = stmtExpr->get_result();
    675551                        if ( ! result->isVoid() ) {
    676552                                static UniqueName retNamer("_tmp_stmtexpr_ret");
    … …  
    686562                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
    687563                                ret->type->set_const( false );
    688                                 stmtsToAddBefore.push_back( new DeclStmt( ret ) );
     564                                stmtExpr->returnDecls.push_front( ret );
    689565
    690566                                // must have a non-empty body, otherwise it wouldn't have a result
    691567                                CompoundStmt * body = stmtExpr->statements;
    692                                 assert( ! body->kids.empty() );
     568                                assert( ! body->get_kids().empty() );
    693569                                // must be an ExprStmt, otherwise it wouldn't have a result
    694                                 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->kids.back() );
    695                                 last->expr = makeCtorDtor( "?{}", ret, last->expr );
    696 
    697                                 // add destructors after current statement
    698                                 stmtsToAddAfter.push_back( new ExprStmt( makeCtorDtor( "^?{}", ret ) ) );
    699 
    700                                 // must have a non-empty body, otherwise it wouldn't have a result
    701                                 assert( ! stmts.empty() );
    702 
    703                                 // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
    704                                 stmts.push_back( new ExprStmt( new VariableExpr( ret ) ) );
     570                                ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
     571                                last->expr = makeCtorDtor( "?{}", ret, last->get_expr() );
     572
     573                                stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) );
    705574                        } // if
    706 
    707                         assert( stmtExpr->returnDecls.empty() );
    708                         assert( stmtExpr->dtors.empty() );
     575                }
     576
     577                void ResolveCopyCtors::previsit( UniqueExpr * unqExpr ) {
     578                        unqCount[ unqExpr->get_id() ]++;  // count the number of unique expressions for each ID
     579                        if ( vars.count( unqExpr->get_id() ) ) {
     580                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
     581                                visit_children = false;
     582                        }
    709583                }
    710584
    … …  
    723597                }
    724598
    725                 void ResolveCopyCtors::premutate( UniqueExpr * unqExpr ) {
     599                void ResolveCopyCtors::postvisit( UniqueExpr * unqExpr ) {
     600                        if ( vars.count( unqExpr->get_id() ) ) {
     601                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
     602                                return;
     603                        }
     604
     605                        // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
     606                        assert( unqExpr->get_result() );
     607                        if ( ImplicitCopyCtorExpr * impCpCtorExpr = dynamic_cast<ImplicitCopyCtorExpr*>( unqExpr->get_expr() ) ) {
     608                                // note the variable used as the result from the call
     609                                assert( impCpCtorExpr->get_result() && impCpCtorExpr->get_returnDecls().size() == 1 );
     610                                unqExpr->set_var( new VariableExpr( impCpCtorExpr->get_returnDecls().front() ) );
     611                        } else {
     612                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
     613                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), makeInit( unqExpr->get_result() ) ) );
     614                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
     615                        }
     616                        vars.insert( unqExpr->get_id() );
     617                }
     618
     619                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
     620                        CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
     621
     622                        std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
     623                        std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
     624                        std::list< Expression * > & dtors = impCpCtorExpr->get_dtors();
     625
     626                        // add all temporary declarations and their constructors
     627                        for ( ObjectDecl * obj : tempDecls ) {
     628                                stmtsToAddBefore.push_back( new DeclStmt( obj ) );
     629                        } // for
     630                        for ( ObjectDecl * obj : returnDecls ) {
     631                                stmtsToAddBefore.push_back( new DeclStmt( obj ) );
     632                        } // for
     633
     634                        // add destructors after current statement
     635                        for ( Expression * dtor : dtors ) {
     636                                // take relevant bindings from environment
     637                                assert( ! dtor->env );
     638                                dtor->env =  maybeClone( env );
     639                                stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
     640                        } // for
     641
     642                        ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
     643                        Expression * callExpr = impCpCtorExpr->get_callExpr();
     644
     645                        CP_CTOR_PRINT( std::cerr << "Coming out the back..." << impCpCtorExpr << std::endl; )
     646
     647                        // detach fields from wrapper node so that it can be deleted without deleting too much
     648                        dtors.clear();
     649                        tempDecls.clear();
     650                        returnDecls.clear();
     651                        impCpCtorExpr->set_callExpr( nullptr );
     652                        std::swap( impCpCtorExpr->env, callExpr->env );
     653                        assert( impCpCtorExpr->env == nullptr );
     654                        delete impCpCtorExpr;
     655
     656                        if ( returnDecl ) {
     657                                ApplicationExpr * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), callExpr );
     658                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
     659                                // move env from callExpr to retExpr
     660                                std::swap( retExpr->env, callExpr->env );
     661                                return retExpr;
     662                        } else {
     663                                return callExpr;
     664                        } // if
     665                }
     666
     667                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
     668                        // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
     669                        // since temporaries can be shared across sub-expressions, e.g.
     670                        //   [A, A] f();
     671                        //   g([A] x, [A] y);
     672                        //   g(f());
     673                        // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
     674                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
     675                        // to the outer context, rather than inside of the statement expression.
    726676                        visit_children = false;
    727                         // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
     677                        std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
     678                        for ( Statement *& stmt : stmts ) {
     679                                stmt = stmt->acceptMutator( *visitor );
     680                        } // for
     681                        assert( stmtExpr->result );
     682                        Type * result = stmtExpr->result;
     683                        if ( ! result->isVoid() ) {
     684                                for ( ObjectDecl * obj : stmtExpr->returnDecls ) {
     685                                        stmtsToAddBefore.push_back( new DeclStmt( obj ) );
     686                                } // for
     687                                // add destructors after current statement
     688                                for ( Expression * dtor : stmtExpr->dtors ) {
     689                                        stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
     690                                } // for
     691                                // must have a non-empty body, otherwise it wouldn't have a result
     692                                assert( ! stmts.empty() );
     693                                assertf( ! stmtExpr->returnDecls.empty() || stmtExpr->dtors.empty(), "StmtExpr returns non-void, but no return decls: %s", toString( stmtExpr ).c_str() );
     694                                // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
     695                                if ( ! stmtExpr->returnDecls.empty() ) {
     696                                        stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->returnDecls.front() ) ) );
     697                                }
     698                                stmtExpr->returnDecls.clear();
     699                                stmtExpr->dtors.clear();
     700                        }
     701                        assert( stmtExpr->returnDecls.empty() );
     702                        assert( stmtExpr->dtors.empty() );
     703                }
     704
     705                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
     706                        visit_children = false;
     707                        unqCount[ unqExpr->get_id() ]--;
     708                        static std::unordered_map< int, std::list< Statement * > > dtors;
    728709                        static std::unordered_map< int, UniqueExpr * > unqMap;
    729                         if ( ! unqMap.count( unqExpr->get_id() ) ) {
    730                                 // resolve expr and find its
    731 
    732                                 ImplicitCopyCtorExpr * impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( unqExpr->expr );
    733                                 // PassVisitor<ResolveCopyCtors> fixer;
    734                                 unqExpr->expr = unqExpr->expr->acceptMutator( *visitor );
    735 
    736                                 // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
    737                                 assert( unqExpr->result );
    738                                 if ( impCpCtorExpr ) {
    739                                         CommaExpr * comma = strict_dynamic_cast< CommaExpr * >( unqExpr->expr );
    740                                         VariableExpr * var = strict_dynamic_cast<VariableExpr *>( comma->arg2 );
    741                                         // note the variable used as the result from the call
    742                                         unqExpr->var = var->clone();
    743                                 } else {
    744                                         // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
    745                                         unqExpr->object = ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->result->clone(), makeInit( unqExpr->result ) );
    746                                         unqExpr->var = new VariableExpr( unqExpr->object );
    747                                 }
    748 
    749                                 // stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
    750                                 // stmtsToAddAfter.splice( stmtsToAddAfter.end(), fixer.pass.stmtsToAddAfter );
    751                                 unqMap[unqExpr->get_id()] = unqExpr;
    752                         } else {
     710                        // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
     711                        if ( unqMap.count( unqExpr->get_id() ) ) {
    753712                                // take data from other UniqueExpr to ensure consistency
    754713                                delete unqExpr->get_expr();
    755                                 unqExpr->expr = unqMap[unqExpr->get_id()]->expr->clone();
    756                                 delete unqExpr->result;
    757                                 unqExpr->result = maybeClone( unqExpr->expr->result );
    758                         }
     714                                unqExpr->set_expr( unqMap[unqExpr->get_id()]->get_expr()->clone() );
     715                                delete unqExpr->get_result();
     716                                unqExpr->set_result( maybeClone( unqExpr->get_expr()->get_result() ) );
     717                                if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
     718                                        stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
     719                                }
     720                                return;
     721                        }
     722                        PassVisitor<FixCopyCtors> fixer( unqCount );
     723                        unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
     724                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
     725                        unqMap[unqExpr->get_id()] = unqExpr;
     726                        if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
     727                                stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
     728                        } else { // remember dtors for last instance of unique expr
     729                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
     730                        }
     731                        return;
    759732                }
    760733
    … …  
    871844                                                        ctorInit->ctor = nullptr;
    872845                                                }
    873 
    874                                                 Statement * dtor = ctorInit->dtor;
    875                                                 if ( dtor ) {
    876                                                         ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * >( dtor );
    877                                                         Statement * dtorStmt = implicit->callStmt;
    878 
    879                                                         // don't need to call intrinsic dtor, because it does nothing, but
    880                                                         // non-intrinsic dtors must be called
    881                                                         if ( ! isIntrinsicSingleArgCallStmt( dtorStmt ) ) {
    882                                                                 // set dtor location to the object's location for error messages
    883                                                                 DeclarationWithType * dtorFunc = getDtorFunc( objDecl, dtorStmt, stmtsToAddBefore );
    884                                                                 objDecl->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( dtorFunc ) } ) );
    885                                                                 ctorInit->dtor = nullptr;
    886                                                         } // if
    887                                                 }
    888846                                        } // if
    889847                                } else if ( Initializer * init = ctorInit->init ) {
    … …  
    928886
    929887
     888                template<typename Iterator, typename OutputIterator>
     889                void insertDtors( Iterator begin, Iterator end, OutputIterator out ) {
     890                        for ( Iterator it = begin ; it != end ; ++it ) {
     891                                // extract destructor statement from the object decl and insert it into the output. Note that this is
     892                                // only called on lists of non-static objects with implicit non-intrinsic dtors, so if the user manually
     893                                // calls an intrinsic dtor then the call must (and will) still be generated since the argument may
     894                                // contain side effects.
     895                                ObjectDecl * objDecl = *it;
     896                                ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() );
     897                                assert( ctorInit && ctorInit->get_dtor() );
     898                                *out++ = ctorInit->get_dtor()->clone();
     899                        } // for
     900                }
     901
     902                void InsertDtors::previsit( ObjectDecl * objDecl ) {
     903                        // remember non-static destructed objects so that their destructors can be inserted later
     904                        if ( ! objDecl->get_storageClasses().is_static ) {
     905                                if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
     906                                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
     907                                        assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
     908                                        Statement * dtor = ctorInit->get_dtor();
     909                                        // don't need to call intrinsic dtor, because it does nothing, but
     910                                        // non-intrinsic dtors must be called
     911                                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
     912                                                // set dtor location to the object's location for error messages
     913                                                ctorInit->dtor->location = objDecl->location;
     914                                                reverseDeclOrder.front().push_front( objDecl );
     915                                        } // if
     916                                } // if
     917                        } // if
     918                }
     919
    930920                void InsertDtors::previsit( FunctionDecl * funcDecl ) {
    931921                        // each function needs to have its own set of labels
    … …  
    940930                }
    941931
     932                void InsertDtors::previsit( CompoundStmt * compoundStmt ) {
     933                        // visit statements - this will also populate reverseDeclOrder list.  don't want to dump all destructors
     934                        // when block is left, just the destructors associated with variables defined in this block, so push a new
     935                        // list to the top of the stack so that we can differentiate scopes
     936                        reverseDeclOrder.push_front( OrderedDecls() );
     937                        Parent::previsit( compoundStmt );
     938                }
     939
     940                void InsertDtors::postvisit( CompoundStmt * compoundStmt ) {
     941                        // add destructors for the current scope that we're exiting, unless the last statement is a return, which
     942                        // causes unreachable code warnings
     943                        std::list< Statement * > & statements = compoundStmt->get_kids();
     944                        if ( ! statements.empty() && ! dynamic_cast< ReturnStmt * >( statements.back() ) ) {
     945                                insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
     946                        }
     947                        reverseDeclOrder.pop_front();
     948                }
     949
     950                void InsertDtors::previsit( ReturnStmt * ) {
     951                        // return exits all scopes, so dump destructors for all scopes
     952                        for ( OrderedDecls & od : reverseDeclOrder ) {
     953                                insertDtors( od.begin(), od.end(), back_inserter( stmtsToAddBefore ) );
     954                        } // for
     955                }
     956
    942957                // Handle break/continue/goto in the same manner as C++.  Basic idea: any objects that are in scope at the
    943958                // BranchStmt but not at the labelled (target) statement must be destructed.  If there are any objects in scope
    … …  
    967982                        if ( ! diff.empty() ) {
    968983                                SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " );
     984                        } // if
     985                        // S_G-S_L results in set of objects that must be destructed
     986                        diff.clear();
     987                        std::set_difference( curVars.begin(), curVars.end(), lvars.begin(), lvars.end(), std::inserter( diff, diff.end() ) );
     988                        DTOR_PRINT(
     989                                std::cerr << "S_G-S_L = " << printSet( diff ) << std::endl;
     990                        )
     991                        if ( ! diff.empty() ) {
     992                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
     993                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
     994
     995                                // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
     996                                OrderedDecls ordered;
     997                                for ( OrderedDecls & rdo : reverseDeclOrder ) {
     998                                        // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
     999                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
     1000                                } // for
     1001                                insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAddBefore ) );
    9691002                        } // if
    9701003                }
    … …  
    10831116                                                        callStmt->acceptMutator( *visitor );
    10841117                                                        if ( isCtor ) {
    1085                                                                 function->statements->push_front( callStmt );
    1086                                                         } else { // TODO: don't generate destructor function/object for intrinsic calls
     1118                                                                function->get_statements()->push_front( callStmt );
     1119                                                        } else {
    10871120                                                                // destructor statements should be added at the end
    1088                                                                 // function->get_statements()->push_back( callStmt );
    1089 
    1090                                                                 // Optimization: do not need to call intrinsic destructors on members
    1091                                                                 if ( isIntrinsicSingleArgCallStmt( callStmt ) ) continue;;
    1092 
    1093                                                                 // __Destructor _dtor0 = { (void *)&b.a1, (void (*)(void *)_destroy_A };
    1094                                                                 std::list< Statement * > stmtsToAdd;
    1095 
    1096                                                                 static UniqueName memberDtorNamer = { "__memberDtor" };
    1097                                                                 assertf( Validate::dtorStruct, "builtin __Destructor not found." );
    1098                                                                 assertf( Validate::dtorStructDestroy, "builtin __destroy_Destructor not found." );
    1099 
    1100                                                                 Expression * thisExpr = new CastExpr( new AddressExpr( new VariableExpr( thisParam ) ), new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ) );
    1101                                                                 Expression * dtorExpr = new VariableExpr( getDtorFunc( thisParam, callStmt, stmtsToAdd ) );
    1102 
    1103                                                                 // cast destructor pointer to void (*)(void *), to silence GCC incompatible pointer warnings
    1104                                                                 FunctionType * dtorFtype = new FunctionType( Type::Qualifiers(), false );
    1105                                                                 dtorFtype->parameters.push_back( ObjectDecl::newObject( "", new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), nullptr ) );
    1106                                                                 Type * dtorType = new PointerType( Type::Qualifiers(), dtorFtype );
    1107 
    1108                                                                 ObjectDecl * destructor = ObjectDecl::newObject( memberDtorNamer.newName(), new StructInstType( Type::Qualifiers(), Validate::dtorStruct ), new ListInit( { new SingleInit( thisExpr ), new SingleInit( new CastExpr( dtorExpr, dtorType ) ) } ) );
    1109                                                                 function->statements->push_front( new DeclStmt( destructor ) );
    1110                                                                 destructor->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( Validate::dtorStructDestroy ) } ) );
    1111 
    1112                                                                 function->statements->kids.splice( function->statements->kids.begin(), stmtsToAdd );
     1121                                                                function->get_statements()->push_back( callStmt );
    11131122                                                        }
    11141123                                                } catch ( SemanticErrorException & error ) {

  • src/InitTweak/GenInit.cc

    r933f32f r292642a  
    1515#include "GenInit.h"
    1616
    17 #include <stddef.h>                    // for NULL
    18 #include <algorithm>                   // for any_of
    19 #include <cassert>                     // for assert, strict_dynamic_cast, assertf
    20 #include <iterator>                    // for back_inserter, inserter, back_inse...
    21 #include <list>                        // for _List_iterator, list
     17#include <stddef.h>                // for NULL
     18#include <algorithm>               // for any_of
     19#include <cassert>                 // for assert, strict_dynamic_cast, assertf
     20#include <iterator>                // for back_inserter, inserter, back_inse...
     21#include <list>                    // for _List_iterator, list
    2222
    2323#include "CodeGen/OperatorTable.h"
    24 #include "Common/PassVisitor.h"        // for PassVisitor, WithGuards, WithShort...
    25 #include "Common/SemanticError.h"      // for SemanticError
    26 #include "Common/UniqueName.h"         // for UniqueName
    27 #include "Common/utility.h"            // for ValueGuard, maybeClone
    28 #include "GenPoly/GenPoly.h"           // for getFunctionType, isPolyType
    29 #include "GenPoly/ScopedSet.h"         // for ScopedSet, ScopedSet<>::const_iter...
    30 #include "InitTweak.h"                 // for isConstExpr, InitExpander, checkIn...
    31 #include "Parser/LinkageSpec.h"        // for isOverridable, C
     24#include "Common/PassVisitor.h"    // for PassVisitor, WithGuards, WithShort...
     25#include "Common/SemanticError.h"  // for SemanticError
     26#include "Common/UniqueName.h"     // for UniqueName
     27#include "Common/utility.h"        // for ValueGuard, maybeClone
     28#include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
     29#include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
     30#include "InitTweak.h"             // for isConstExpr, InitExpander, checkIn...
     31#include "Parser/LinkageSpec.h"    // for isOverridable, C
    3232#include "ResolvExpr/Resolver.h"
    33 #include "SymTab/Autogen.h"            // for genImplicitCall
    34 #include "SymTab/Mangler.h"            // for Mangler
    35 #include "SynTree/Declaration.h"       // for ObjectDecl, DeclarationWithType
    36 #include "SynTree/Expression.h"        // for VariableExpr, UntypedExpr, Address...
    37 #include "SynTree/Initializer.h"       // for ConstructorInit, SingleInit, Initi...
    38 #include "SynTree/Label.h"             // for Label
    39 #include "SynTree/Mutator.h"           // for mutateAll
    40 #include "SynTree/Statement.h"         // for CompoundStmt, ImplicitCtorDtorStmt
    41 #include "SynTree/Type.h"              // for Type, ArrayType, Type::Qualifiers
    42 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
    43 #include "Tuples/Tuples.h"             // for maybeImpure
    44 #include "Validate/FindSpecialDecls.h" // for SizeType
     33#include "SymTab/Autogen.h"        // for genImplicitCall, SizeType
     34#include "SymTab/Mangler.h"        // for Mangler
     35#include "SynTree/Declaration.h"   // for ObjectDecl, DeclarationWithType
     36#include "SynTree/Expression.h"    // for VariableExpr, UntypedExpr, Address...
     37#include "SynTree/Initializer.h"   // for ConstructorInit, SingleInit, Initi...
     38#include "SynTree/Label.h"         // for Label
     39#include "SynTree/Mutator.h"       // for mutateAll
     40#include "SynTree/Statement.h"     // for CompoundStmt, ImplicitCtorDtorStmt
     41#include "SynTree/Type.h"          // for Type, ArrayType, Type::Qualifiers
     42#include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
     43#include "Tuples/Tuples.h"         // for maybeImpure
    4544
    4645namespace InitTweak {
    … …  
    187186
    188187                        // need to resolve array dimensions in order to accurately determine if constexpr
    189                         ResolvExpr::findSingleExpression( arrayType->dimension, Validate::SizeType->clone(), indexer );
     188                        ResolvExpr::findSingleExpression( arrayType->dimension, SymTab::SizeType->clone(), indexer );
    190189                        // array is variable-length when the dimension is not constexpr
    191190                        arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
    … …  
    193192                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
    194193
    195                         ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
     194                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
    196195                        arrayDimension->get_type()->set_const( true );
    197196

  • src/InitTweak/InitTweak.cc

    r933f32f r292642a  
    340340                std::list< Expression * > matches;
    341341                collectCtorDtorCalls( stmt, matches );
    342                 assertf( matches.size() <= 1, "%zd constructor/destructors found in %s", matches.size(), toString( stmt ).c_str() );
     342                assert( matches.size() <= 1 );
    343343                return matches.size() == 1 ? matches.front() : nullptr;
    344344        }

  • src/Makefile.am

    r933f32f r292642a  
    6969ARFLAGS     = cr
    7070
    71 demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
     71demangler_SOURCES = SymTab/demangler.cc
    7272
    7373demangler_LDADD = libdemangle.a -ldl                    # yywrap

  • src/Makefile.in

    r933f32f r292642a  
    224224        $(am__objects_6) Tuples/TupleAssignment.$(OBJEXT) \
    225225        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
    226         Validate/HandleAttributes.$(OBJEXT) \
    227         Validate/FindSpecialDecls.$(OBJEXT)
     226        Validate/HandleAttributes.$(OBJEXT)
    228227am_libdemangle_a_OBJECTS = $(am__objects_7)
    229228libdemangle_a_OBJECTS = $(am_libdemangle_a_OBJECTS)
    … …  
    256255        Tuples/TupleExpansion.$(OBJEXT) Tuples/Explode.$(OBJEXT) \
    257256        Validate/HandleAttributes.$(OBJEXT) \
    258         Validate/FindSpecialDecls.$(OBJEXT) \
    259257        Virtual/ExpandCasts.$(OBJEXT)
    260258am____driver_cfa_cpp_OBJECTS = $(am__objects_8)
    … …  
    547545        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
    548546        Tuples/Explode.cc Validate/HandleAttributes.cc \
    549         Validate/FindSpecialDecls.cc Virtual/ExpandCasts.cc
     547        Virtual/ExpandCasts.cc
    550548SRCDEMANGLE = CompilationState.cc $(SRC_CODEGEN) \
    551549        Concurrency/Keywords.cc $(SRC_COMMON) $(SRC_CONTROLSTRUCT) \
    … …  
    554552        $(SRC_SYMTAB) SymTab/Demangle.cc $(SRC_SYNTREE) \
    555553        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
    556         Tuples/Explode.cc Validate/HandleAttributes.cc \
    557         Validate/FindSpecialDecls.cc
     554        Tuples/Explode.cc Validate/HandleAttributes.cc
    558555MAINTAINERCLEANFILES = ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}}
    559556MOSTLYCLEANFILES = Parser/lex.cc Parser/parser.cc Parser/parser.hh \
    … …  
    662659AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
    663660ARFLAGS = cr
    664 demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
     661demangler_SOURCES = SymTab/demangler.cc
    665662demangler_LDADD = libdemangle.a -ldl                    # yywrap
    666663noinst_LIBRARIES = libdemangle.a
    … …  
    959956        @: > Validate/$(DEPDIR)/$(am__dirstamp)
    960957Validate/HandleAttributes.$(OBJEXT): Validate/$(am__dirstamp) \
    961         Validate/$(DEPDIR)/$(am__dirstamp)
    962 Validate/FindSpecialDecls.$(OBJEXT): Validate/$(am__dirstamp) \
    963958        Validate/$(DEPDIR)/$(am__dirstamp)
    964959
    … …  
    12391234@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/TupleAssignment.Po@am__quote@
    12401235@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/TupleExpansion.Po@am__quote@
    1241 @AMDEP_TRUE@@am__include@ @am__quote@Validate/$(DEPDIR)/FindSpecialDecls.Po@am__quote@
    12421236@AMDEP_TRUE@@am__include@ @am__quote@Validate/$(DEPDIR)/HandleAttributes.Po@am__quote@
    12431237@AMDEP_TRUE@@am__include@ @am__quote@Virtual/$(DEPDIR)/ExpandCasts.Po@am__quote@

  • src/Parser/parser.yy

    r933f32f r292642a  
    13451345
    13461346handler_clause:
    1347         handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
     1347        handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
    13481348                { $$ = new StatementNode( build_catch( $1, $4, $6, $8 ) ); }
    1349         | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement
     1349        | handler_clause handler_key '(' push exception_declaration pop handler_predicate_opt ')' compound_statement pop
    13501350                { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( $2, $5, $7, $9 ) ) ); }
    13511351        ;

  • src/ResolvExpr/Resolver.cc

    r933f32f r292642a  
    4343#include "typeops.h"                     // for extractResultType
    4444#include "Unify.h"                       // for unify
    45 #include "Validate/FindSpecialDecls.h"   // for SizeType
    4645
    4746using namespace std;
    … …  
    236235                                winner.cost = winner.cvtCost;
    237236                        }
    238 
     237                       
    239238                        // produce ambiguous errors, if applicable
    240239                        if ( winners.size() != 1 ) {
    … …  
    256255
    257256                        // xxx - check for ambiguous expressions
    258 
     257                       
    259258                        // output selected choice
    260259                        alt = std::move( choice );
    … …  
    403402
    404403        void Resolver::previsit( ObjectDecl * objectDecl ) {
    405                 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
    406                 // class-variable initContext is changed multiple time because the LHS is analysed twice.
    407                 // The second analysis changes initContext because of a function type can contain object
    408                 // declarations in the return and parameter types. So each value of initContext is
     404                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
     405                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
     406                // The second analysis changes initContext because of a function type can contain object 
     407                // declarations in the return and parameter types. So each value of initContext is 
    409408                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
    410409                GuardValue( currentObject );
    … …  
    420419        void Resolver::handlePtrType( PtrType * type ) {
    421420                if ( type->get_dimension() ) {
    422                         findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
     421                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
    423422                }
    424423        }
    … …  
    443442
    444443        void Resolver::postvisit( FunctionDecl * functionDecl ) {
    445                 // default value expressions have an environment which shouldn't be there and trips up
     444                // default value expressions have an environment which shouldn't be there and trips up 
    446445                // later passes.
    447                 // xxx - it might be necessary to somehow keep the information from this environment, but I
     446                // xxx - it might be necessary to somehow keep the information from this environment, but I 
    448447                // can't currently see how it's useful.
    449448                for ( Declaration * d : functionDecl->type->parameters ) {
    … …  
    796795                initExpr->expr = nullptr;
    797796                std::swap( initExpr->env, newExpr->env );
    798                 // InitExpr may have inferParams in the case where the expression specializes a function
    799                 // pointer, and newExpr may already have inferParams of its own, so a simple swap is not
     797                // InitExpr may have inferParams in the case where the expression specializes a function 
     798                // pointer, and newExpr may already have inferParams of its own, so a simple swap is not 
    800799                // sufficient.
    801800                newExpr->spliceInferParams( initExpr );
    802801                delete initExpr;
    803802
    804                 // get the actual object's type (may not exactly match what comes back from the resolver
     803                // get the actual object's type (may not exactly match what comes back from the resolver 
    805804                // due to conversions)
    806805                Type * initContext = currentObject.getCurrentType();
    … …  
    815814                                        if ( isCharType( pt->get_base() ) ) {
    816815                                                if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
    817                                                         // strip cast if we're initializing a char[] with a char *,
     816                                                        // strip cast if we're initializing a char[] with a char *, 
    818817                                                        // e.g.  char x[] = "hello";
    819818                                                        newExpr = ce->get_arg();
    … …  
    838837                // move cursor into brace-enclosed initializer-list
    839838                currentObject.enterListInit();
    840                 // xxx - fix this so that the list isn't copied, iterator should be used to change current
     839                // xxx - fix this so that the list isn't copied, iterator should be used to change current 
    841840                // element
    842841                std::list<Designation *> newDesignations;
    843842                for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
    844                         // iterate designations and initializers in pairs, moving the cursor to the current
     843                        // iterate designations and initializers in pairs, moving the cursor to the current 
    845844                        // designated object and resolving the initializer against that object.
    846845                        Designation * des = std::get<0>(p);

  • src/SymTab/Autogen.cc

    r933f32f r292642a  
    4141
    4242namespace SymTab {
     43        Type * SizeType = 0;
     44
    4345        /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
    4446        struct FuncData {
    45                 typedef FunctionType * (*TypeGen)( Type *, bool );
     47                typedef FunctionType * (*TypeGen)( Type * );
    4648                FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
    4749                std::string fname;
    … …  
    229231
    230232        /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
    231         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
     233        FunctionType * genDefaultType( Type * paramType ) {
     234                const auto & typeParams = getGenericParams( paramType );
    232235                FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
    233                 if ( maybePolymorphic ) {
    234                         // only copy in
    235                         const auto & typeParams = getGenericParams( paramType );
    236                         cloneAll( typeParams, ftype->forall );
    237                 }
     236                cloneAll( typeParams, ftype->forall );
    238237                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
    239238                ftype->parameters.push_back( dstParam );
    … …  
    242241
    243242        /// given type T, generate type of copy ctor, i.e. function type void (*) (T *, T)
    244         FunctionType * genCopyType( Type * paramType, bool maybePolymorphic ) {
    245                 FunctionType *ftype = genDefaultType( paramType, maybePolymorphic );
     243        FunctionType * genCopyType( Type * paramType ) {
     244                FunctionType *ftype = genDefaultType( paramType );
    246245                ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    247246                ftype->parameters.push_back( srcParam );
    … …  
    250249
    251250        /// given type T, generate type of assignment, i.e. function type T (*) (T *, T)
    252         FunctionType * genAssignType( Type * paramType, bool maybePolymorphic ) {
    253                 FunctionType *ftype = genCopyType( paramType, maybePolymorphic );
     251        FunctionType * genAssignType( Type * paramType ) {
     252                FunctionType *ftype = genCopyType( paramType );
    254253                ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
    255254                ftype->returnVals.push_back( returnVal );
    … …  
    309308                for ( const FuncData & d : data ) {
    310309                        // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
    311                         FunctionType * ftype = d.genType( type, true );
     310                        FunctionType * ftype = d.genType( type );
    312311
    313312                        // destructor for concurrent type must be mutex

  • src/SymTab/Autogen.h

    r933f32f r292642a  
    3737        bool isUnnamedBitfield( ObjectDecl * obj );
    3838
    39         /// generate the type of an assignment function for paramType.
    40         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
    41         FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
    42 
    43         /// generate the type of a default constructor or destructor for paramType.
    44         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
    45         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
    46 
    47         /// generate the type of a copy constructor for paramType.
    48         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
    49         FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
     39        /// size_t type - set when size_t typedef is seen. Useful in a few places,
     40        /// such as in determining array dimension type
     41        extern Type * SizeType;
     42
     43        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
     44        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
     45        extern FunctionDecl * dereferenceOperator;
     46
     47        // generate the type of an assignment function for paramType
     48        FunctionType * genAssignType( Type * paramType );
     49
     50        // generate the type of a default constructor or destructor for paramType
     51        FunctionType * genDefaultType( Type * paramType );
     52
     53        // generate the type of a copy constructor for paramType
     54        FunctionType * genCopyType( Type * paramType );
    5055
    5156        /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.

  • src/SymTab/Validate.cc

    r933f32f r292642a  
    7676#include "SynTree/Visitor.h"           // for Visitor
    7777#include "Validate/HandleAttributes.h" // for handleAttributes
    78 #include "Validate/FindSpecialDecls.h" // for FindSpecialDecls
    7978
    8079class CompoundStmt;
    … …  
    289288        };
    290289
     290        FunctionDecl * dereferenceOperator = nullptr;
     291        struct FindSpecialDeclarations final {
     292                void previsit( FunctionDecl * funcDecl );
     293        };
     294
    291295        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
    292296                PassVisitor<EnumAndPointerDecay> epc;
    … …  
    295299                PassVisitor<CompoundLiteral> compoundliteral;
    296300                PassVisitor<ValidateGenericParameters> genericParams;
     301                PassVisitor<FindSpecialDeclarations> finder;
    297302                PassVisitor<LabelAddressFixer> labelAddrFixer;
    298303                PassVisitor<HoistTypeDecls> hoistDecls;
    … …  
    373378                        });
    374379                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
    375                                 Validate::findSpecialDecls( translationUnit );
     380                                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
    376381                        });
    377382                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
    … …  
    938943                if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
    939944                        // grab and remember declaration of size_t
    940                         Validate::SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
     945                        SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
    941946                } else {
    942947                        // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
    943948                        // eventually should have a warning for this case.
    944                         Validate::SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
     949                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
    945950                }
    946951        }
    … …  
    13301335                        // need to resolve array dimensions early so that constructor code can correctly determine
    13311336                        // if a type is a VLA (and hence whether its elements need to be constructed)
    1332                         ResolvExpr::findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
     1337                        ResolvExpr::findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
    13331338
    13341339                        // must re-evaluate whether a type is a VLA, now that more information is available
    … …  
    13671372                return addrExpr;
    13681373        }
     1374
     1375        void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) {
     1376                if ( ! dereferenceOperator ) {
     1377                        if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) {
     1378                                FunctionType * ftype = funcDecl->get_functionType();
     1379                                if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) {
     1380                                        dereferenceOperator = funcDecl;
     1381                                }
     1382                        }
     1383                }
     1384        }
    13691385} // namespace SymTab
    13701386

  • src/SynTree/DeclReplacer.cc

    r933f32f r292642a  
    3838                        void previsit( TypeInstType * inst );
    3939                };
    40 
    41                 /// Mutator that replaces uses of declarations with arbitrary expressions, according to the supplied mapping
    42                 struct ExprDeclReplacer {
    43                 private:
    44                         const ExprMap & exprMap;
    45                         bool debug;
    46                 public:
    47                         ExprDeclReplacer( const ExprMap & exprMap, bool debug = false );
    48 
    49                         // replace variable with new node from expr map
    50                         Expression * postmutate( VariableExpr * varExpr );
    51                 };
    5240        }
    5341
    … …  
    6553                DeclMap declMap;
    6654                replace( node, declMap, typeMap, debug );
    67         }
    68 
    69         void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug ) {
    70                 PassVisitor<ExprDeclReplacer> replacer( exprMap, debug );
    71                 node = maybeMutate( node, replacer );
    7255        }
    7356
    … …  
    9679                        }
    9780                }
    98 
    99                 ExprDeclReplacer::ExprDeclReplacer( const ExprMap & exprMap, bool debug ) : exprMap( exprMap ), debug( debug ) {}
    100 
    101                 Expression * ExprDeclReplacer::postmutate( VariableExpr * varExpr ) {
    102                         if ( exprMap.count( varExpr->var ) ) {
    103                                 Expression * replacement = exprMap.at( varExpr->var )->clone();
    104                                 if ( debug ) {
    105                                         std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)replacement << " " << replacement << std::endl;
    106                                 }
    107                                 std::swap( varExpr->env, replacement->env );
    108                                 delete varExpr;
    109                                 return replacement;
    110                         }
    111                         return varExpr;
    112                 }
    11381        }
    11482} // namespace VarExprReplacer

  • src/SynTree/DeclReplacer.h

    r933f32f r292642a  
    2626        typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
    2727        typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
    28         typedef std::map< DeclarationWithType *, Expression * > ExprMap;
    2928
    3029        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
    3130        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
    3231        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
    33 
    34         void replace( BaseSyntaxNode *& node, const ExprMap & exprMap, bool debug = false);
    35         template<typename T>
    36                 void replace( T *& node, const ExprMap & exprMap, bool debug = false ) {
    37                 if ( ! node ) return;
    38                 BaseSyntaxNode * arg = node;
    39                 replace( arg, exprMap, debug );
    40                 node = dynamic_cast<T *>( arg );
    41                 assertf( node, "DeclReplacer fundamentally changed the type of its argument." );
    42         }
    4332}
    4433

  • src/SynTree/Expression.cc

    r933f32f r292642a  
    538538        assert( callExpr );
    539539        assert( callExpr->result );
    540         set_result( callExpr->result->clone() );
     540        set_result( callExpr->get_result()->clone() );
    541541}
    542542
    543543ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other ) : Expression( other ), callExpr( maybeClone( other.callExpr ) ) {
     544        cloneAll( other.tempDecls, tempDecls );
     545        cloneAll( other.returnDecls, returnDecls );
     546        cloneAll( other.dtors, dtors );
    544547}
    545548
    … …  
    547550        set_env( nullptr ); // ImplicitCopyCtorExpr does not take ownership of an environment
    548551        delete callExpr;
     552        deleteAll( tempDecls );
     553        deleteAll( returnDecls );
     554        deleteAll( dtors );
    549555}
    550556
    … …  
    552558        os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
    553559        callExpr->print( os, indent+1 );
     560        os << std::endl << indent << "... with temporaries:" << std::endl;
     561        printAll( tempDecls, os, indent+1 );
     562        os << std::endl << indent << "... with return temporaries:" << std::endl;
     563        printAll( returnDecls, os, indent+1 );
     564        Expression::print( os, indent );
    554565}
    555566

  • src/SynTree/Expression.h

    r933f32f r292642a  
    593593class ImplicitCopyCtorExpr : public Expression {
    594594public:
    595         ApplicationExpr * callExpr = nullptr;
     595        ApplicationExpr * callExpr;
     596        std::list< ObjectDecl * > tempDecls;
     597        std::list< ObjectDecl * > returnDecls;
     598        std::list< Expression * > dtors;
    596599
    597600        ImplicitCopyCtorExpr( ApplicationExpr * callExpr );
    598601        ImplicitCopyCtorExpr( const ImplicitCopyCtorExpr & other );
    599602        virtual ~ImplicitCopyCtorExpr();
     603
     604        ApplicationExpr * get_callExpr() const { return callExpr; }
     605        void set_callExpr( ApplicationExpr * newValue ) { callExpr = newValue; }
     606
     607        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
     608        std::list< ObjectDecl * > & get_returnDecls() { return returnDecls; }
     609        std::list< Expression * > & get_dtors() { return dtors; }
    600610
    601611        virtual ImplicitCopyCtorExpr * clone() const { return new ImplicitCopyCtorExpr( * this ); }

  • src/Validate/module.mk

    r933f32f r292642a  
    1515###############################################################################
    1616
    17 SRC += Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
    18 SRCDEMANGLE += Validate/HandleAttributes.cc Validate/FindSpecialDecls.cc
     17SRC += Validate/HandleAttributes.cc
     18SRCDEMANGLE += Validate/HandleAttributes.cc

  • src/Virtual/ExpandCasts.cc

    r933f32f r292642a  
    147147                                //              )
    148148                                //      ),
    149                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
     149                        new UntypedExpr( new NameExpr( "__cfa__virtual_cast" ), {
    150150                                        new CastExpr(
    151151                                                new AddressExpr( new VariableExpr( table ) ),
    152152                                                pointer_to_pvt(1)
    153                                         ),
     153                                                ),
    154154                                        new CastExpr(
    155155                                                castExpr->get_arg(),
    156156                                                pointer_to_pvt(2)
    157                                         )
    158                         } ),
     157                                                )
     158                                } ),
    159159                        castExpr->get_result()->clone()
    160                 );
     160                        );
    161161
    162162                castExpr->set_arg( nullptr );

  • tests/.expect/KRfunctions.x64.txt

    r933f32f r292642a  
    1717static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    1818static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    19     {
    20         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    21     }
    22 
     19    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    2320}
    2421static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    25     {
    26         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    27     }
    28 
     22    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    2923}
    3024static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    31     {
    32         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    33     }
    34 
     25    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    3526}
    3627static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    3728    struct S _X4_retS1S_1;
    38     {
    39         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    40     }
    41 
    42     {
    43         ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    44     }
    45 
     29    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
     30    ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    4631    return _X4_retS1S_1;
    4732}
    4833static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    49     {
    50         ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    51     }
    52 
     34    ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    5335}
    5436signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
    … …  
    7759    __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
    7860    signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    79     {
    80         ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
    81     }
    82 
     61    ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
    8362    return _X11_retval_f10FPi_ii__1;
    8463}
    … …  
    10382    signed int _X1ai_2;
    10483    signed int _X1bi_2;
    105     {
    106         signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
    107         ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
    108     }
    109 
     84    signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
     85    ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
     86    ((void)(_tmp_cp_ret4) /* ^?{} */);
    11087    const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
    11188        __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;

  • tests/.expect/KRfunctions.x86.txt

    r933f32f r292642a  
    1717static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    1818static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    19     {
    20         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    21     }
    22 
     19    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    2320}
    2421static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    25     {
    26         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    27     }
    28 
     22    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    2923}
    3024static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    31     {
    32         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    33     }
    34 
     25    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    3526}
    3627static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    3728    struct S _X4_retS1S_1;
    38     {
    39         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    40     }
    41 
    42     {
    43         ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    44     }
    45 
     29    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
     30    ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    4631    return _X4_retS1S_1;
    4732}
    4833static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    49     {
    50         ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    51     }
    52 
     34    ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    5335}
    5436signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
    … …  
    7759    __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
    7860    signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    79     {
    80         ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
    81     }
    82 
     61    ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
    8362    return _X11_retval_f10FPi_ii__1;
    8463}
    … …  
    10382    signed int _X1ai_2;
    10483    signed int _X1bi_2;
    105     {
    106         signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
    107         ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
    108     }
    109 
     84    signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
     85    ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
     86    ((void)(_tmp_cp_ret4) /* ^?{} */);
    11087    const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
    11188        __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;

  • tests/.expect/attributes.x64.txt

    r933f32f r292642a  
    11signed int _X2laFi___1(){
    22    __attribute__ ((unused)) signed int _X10_retval_lai_1;
    3     {
    4         L: __attribute__ ((unused)) ((void)1);
    5     }
    6 
     3    L: __attribute__ ((unused)) ((void)1);
    74}
    85struct __attribute__ ((unused)) __anonymous0 {
    … …  
    2017static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    2118    struct __anonymous0 _X4_retS12__anonymous0_1;
    22     {
    23         ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    24     }
    25 
     19    ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    2620    return _X4_retS12__anonymous0_1;
    2721}
    … …  
    4135static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    4236    struct Agn2 _X4_retS4Agn2_1;
    43     {
    44         ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
    45     }
    46 
     37    ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
    4738    return _X4_retS4Agn2_1;
    4839}
    … …  
    6859static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    6960    struct __anonymous2 _X4_retS12__anonymous2_1;
    70     {
    71         ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    72     }
    73 
     61    ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    7462    return _X4_retS12__anonymous2_1;
    7563}
    … …  
    8876static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    8977    struct Agn4 _X4_retS4Agn4_1;
    90     {
    91         ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
    92     }
    93 
     78    ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
    9479    return _X4_retS4Agn4_1;
    9580}
    … …  
    119104static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
    120105static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    121     {
    122         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
    123     }
    124 
    125     {
    126         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    127     }
    128 
    129     {
    130         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    131     }
    132 
    133     {
    134         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    135     }
    136 
    137     {
    138         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    139     }
    140 
    141     {
    142         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    143     }
    144 
    145     {
    146         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    147     }
    148 
    149     {
    150         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    151     }
    152 
    153     {
    154         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    155     }
    156 
     106    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
     107    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
     108    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
     109    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     110    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     111    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     112    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     113    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     114    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    157115}
    158116static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    159     {
    160         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
    161     }
    162 
    163     {
    164         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
    165     }
    166 
    167     {
    168         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
    169     }
    170 
    171     {
    172         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
    173     }
    174 
    175     {
    176         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
    177     }
    178 
    179     {
    180         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
    181     }
    182 
    183     {
    184         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
    185     }
    186 
    187     {
    188         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
    189     }
    190 
    191     {
    192         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
    193     }
    194 
     117    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
     118    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
     119    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
     120    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
     121    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
     122    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
     123    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
     124    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
     125    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
    195126}
    196127static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    197     {
    198         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
    199     }
    200 
    201     {
    202         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
    203     }
    204 
    205     {
    206         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
    207     }
    208 
    209     {
    210         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
    211     }
    212 
    213     {
    214         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
    215     }
    216 
    217     {
    218         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
    219     }
    220 
    221     {
    222         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
    223     }
    224 
    225     {
    226         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
    227     }
    228 
    229     {
    230         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
    231     }
    232 
     128    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
     129    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
     130    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
     131    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
     132    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
     133    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
     134    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
     135    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
     136    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
    233137}
    234138static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    235139    struct Fdl _X4_retS3Fdl_1;
    236     {
    237         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
    238     }
    239 
    240     {
    241         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
    242     }
    243 
    244     {
    245         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
    246     }
    247 
    248     {
    249         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
    250     }
    251 
    252     {
    253         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
    254     }
    255 
    256     {
    257         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
    258     }
    259 
    260     {
    261         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
    262     }
    263 
    264     {
    265         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
    266     }
    267 
    268     {
    269         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
    270     }
    271 
    272     {
    273         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
    274     }
    275 
     140    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
     141    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
     142    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
     143    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
     144    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
     145    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
     146    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
     147    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
     148    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
     149    ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
    276150    return _X4_retS3Fdl_1;
    277151}
    278152static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
    279     {
    280         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    281     }
    282 
    283     {
    284         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    285     }
    286 
    287     {
    288         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    289     }
    290 
    291     {
    292         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    293     }
    294 
    295     {
    296         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    297     }
    298 
    299     {
    300         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    301     }
    302 
    303     {
    304         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    305     }
    306 
    307     {
    308         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    309     }
    310 
    311     {
    312         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    313     }
    314 
     153    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     154    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
     155    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
     156    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     157    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     158    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     159    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     160    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     161    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    315162}
    316163static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
    317     {
    318         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    319     }
    320 
    321     {
    322         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    323     }
    324 
    325     {
    326         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    327     }
    328 
    329     {
    330         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    331     }
    332 
    333     {
    334         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    335     }
    336 
    337     {
    338         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    339     }
    340 
    341     {
    342         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    343     }
    344 
    345     {
    346         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    347     }
    348 
    349     {
    350         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    351     }
    352 
     164    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     165    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     166    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
     167    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     168    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     169    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     170    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     171    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     172    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    353173}
    354174static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
    355     {
    356         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    357     }
    358 
    359     {
    360         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    361     }
    362 
    363     {
    364         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    365     }
    366 
    367     {
    368         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    369     }
    370 
    371     {
    372         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    373     }
    374 
    375     {
    376         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    377     }
    378 
    379     {
    380         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    381     }
    382 
    383     {
    384         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    385     }
    386 
    387     {
    388         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    389     }
    390 
     175    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     176    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     177    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     178    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     179    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     180    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     181    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     182    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     183    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    391184}
    392185static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
    393     {
    394         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    395     }
    396 
    397     {
    398         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    399     }
    400 
    401     {
    402         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    403     }
    404 
    405     {
    406         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    407     }
    408 
    409     {
    410         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    411     }
    412 
    413     {
    414         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    415     }
    416 
    417     {
    418         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    419     }
    420 
    421     {
    422         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    423     }
    424 
    425     {
    426         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    427     }
    428 
     186    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     187    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     188    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     189    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     190    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     191    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     192    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     193    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     194    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    429195}
    430196static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
    431     {
    432         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    433     }
    434 
    435     {
    436         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    437     }
    438 
    439     {
    440         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    441     }
    442 
    443     {
    444         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    445     }
    446 
    447     {
    448         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    449     }
    450 
    451     {
    452         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    453     }
    454 
    455     {
    456         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    457     }
    458 
    459     {
    460         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    461     }
    462 
    463     {
    464         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    465     }
    466 
     197    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     198    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     199    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     200    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     201    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     202    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     203    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     204    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     205    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    467206}
    468207static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
    469     {
    470         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    471     }
    472 
    473     {
    474         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    475     }
    476 
    477     {
    478         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    479     }
    480 
    481     {
    482         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    483     }
    484 
    485     {
    486         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    487     }
    488 
    489     {
    490         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    491     }
    492 
    493     {
    494         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    495     }
    496 
    497     {
    498         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    499     }
    500 
    501     {
    502         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    503     }
    504 
     208    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     209    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     210    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     211    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     212    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     213    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     214    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     215    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     216    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    505217}
    506218static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
    507     {
    508         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    509     }
    510 
    511     {
    512         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    513     }
    514 
    515     {
    516         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    517     }
    518 
    519     {
    520         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    521     }
    522 
    523     {
    524         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    525     }
    526 
    527     {
    528         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    529     }
    530 
    531     {
    532         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    533     }
    534 
    535     {
    536         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    537     }
    538 
    539     {
    540         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    541     }
    542 
     219    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     220    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     221    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     222    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     223    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     224    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     225    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
     226    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     227    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    543228}
    544229static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
    545     {
    546         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    547     }
    548 
    549     {
    550         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    551     }
    552 
    553     {
    554         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    555     }
    556 
    557     {
    558         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    559     }
    560 
    561     {
    562         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    563     }
    564 
    565     {
    566         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    567     }
    568 
    569     {
    570         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    571     }
    572 
    573     {
    574         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    575     }
    576 
    577     {
    578         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    579     }
    580 
     230    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     231    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     232    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     233    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     234    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     235    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     236    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
     237    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
     238    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    581239}
    582240static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
    583     {
    584         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    585     }
    586 
    587     {
    588         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    589     }
    590 
    591     {
    592         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    593     }
    594 
    595     {
    596         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    597     }
    598 
    599     {
    600         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    601     }
    602 
    603     {
    604         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    605     }
    606 
    607     {
    608         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    609     }
    610 
    611     {
    612         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    613     }
    614 
    615     {
    616         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
    617     }
    618 
     241    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     242    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     243    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     244    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     245    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     246    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     247    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
     248    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
     249    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
    619250}
    620251__attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
    … …  
    683314    __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    684315    __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
    685     {
    686         ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
    687     }
    688 
    689     {
    690         ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
    691     }
    692 
    693     {
    694         ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [((unsigned long int )5)]));
    695     }
    696 
    697     {
    698         ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[((unsigned long int )10)]));
    699     }
    700 
    701     {
    702         ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    703     }
    704 
     316    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
     317    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
     318    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [((unsigned long int )5)]));
     319    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[((unsigned long int )10)]));
     320    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    705321    struct __attribute__ ((unused)) __anonymous3 {
    706322        signed int _X1ii_2;
    707323    };
    708324    inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    709         {
    710             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
    711         }
    712 
     325        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
    713326    }
    714327    inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    715         {
    716             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
    717         }
    718 
     328        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
    719329    }
    720330    inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    721         {
    722             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
    723         }
    724 
     331        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
    725332    }
    726333    inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    727334        struct __anonymous3 _X4_retS12__anonymous3_2;
    728         {
    729             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
    730         }
    731 
    732         {
    733             ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
    734         }
    735 
     335        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
     336        ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
    736337        return _X4_retS12__anonymous3_2;
    737338    }
    738339    inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
    739         {
    740             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    741         }
    742 
    743     }
    744     {
    745         ((void)sizeof(struct __anonymous3 ));
    746     }
    747 
     340        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     341    }
     342    ((void)sizeof(struct __anonymous3 ));
    748343    enum __attribute__ ((unused)) __anonymous4 {
    749344        _X1RKM12__anonymous4_2,
    … …  
    752347    }
    753348    inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    754         {
    755             ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
    756         }
    757 
     349        ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
    758350    }
    759351    inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
    … …  
    761353    inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    762354        enum __anonymous4 _X4_retM12__anonymous4_2;
    763         {
    764             ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
    765         }
    766 
    767         {
    768             ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
    769         }
    770 
     355        ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
     356        ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
    771357        return _X4_retM12__anonymous4_2;
    772358    }
    773     {
    774         ((void)sizeof(enum __anonymous4 ));
    775     }
    776 
     359    ((void)sizeof(enum __anonymous4 ));
    777360}
    778361signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
    … …  
    800383static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    801384    struct Vad _X4_retS3Vad_1;
    802     {
    803         ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
    804     }
    805 
     385    ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
    806386    return _X4_retS3Vad_1;
    807387}

  • tests/.expect/attributes.x86.txt

    r933f32f r292642a  
    11signed int _X2laFi___1(){
    22    __attribute__ ((unused)) signed int _X10_retval_lai_1;
    3     {
    4         L: __attribute__ ((unused)) ((void)1);
    5     }
    6 
     3    L: __attribute__ ((unused)) ((void)1);
    74}
    85struct __attribute__ ((unused)) __anonymous0 {
    … …  
    2017static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    2118    struct __anonymous0 _X4_retS12__anonymous0_1;
    22     {
    23         ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    24     }
    25 
     19    ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    2620    return _X4_retS12__anonymous0_1;
    2721}
    … …  
    4135static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
    4236    struct Agn2 _X4_retS4Agn2_1;
    43     {
    44         ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
    45     }
    46 
     37    ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
    4738    return _X4_retS4Agn2_1;
    4839}
    … …  
    6859static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    6960    struct __anonymous2 _X4_retS12__anonymous2_1;
    70     {
    71         ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    72     }
    73 
     61    ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    7462    return _X4_retS12__anonymous2_1;
    7563}
    … …  
    8876static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
    8977    struct Agn4 _X4_retS4Agn4_1;
    90     {
    91         ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
    92     }
    93 
     78    ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
    9479    return _X4_retS4Agn4_1;
    9580}
    … …  
    119104static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
    120105static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    121     {
    122         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
    123     }
    124 
    125     {
    126         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    127     }
    128 
    129     {
    130         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    131     }
    132 
    133     {
    134         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    135     }
    136 
    137     {
    138         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    139     }
    140 
    141     {
    142         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    143     }
    144 
    145     {
    146         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    147     }
    148 
    149     {
    150         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    151     }
    152 
    153     {
    154         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    155     }
    156 
     106    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
     107    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
     108    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
     109    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     110    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     111    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     112    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     113    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     114    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    157115}
    158116static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    159     {
    160         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
    161     }
    162 
    163     {
    164         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
    165     }
    166 
    167     {
    168         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
    169     }
    170 
    171     {
    172         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
    173     }
    174 
    175     {
    176         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
    177     }
    178 
    179     {
    180         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
    181     }
    182 
    183     {
    184         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
    185     }
    186 
    187     {
    188         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
    189     }
    190 
    191     {
    192         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
    193     }
    194 
     117    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
     118    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
     119    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
     120    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
     121    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
     122    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
     123    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
     124    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
     125    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
    195126}
    196127static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
    197     {
    198         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
    199     }
    200 
    201     {
    202         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
    203     }
    204 
    205     {
    206         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
    207     }
    208 
    209     {
    210         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
    211     }
    212 
    213     {
    214         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
    215     }
    216 
    217     {
    218         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
    219     }
    220 
    221     {
    222         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
    223     }
    224 
    225     {
    226         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
    227     }
    228 
    229     {
    230         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
    231     }
    232 
     128    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
     129    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
     130    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
     131    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
     132    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
     133    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
     134    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
     135    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
     136    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
    233137}
    234138static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
    235139    struct Fdl _X4_retS3Fdl_1;
    236     {
    237         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
    238     }
    239 
    240     {
    241         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
    242     }
    243 
    244     {
    245         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
    246     }
    247 
    248     {
    249         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
    250     }
    251 
    252     {
    253         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
    254     }
    255 
    256     {
    257         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
    258     }
    259 
    260     {
    261         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
    262     }
    263 
    264     {
    265         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
    266     }
    267 
    268     {
    269         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
    270     }
    271 
    272     {
    273         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
    274     }
    275 
     140    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
     141    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
     142    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
     143    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
     144    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
     145    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
     146    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
     147    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
     148    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
     149    ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
    276150    return _X4_retS3Fdl_1;
    277151}
    278152static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
    279     {
    280         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    281     }
    282 
    283     {
    284         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
    285     }
    286 
    287     {
    288         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    289     }
    290 
    291     {
    292         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    293     }
    294 
    295     {
    296         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    297     }
    298 
    299     {
    300         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    301     }
    302 
    303     {
    304         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    305     }
    306 
    307     {
    308         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    309     }
    310 
    311     {
    312         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    313     }
    314 
     153    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     154    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
     155    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
     156    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     157    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     158    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     159    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     160    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     161    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    315162}
    316163static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
    317     {
    318         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    319     }
    320 
    321     {
    322         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    323     }
    324 
    325     {
    326         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
    327     }
    328 
    329     {
    330         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    331     }
    332 
    333     {
    334         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    335     }
    336 
    337     {
    338         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    339     }
    340 
    341     {
    342         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    343     }
    344 
    345     {
    346         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    347     }
    348 
    349     {
    350         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    351     }
    352 
     164    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     165    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     166    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
     167    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     168    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     169    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     170    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     171    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     172    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    353173}
    354174static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
    355     {
    356         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    357     }
    358 
    359     {
    360         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    361     }
    362 
    363     {
    364         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    365     }
    366 
    367     {
    368         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
    369     }
    370 
    371     {
    372         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    373     }
    374 
    375     {
    376         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    377     }
    378 
    379     {
    380         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    381     }
    382 
    383     {
    384         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    385     }
    386 
    387     {
    388         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    389     }
    390 
     175    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     176    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     177    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     178    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
     179    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     180    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     181    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     182    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     183    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    391184}
    392185static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
    393     {
    394         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    395     }
    396 
    397     {
    398         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    399     }
    400 
    401     {
    402         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    403     }
    404 
    405     {
    406         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    407     }
    408 
    409     {
    410         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
    411     }
    412 
    413     {
    414         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    415     }
    416 
    417     {
    418         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    419     }
    420 
    421     {
    422         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    423     }
    424 
    425     {
    426         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    427     }
    428 
     186    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     187    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     188    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     189    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     190    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
     191    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     192    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     193    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     194    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    429195}
    430196static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
    431     {
    432         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    433     }
    434 
    435     {
    436         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    437     }
    438 
    439     {
    440         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    441     }
    442 
    443     {
    444         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    445     }
    446 
    447     {
    448         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    449     }
    450 
    451     {
    452         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
    453     }
    454 
    455     {
    456         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    457     }
    458 
    459     {
    460         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    461     }
    462 
    463     {
    464         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    465     }
    466 
     197    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     198    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     199    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     200    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     201    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     202    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
     203    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     204    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     205    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    467206}
    468207static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
    469     {
    470         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    471     }
    472 
    473     {
    474         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    475     }
    476 
    477     {
    478         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    479     }
    480 
    481     {
    482         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    483     }
    484 
    485     {
    486         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    487     }
    488 
    489     {
    490         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    491     }
    492 
    493     {
    494         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
    495     }
    496 
    497     {
    498         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    499     }
    500 
    501     {
    502         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    503     }
    504 
     208    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     209    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     210    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     211    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     212    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     213    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     214    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
     215    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     216    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    505217}
    506218static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
    507     {
    508         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    509     }
    510 
    511     {
    512         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    513     }
    514 
    515     {
    516         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    517     }
    518 
    519     {
    520         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    521     }
    522 
    523     {
    524         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    525     }
    526 
    527     {
    528         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    529     }
    530 
    531     {
    532         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    533     }
    534 
    535     {
    536         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
    537     }
    538 
    539     {
    540         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    541     }
    542 
     219    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     220    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     221    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     222    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     223    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     224    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     225    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
     226    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
     227    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    543228}
    544229static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
    545     {
    546         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    547     }
    548 
    549     {
    550         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    551     }
    552 
    553     {
    554         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    555     }
    556 
    557     {
    558         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    559     }
    560 
    561     {
    562         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    563     }
    564 
    565     {
    566         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    567     }
    568 
    569     {
    570         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    571     }
    572 
    573     {
    574         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    575     }
    576 
    577     {
    578         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    579     }
    580 
     230    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     231    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     232    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     233    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     234    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     235    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     236    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
     237    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
     238    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
    581239}
    582240static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
    583     {
    584         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
    585     }
    586 
    587     {
    588         ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
    589     }
    590 
    591     {
    592         ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
    593     }
    594 
    595     {
    596         ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
    597     }
    598 
    599     {
    600         ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
    601     }
    602 
    603     {
    604         ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
    605     }
    606 
    607     {
    608         ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
    609     }
    610 
    611     {
    612         ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
    613     }
    614 
    615     {
    616         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
    617     }
    618 
     241    ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
     242    ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
     243    ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
     244    ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
     245    ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
     246    ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
     247    ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
     248    ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
     249    ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
    619250}
    620251__attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
    … …  
    683314    __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    684315    __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
    685     {
    686         ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
    687     }
    688 
    689     {
    690         ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
    691     }
    692 
    693     {
    694         ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [((unsigned int )5)]));
    695     }
    696 
    697     {
    698         ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[((unsigned int )10)]));
    699     }
    700 
    701     {
    702         ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    703     }
    704 
     316    ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
     317    ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
     318    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [((unsigned int )5)]));
     319    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[((unsigned int )10)]));
     320    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    705321    struct __attribute__ ((unused)) __anonymous3 {
    706322        signed int _X1ii_2;
    707323    };
    708324    inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    709         {
    710             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
    711         }
    712 
     325        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
    713326    }
    714327    inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    715         {
    716             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
    717         }
    718 
     328        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
    719329    }
    720330    inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
    721         {
    722             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
    723         }
    724 
     331        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
    725332    }
    726333    inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
    727334        struct __anonymous3 _X4_retS12__anonymous3_2;
    728         {
    729             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
    730         }
    731 
    732         {
    733             ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
    734         }
    735 
     335        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
     336        ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
    736337        return _X4_retS12__anonymous3_2;
    737338    }
    738339    inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
    739         {
    740             ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    741         }
    742 
    743     }
    744     {
    745         ((void)sizeof(struct __anonymous3 ));
    746     }
    747 
     340        ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
     341    }
     342    ((void)sizeof(struct __anonymous3 ));
    748343    enum __attribute__ ((unused)) __anonymous4 {
    749344        _X1RKM12__anonymous4_2,
    … …  
    752347    }
    753348    inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    754         {
    755             ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
    756         }
    757 
     349        ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
    758350    }
    759351    inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
    … …  
    761353    inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
    762354        enum __anonymous4 _X4_retM12__anonymous4_2;
    763         {
    764             ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
    765         }
    766 
    767         {
    768             ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
    769         }
    770 
     355        ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
     356        ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
    771357        return _X4_retM12__anonymous4_2;
    772358    }
    773     {
    774         ((void)sizeof(enum __anonymous4 ));
    775     }
    776 
     359    ((void)sizeof(enum __anonymous4 ));
    777360}
    778361signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
    … …  
    800383static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
    801384    struct Vad _X4_retS3Vad_1;
    802     {
    803         ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
    804     }
    805 
     385    ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
    806386    return _X4_retS3Vad_1;
    807387}

  • tests/.expect/declarationSpecifier.x64.txt

    r933f32f r292642a  
    1616static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1);
    1717static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    18     {
    19         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
    20     }
    21 
     18    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
    2219}
    2320static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    24     {
    25         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
    26     }
    27 
     21    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
    2822}
    2923static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    30     {
    31         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
    32     }
    33 
     24    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
    3425}
    3526static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    3627    struct __anonymous0 _X4_retS12__anonymous0_1;
    37     {
    38         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
    39     }
    40 
    41     {
    42         ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    43     }
    44 
     28    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
     29    ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    4530    return _X4_retS12__anonymous0_1;
    4631}
    4732static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
    48     {
    49         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
    50     }
    51 
     33    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
    5234}
    5335volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
    … …  
    6143static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
    6244static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    63     {
    64         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
    65     }
    66 
     45    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
    6746}
    6847static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    69     {
    70         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
    71     }
    72 
     48    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
    7349}
    7450static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    75     {
    76         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
    77     }
    78 
     51    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
    7952}
    8053static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    8154    struct __anonymous1 _X4_retS12__anonymous1_1;
    82     {
    83         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
    84     }
    85 
    86     {
    87         ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
    88     }
    89 
     55    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
     56    ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
    9057    return _X4_retS12__anonymous1_1;
    9158}
    9259static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
    93     {
    94         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
    95     }
    96 
     60    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
    9761}
    9862volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
    … …  
    10670static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
    10771static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    108     {
    109         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
    110     }
    111 
     72    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
    11273}
    11374static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    114     {
    115         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
    116     }
    117 
     75    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
    11876}
    11977static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    120     {
    121         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
    122     }
    123 
     78    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
    12479}
    12580static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    12681    struct __anonymous2 _X4_retS12__anonymous2_1;
    127     {
    128         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
    129     }
    130 
    131     {
    132         ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    133     }
    134 
     82    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
     83    ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    13584    return _X4_retS12__anonymous2_1;
    13685}
    13786static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
    138     {
    139         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
    140     }
    141 
     87    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
    14288}
    14389volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
    … …  
    15197static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
    15298static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    153     {
    154         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
    155     }
    156 
     99    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
    157100}
    158101static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    159     {
    160         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
    161     }
    162 
     102    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
    163103}
    164104static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    165     {
    166         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
    167     }
    168 
     105    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
    169106}
    170107static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    171108    struct __anonymous3 _X4_retS12__anonymous3_1;
    172     {
    173         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
    174     }
    175 
    176     {
    177         ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
    178     }
    179 
     109    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
     110    ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
    180111    return _X4_retS12__anonymous3_1;
    181112}
    182113static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
    183     {
    184         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
    185     }
    186 
     114    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
    187115}
    188116static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
    … …  
    196124static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
    197125static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    198     {
    199         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
    200     }
    201 
     126    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
    202127}
    203128static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    204     {
    205         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
    206     }
    207 
     129    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
    208130}
    209131static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    210     {
    211         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
    212     }
    213 
     132    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
    214133}
    215134static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    216135    struct __anonymous4 _X4_retS12__anonymous4_1;
    217     {
    218         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
    219     }
    220 
    221     {
    222         ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
    223     }
    224 
     136    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
     137    ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
    225138    return _X4_retS12__anonymous4_1;
    226139}
    227140static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
    228     {
    229         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
    230     }
    231 
     141    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
    232142}
    233143static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
    … …  
    241151static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
    242152static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    243     {
    244         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
    245     }
    246 
     153    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
    247154}
    248155static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    249     {
    250         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
    251     }
    252 
     156    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
    253157}
    254158static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    255     {
    256         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
    257     }
    258 
     159    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
    259160}
    260161static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    261162    struct __anonymous5 _X4_retS12__anonymous5_1;
    262     {
    263         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
    264     }
    265 
    266     {
    267         ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
    268     }
    269 
     163    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
     164    ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
    270165    return _X4_retS12__anonymous5_1;
    271166}
    272167static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
    273     {
    274         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
    275     }
    276 
     168    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
    277169}
    278170static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
    … …  
    286178static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
    287179static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    288     {
    289         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
    290     }
    291 
     180    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
    292181}
    293182static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    294     {
    295         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
    296     }
    297 
     183    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
    298184}
    299185static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    300     {
    301         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
    302     }
    303 
     186    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
    304187}
    305188static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    306189    struct __anonymous6 _X4_retS12__anonymous6_1;
    307     {
    308         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
    309     }
    310 
    311     {
    312         ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
    313     }
    314 
     190    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
     191    ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
    315192    return _X4_retS12__anonymous6_1;
    316193}
    317194static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
    318     {
    319         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
    320     }
    321 
     195    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
    322196}
    323197static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
    … …  
    331205static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
    332206static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    333     {
    334         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
    335     }
    336 
     207    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
    337208}
    338209static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    339     {
    340         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
    341     }
    342 
     210    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
    343211}
    344212static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    345     {
    346         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
    347     }
    348 
     213    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
    349214}
    350215static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    351216    struct __anonymous7 _X4_retS12__anonymous7_1;
    352     {
    353         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
    354     }
    355 
    356     {
    357         ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
    358     }
    359 
     217    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
     218    ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
    360219    return _X4_retS12__anonymous7_1;
    361220}
    362221static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
    363     {
    364         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
    365     }
    366 
     222    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
    367223}
    368224static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
    … …  
    384240static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
    385241static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    386     {
    387         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
    388     }
    389 
     242    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
    390243}
    391244static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    392     {
    393         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
    394     }
    395 
     245    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
    396246}
    397247static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    398     {
    399         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
    400     }
    401 
     248    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
    402249}
    403250static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    404251    struct __anonymous8 _X4_retS12__anonymous8_1;
    405     {
    406         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
    407     }
    408 
    409     {
    410         ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
    411     }
    412 
     252    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
     253    ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
    413254    return _X4_retS12__anonymous8_1;
    414255}
    415256static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1){
    416     {
    417         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
    418     }
    419 
     257    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
    420258}
    421259volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
    … …  
    429267static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1);
    430268static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    431     {
    432         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
    433     }
    434 
     269    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
    435270}
    436271static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    437     {
    438         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
    439     }
    440 
     272    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
    441273}
    442274static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    443     {
    444         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
    445     }
    446 
     275    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
    447276}
    448277static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    449278    struct __anonymous9 _X4_retS12__anonymous9_1;
    450     {
    451         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
    452     }
    453 
    454     {
    455         ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
    456     }
    457 
     279    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
     280    ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
    458281    return _X4_retS12__anonymous9_1;
    459282}
    460283static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1){
    461     {
    462         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
    463     }
    464 
     284    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
    465285}
    466286volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
    … …  
    474294static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1);
    475295static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    476     {
    477         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
    478     }
    479 
     296    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
    480297}
    481298static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    482     {
    483         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
    484     }
    485 
     299    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
    486300}
    487301static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    488     {
    489         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
    490     }
    491 
     302    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
    492303}
    493304static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    494305    struct __anonymous10 _X4_retS13__anonymous10_1;
    495     {
    496         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
    497     }
    498 
    499     {
    500         ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
    501     }
    502 
     306    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
     307    ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
    503308    return _X4_retS13__anonymous10_1;
    504309}
    505310static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1){
    506     {
    507         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
    508     }
    509 
     311    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
    510312}
    511313volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
    … …  
    519321static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1);
    520322static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    521     {
    522         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
    523     }
    524 
     323    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
    525324}
    526325static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    527     {
    528         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
    529     }
    530 
     326    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
    531327}
    532328static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    533     {
    534         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
    535     }
    536 
     329    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
    537330}
    538331static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    539332    struct __anonymous11 _X4_retS13__anonymous11_1;
    540     {
    541         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
    542     }
    543 
    544     {
    545         ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
    546     }
    547 
     333    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
     334    ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
    548335    return _X4_retS13__anonymous11_1;
    549336}
    550337static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1){
    551     {
    552         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
    553     }
    554 
     338    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
    555339}
    556340static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
    … …  
    564348static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1);
    565349static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    566     {
    567         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
    568     }
    569 
     350    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
    570351}
    571352static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    572     {
    573         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
    574     }
    575 
     353    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
    576354}
    577355static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    578     {
    579         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
    580     }
    581 
     356    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
    582357}
    583358static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    584359    struct __anonymous12 _X4_retS13__anonymous12_1;
    585     {
    586         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
    587     }
    588 
    589     {
    590         ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
    591     }
    592 
     360    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
     361    ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
    593362    return _X4_retS13__anonymous12_1;
    594363}
    595364static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1){
    596     {
    597         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
    598     }
    599 
     365    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
    600366}
    601367static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
    … …  
    609375static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1);
    610376static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    611     {
    612         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
    613     }
    614 
     377    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
    615378}
    616379static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    617     {
    618         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
    619     }
    620 
     380    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
    621381}
    622382static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    623     {
    624         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
    625     }
    626 
     383    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
    627384}
    628385static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    629386    struct __anonymous13 _X4_retS13__anonymous13_1;
    630     {
    631         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
    632     }
    633 
    634     {
    635         ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
    636     }
    637 
     387    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
     388    ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
    638389    return _X4_retS13__anonymous13_1;
    639390}
    640391static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1){
    641     {
    642         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
    643     }
    644 
     392    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
    645393}
    646394static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
    … …  
    654402static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
    655403static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    656     {
    657         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
    658     }
    659 
     404    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
    660405}
    661406static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    662     {
    663         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
    664     }
    665 
     407    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
    666408}
    667409static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    668     {
    669         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
    670     }
    671 
     410    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
    672411}
    673412static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    674413    struct __anonymous14 _X4_retS13__anonymous14_1;
    675     {
    676         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
    677     }
    678 
    679     {
    680         ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
    681     }
    682 
     414    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
     415    ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
    683416    return _X4_retS13__anonymous14_1;
    684417}
    685418static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
    686     {
    687         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
    688     }
    689 
     419    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
    690420}
    691421static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
    … …  
    699429static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
    700430static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    701     {
    702         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
    703     }
    704 
     431    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
    705432}
    706433static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    707     {
    708         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
    709     }
    710 
     434    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
    711435}
    712436static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    713     {
    714         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
    715     }
    716 
     437    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
    717438}
    718439static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    719440    struct __anonymous15 _X4_retS13__anonymous15_1;
    720     {
    721         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
    722     }
    723 
    724     {
    725         ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
    726     }
    727 
     441    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
     442    ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
    728443    return _X4_retS13__anonymous15_1;
    729444}
    730445static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
    731     {
    732         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
    733     }
    734 
     446    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
    735447}
    736448static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
    … …  
    760472static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1);
    761473static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    762     {
    763         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
    764     }
    765 
     474    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
    766475}
    767476static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    768     {
    769         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
    770     }
    771 
     477    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
    772478}
    773479static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    774     {
    775         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
    776     }
    777 
     480    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
    778481}
    779482static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    780483    struct __anonymous16 _X4_retS13__anonymous16_1;
    781     {
    782         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
    783     }
    784 
    785     {
    786         ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
    787     }
    788 
     484    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
     485    ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
    789486    return _X4_retS13__anonymous16_1;
    790487}
    791488static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1){
    792     {
    793         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
    794     }
    795 
     489    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
    796490}
    797491static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
    … …  
    805499static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1);
    806500static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    807     {
    808         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
    809     }
    810 
     501    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
    811502}
    812503static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    813     {
    814         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
    815     }
    816 
     504    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
    817505}
    818506static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    819     {
    820         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
    821     }
    822 
     507    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
    823508}
    824509static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    825510    struct __anonymous17 _X4_retS13__anonymous17_1;
    826     {
    827         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
    828     }
    829 
    830     {
    831         ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
    832     }
    833 
     511    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
     512    ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
    834513    return _X4_retS13__anonymous17_1;
    835514}
    836515static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1){
    837     {
    838         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
    839     }
    840 
     516    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
    841517}
    842518static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
    … …  
    850526static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1);
    851527static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    852     {
    853         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
    854     }
    855 
     528    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
    856529}
    857530static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    858     {
    859         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
    860     }
    861 
     531    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
    862532}
    863533static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    864     {
    865         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
    866     }
    867 
     534    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
    868535}
    869536static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    870537    struct __anonymous18 _X4_retS13__anonymous18_1;
    871     {
    872         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
    873     }
    874 
    875     {
    876         ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
    877     }
    878 
     538    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
     539    ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
    879540    return _X4_retS13__anonymous18_1;
    880541}
    881542static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1){
    882     {
    883         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
    884     }
    885 
     543    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
    886544}
    887545static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
    … …  
    895553static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1);
    896554static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    897     {
    898         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
    899     }
    900 
     555    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
    901556}
    902557static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    903     {
    904         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
    905     }
    906 
     558    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
    907559}
    908560static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    909     {
    910         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
    911     }
    912 
     561    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
    913562}
    914563static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    915564    struct __anonymous19 _X4_retS13__anonymous19_1;
    916     {
    917         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
    918     }
    919 
    920     {
    921         ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
    922     }
    923 
     565    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
     566    ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
    924567    return _X4_retS13__anonymous19_1;
    925568}
    926569static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1){
    927     {
    928         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
    929     }
    930 
     570    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
    931571}
    932572static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
    … …  
    940580static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1);
    941581static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    942     {
    943         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
    944     }
    945 
     582    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
    946583}
    947584static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    948     {
    949         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
    950     }
    951 
     585    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
    952586}
    953587static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    954     {
    955         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
    956     }
    957 
     588    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
    958589}
    959590static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    960591    struct __anonymous20 _X4_retS13__anonymous20_1;
    961     {
    962         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
    963     }
    964 
    965     {
    966         ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
    967     }
    968 
     592    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
     593    ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
    969594    return _X4_retS13__anonymous20_1;
    970595}
    971596static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1){
    972     {
    973         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
    974     }
    975 
     597    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
    976598}
    977599static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
    … …  
    985607static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1);
    986608static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    987     {
    988         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
    989     }
    990 
     609    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
    991610}
    992611static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    993     {
    994         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
    995     }
    996 
     612    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
    997613}
    998614static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    999     {
    1000         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
    1001     }
    1002 
     615    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
    1003616}
    1004617static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    1005618    struct __anonymous21 _X4_retS13__anonymous21_1;
    1006     {
    1007         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
    1008     }
    1009 
    1010     {
    1011         ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
    1012     }
    1013 
     619    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
     620    ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
    1014621    return _X4_retS13__anonymous21_1;
    1015622}
    1016623static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1){
    1017     {
    1018         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1019     }
    1020 
     624    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1021625}
    1022626static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
    … …  
    1030634static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
    1031635static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    1032     {
    1033         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
    1034     }
    1035 
     636    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
    1036637}
    1037638static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    1038     {
    1039         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
    1040     }
    1041 
     639    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
    1042640}
    1043641static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    1044     {
    1045         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
    1046     }
    1047 
     642    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
    1048643}
    1049644static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    1050645    struct __anonymous22 _X4_retS13__anonymous22_1;
    1051     {
    1052         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
    1053     }
    1054 
    1055     {
    1056         ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
    1057     }
    1058 
     646    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
     647    ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
    1059648    return _X4_retS13__anonymous22_1;
    1060649}
    1061650static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
    1062     {
    1063         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1064     }
    1065 
     651    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1066652}
    1067653static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
    … …  
    1075661static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
    1076662static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    1077     {
    1078         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
    1079     }
    1080 
     663    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
    1081664}
    1082665static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    1083     {
    1084         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
    1085     }
    1086 
     666    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
    1087667}
    1088668static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    1089     {
    1090         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
    1091     }
    1092 
     669    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
    1093670}
    1094671static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    1095672    struct __anonymous23 _X4_retS13__anonymous23_1;
    1096     {
    1097         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
    1098     }
    1099 
    1100     {
    1101         ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
    1102     }
    1103 
     673    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
     674    ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
    1104675    return _X4_retS13__anonymous23_1;
    1105676}
    1106677static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
    1107     {
    1108         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1109     }
    1110 
     678    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1111679}
    1112680static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
    … …  
    1121689signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    1122690    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    1123     {
    1124         ((void)(_X12_retval_maini_1=0) /* ?{} */);
    1125     }
    1126 
     691    ((void)(_X12_retval_maini_1=0) /* ?{} */);
    1127692    return _X12_retval_maini_1;
    1128693}
    … …  
    1131696signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    1132697    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    1133     {
    1134         signed int _tmp_cp_ret4;
    1135         ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
    1136     }
    1137 
     698    signed int _tmp_cp_ret4;
     699    ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
     700    ((void)(_tmp_cp_ret4) /* ^?{} */);
    1138701    return _X12_retval_maini_1;
    1139702}

  • tests/.expect/declarationSpecifier.x86.txt

    r933f32f r292642a  
    1616static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1);
    1717static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    18     {
    19         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
    20     }
    21 
     18    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
    2219}
    2320static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    24     {
    25         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
    26     }
    27 
     21    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
    2822}
    2923static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
    30     {
    31         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
    32     }
    33 
     24    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
    3425}
    3526static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
    3627    struct __anonymous0 _X4_retS12__anonymous0_1;
    37     {
    38         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
    39     }
    40 
    41     {
    42         ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    43     }
    44 
     28    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
     29    ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
    4530    return _X4_retS12__anonymous0_1;
    4631}
    4732static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
    48     {
    49         ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
    50     }
    51 
     33    ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
    5234}
    5335volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
    … …  
    6143static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
    6244static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    63     {
    64         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
    65     }
    66 
     45    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
    6746}
    6847static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    69     {
    70         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
    71     }
    72 
     48    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
    7349}
    7450static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
    75     {
    76         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
    77     }
    78 
     51    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
    7952}
    8053static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
    8154    struct __anonymous1 _X4_retS12__anonymous1_1;
    82     {
    83         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
    84     }
    85 
    86     {
    87         ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
    88     }
    89 
     55    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
     56    ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
    9057    return _X4_retS12__anonymous1_1;
    9158}
    9259static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
    93     {
    94         ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
    95     }
    96 
     60    ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
    9761}
    9862volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
    … …  
    10670static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
    10771static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    108     {
    109         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
    110     }
    111 
     72    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
    11273}
    11374static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    114     {
    115         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
    116     }
    117 
     75    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
    11876}
    11977static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
    120     {
    121         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
    122     }
    123 
     78    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
    12479}
    12580static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
    12681    struct __anonymous2 _X4_retS12__anonymous2_1;
    127     {
    128         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
    129     }
    130 
    131     {
    132         ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    133     }
    134 
     82    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
     83    ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
    13584    return _X4_retS12__anonymous2_1;
    13685}
    13786static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
    138     {
    139         ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
    140     }
    141 
     87    ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
    14288}
    14389volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
    … …  
    15197static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
    15298static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    153     {
    154         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
    155     }
    156 
     99    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
    157100}
    158101static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    159     {
    160         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
    161     }
    162 
     102    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
    163103}
    164104static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
    165     {
    166         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
    167     }
    168 
     105    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
    169106}
    170107static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
    171108    struct __anonymous3 _X4_retS12__anonymous3_1;
    172     {
    173         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
    174     }
    175 
    176     {
    177         ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
    178     }
    179 
     109    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
     110    ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
    180111    return _X4_retS12__anonymous3_1;
    181112}
    182113static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
    183     {
    184         ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
    185     }
    186 
     114    ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
    187115}
    188116static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
    … …  
    196124static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
    197125static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    198     {
    199         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
    200     }
    201 
     126    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
    202127}
    203128static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    204     {
    205         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
    206     }
    207 
     129    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
    208130}
    209131static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
    210     {
    211         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
    212     }
    213 
     132    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
    214133}
    215134static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
    216135    struct __anonymous4 _X4_retS12__anonymous4_1;
    217     {
    218         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
    219     }
    220 
    221     {
    222         ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
    223     }
    224 
     136    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
     137    ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
    225138    return _X4_retS12__anonymous4_1;
    226139}
    227140static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
    228     {
    229         ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
    230     }
    231 
     141    ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
    232142}
    233143static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
    … …  
    241151static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
    242152static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    243     {
    244         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
    245     }
    246 
     153    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
    247154}
    248155static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    249     {
    250         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
    251     }
    252 
     156    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
    253157}
    254158static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
    255     {
    256         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
    257     }
    258 
     159    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
    259160}
    260161static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
    261162    struct __anonymous5 _X4_retS12__anonymous5_1;
    262     {
    263         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
    264     }
    265 
    266     {
    267         ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
    268     }
    269 
     163    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
     164    ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
    270165    return _X4_retS12__anonymous5_1;
    271166}
    272167static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
    273     {
    274         ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
    275     }
    276 
     168    ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
    277169}
    278170static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
    … …  
    286178static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
    287179static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    288     {
    289         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
    290     }
    291 
     180    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
    292181}
    293182static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    294     {
    295         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
    296     }
    297 
     183    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
    298184}
    299185static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
    300     {
    301         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
    302     }
    303 
     186    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
    304187}
    305188static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
    306189    struct __anonymous6 _X4_retS12__anonymous6_1;
    307     {
    308         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
    309     }
    310 
    311     {
    312         ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
    313     }
    314 
     190    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
     191    ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
    315192    return _X4_retS12__anonymous6_1;
    316193}
    317194static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
    318     {
    319         ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
    320     }
    321 
     195    ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
    322196}
    323197static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
    … …  
    331205static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
    332206static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    333     {
    334         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
    335     }
    336 
     207    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
    337208}
    338209static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    339     {
    340         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
    341     }
    342 
     210    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
    343211}
    344212static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
    345     {
    346         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
    347     }
    348 
     213    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
    349214}
    350215static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
    351216    struct __anonymous7 _X4_retS12__anonymous7_1;
    352     {
    353         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
    354     }
    355 
    356     {
    357         ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
    358     }
    359 
     217    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
     218    ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
    360219    return _X4_retS12__anonymous7_1;
    361220}
    362221static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
    363     {
    364         ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
    365     }
    366 
     222    ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
    367223}
    368224static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
    … …  
    384240static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
    385241static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    386     {
    387         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
    388     }
    389 
     242    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
    390243}
    391244static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    392     {
    393         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
    394     }
    395 
     245    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
    396246}
    397247static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
    398     {
    399         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
    400     }
    401 
     248    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
    402249}
    403250static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
    404251    struct __anonymous8 _X4_retS12__anonymous8_1;
    405     {
    406         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
    407     }
    408 
    409     {
    410         ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
    411     }
    412 
     252    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
     253    ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
    413254    return _X4_retS12__anonymous8_1;
    414255}
    415256static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1){
    416     {
    417         ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
    418     }
    419 
     257    ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
    420258}
    421259volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
    … …  
    429267static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1);
    430268static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    431     {
    432         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
    433     }
    434 
     269    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
    435270}
    436271static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    437     {
    438         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
    439     }
    440 
     272    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
    441273}
    442274static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
    443     {
    444         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
    445     }
    446 
     275    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
    447276}
    448277static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
    449278    struct __anonymous9 _X4_retS12__anonymous9_1;
    450     {
    451         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
    452     }
    453 
    454     {
    455         ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
    456     }
    457 
     279    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
     280    ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
    458281    return _X4_retS12__anonymous9_1;
    459282}
    460283static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1){
    461     {
    462         ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
    463     }
    464 
     284    ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
    465285}
    466286volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
    … …  
    474294static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1);
    475295static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    476     {
    477         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
    478     }
    479 
     296    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
    480297}
    481298static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    482     {
    483         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
    484     }
    485 
     299    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
    486300}
    487301static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
    488     {
    489         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
    490     }
    491 
     302    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
    492303}
    493304static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
    494305    struct __anonymous10 _X4_retS13__anonymous10_1;
    495     {
    496         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
    497     }
    498 
    499     {
    500         ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
    501     }
    502 
     306    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
     307    ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
    503308    return _X4_retS13__anonymous10_1;
    504309}
    505310static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1){
    506     {
    507         ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
    508     }
    509 
     311    ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
    510312}
    511313volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
    … …  
    519321static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1);
    520322static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    521     {
    522         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
    523     }
    524 
     323    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
    525324}
    526325static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    527     {
    528         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
    529     }
    530 
     326    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
    531327}
    532328static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
    533     {
    534         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
    535     }
    536 
     329    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
    537330}
    538331static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
    539332    struct __anonymous11 _X4_retS13__anonymous11_1;
    540     {
    541         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
    542     }
    543 
    544     {
    545         ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
    546     }
    547 
     333    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
     334    ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
    548335    return _X4_retS13__anonymous11_1;
    549336}
    550337static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1){
    551     {
    552         ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
    553     }
    554 
     338    ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
    555339}
    556340static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
    … …  
    564348static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1);
    565349static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    566     {
    567         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
    568     }
    569 
     350    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
    570351}
    571352static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    572     {
    573         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
    574     }
    575 
     353    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
    576354}
    577355static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
    578     {
    579         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
    580     }
    581 
     356    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
    582357}
    583358static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
    584359    struct __anonymous12 _X4_retS13__anonymous12_1;
    585     {
    586         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
    587     }
    588 
    589     {
    590         ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
    591     }
    592 
     360    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
     361    ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
    593362    return _X4_retS13__anonymous12_1;
    594363}
    595364static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1){
    596     {
    597         ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
    598     }
    599 
     365    ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
    600366}
    601367static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
    … …  
    609375static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1);
    610376static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    611     {
    612         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
    613     }
    614 
     377    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
    615378}
    616379static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    617     {
    618         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
    619     }
    620 
     380    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
    621381}
    622382static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
    623     {
    624         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
    625     }
    626 
     383    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
    627384}
    628385static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
    629386    struct __anonymous13 _X4_retS13__anonymous13_1;
    630     {
    631         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
    632     }
    633 
    634     {
    635         ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
    636     }
    637 
     387    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
     388    ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
    638389    return _X4_retS13__anonymous13_1;
    639390}
    640391static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1){
    641     {
    642         ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
    643     }
    644 
     392    ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
    645393}
    646394static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
    … …  
    654402static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
    655403static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    656     {
    657         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
    658     }
    659 
     404    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
    660405}
    661406static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    662     {
    663         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
    664     }
    665 
     407    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
    666408}
    667409static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
    668     {
    669         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
    670     }
    671 
     410    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
    672411}
    673412static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
    674413    struct __anonymous14 _X4_retS13__anonymous14_1;
    675     {
    676         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
    677     }
    678 
    679     {
    680         ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
    681     }
    682 
     414    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
     415    ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
    683416    return _X4_retS13__anonymous14_1;
    684417}
    685418static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
    686     {
    687         ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
    688     }
    689 
     419    ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
    690420}
    691421static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
    … …  
    699429static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
    700430static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    701     {
    702         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
    703     }
    704 
     431    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
    705432}
    706433static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    707     {
    708         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
    709     }
    710 
     434    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
    711435}
    712436static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
    713     {
    714         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
    715     }
    716 
     437    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
    717438}
    718439static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
    719440    struct __anonymous15 _X4_retS13__anonymous15_1;
    720     {
    721         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
    722     }
    723 
    724     {
    725         ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
    726     }
    727 
     441    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
     442    ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
    728443    return _X4_retS13__anonymous15_1;
    729444}
    730445static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
    731     {
    732         ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
    733     }
    734 
     446    ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
    735447}
    736448static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
    … …  
    760472static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1);
    761473static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    762     {
    763         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
    764     }
    765 
     474    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
    766475}
    767476static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    768     {
    769         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
    770     }
    771 
     477    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
    772478}
    773479static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
    774     {
    775         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
    776     }
    777 
     480    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
    778481}
    779482static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
    780483    struct __anonymous16 _X4_retS13__anonymous16_1;
    781     {
    782         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
    783     }
    784 
    785     {
    786         ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
    787     }
    788 
     484    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
     485    ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
    789486    return _X4_retS13__anonymous16_1;
    790487}
    791488static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1){
    792     {
    793         ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
    794     }
    795 
     489    ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
    796490}
    797491static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
    … …  
    805499static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1);
    806500static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    807     {
    808         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
    809     }
    810 
     501    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
    811502}
    812503static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    813     {
    814         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
    815     }
    816 
     504    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
    817505}
    818506static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
    819     {
    820         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
    821     }
    822 
     507    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
    823508}
    824509static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
    825510    struct __anonymous17 _X4_retS13__anonymous17_1;
    826     {
    827         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
    828     }
    829 
    830     {
    831         ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
    832     }
    833 
     511    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
     512    ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
    834513    return _X4_retS13__anonymous17_1;
    835514}
    836515static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1){
    837     {
    838         ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
    839     }
    840 
     516    ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
    841517}
    842518static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
    … …  
    850526static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1);
    851527static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    852     {
    853         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
    854     }
    855 
     528    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
    856529}
    857530static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    858     {
    859         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
    860     }
    861 
     531    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
    862532}
    863533static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
    864     {
    865         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
    866     }
    867 
     534    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
    868535}
    869536static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
    870537    struct __anonymous18 _X4_retS13__anonymous18_1;
    871     {
    872         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
    873     }
    874 
    875     {
    876         ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
    877     }
    878 
     538    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
     539    ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
    879540    return _X4_retS13__anonymous18_1;
    880541}
    881542static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1){
    882     {
    883         ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
    884     }
    885 
     543    ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
    886544}
    887545static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
    … …  
    895553static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1);
    896554static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    897     {
    898         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
    899     }
    900 
     555    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
    901556}
    902557static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    903     {
    904         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
    905     }
    906 
     558    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
    907559}
    908560static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
    909     {
    910         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
    911     }
    912 
     561    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
    913562}
    914563static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
    915564    struct __anonymous19 _X4_retS13__anonymous19_1;
    916     {
    917         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
    918     }
    919 
    920     {
    921         ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
    922     }
    923 
     565    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
     566    ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
    924567    return _X4_retS13__anonymous19_1;
    925568}
    926569static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1){
    927     {
    928         ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
    929     }
    930 
     570    ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
    931571}
    932572static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
    … …  
    940580static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1);
    941581static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    942     {
    943         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
    944     }
    945 
     582    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
    946583}
    947584static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    948     {
    949         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
    950     }
    951 
     585    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
    952586}
    953587static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
    954     {
    955         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
    956     }
    957 
     588    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
    958589}
    959590static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
    960591    struct __anonymous20 _X4_retS13__anonymous20_1;
    961     {
    962         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
    963     }
    964 
    965     {
    966         ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
    967     }
    968 
     592    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
     593    ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
    969594    return _X4_retS13__anonymous20_1;
    970595}
    971596static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1){
    972     {
    973         ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
    974     }
    975 
     597    ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
    976598}
    977599static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
    … …  
    985607static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1);
    986608static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    987     {
    988         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
    989     }
    990 
     609    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
    991610}
    992611static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    993     {
    994         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
    995     }
    996 
     612    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
    997613}
    998614static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
    999     {
    1000         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
    1001     }
    1002 
     615    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
    1003616}
    1004617static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
    1005618    struct __anonymous21 _X4_retS13__anonymous21_1;
    1006     {
    1007         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
    1008     }
    1009 
    1010     {
    1011         ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
    1012     }
    1013 
     619    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
     620    ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
    1014621    return _X4_retS13__anonymous21_1;
    1015622}
    1016623static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1){
    1017     {
    1018         ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1019     }
    1020 
     624    ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1021625}
    1022626static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
    … …  
    1030634static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
    1031635static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    1032     {
    1033         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
    1034     }
    1035 
     636    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
    1036637}
    1037638static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    1038     {
    1039         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
    1040     }
    1041 
     639    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
    1042640}
    1043641static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
    1044     {
    1045         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
    1046     }
    1047 
     642    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
    1048643}
    1049644static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
    1050645    struct __anonymous22 _X4_retS13__anonymous22_1;
    1051     {
    1052         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
    1053     }
    1054 
    1055     {
    1056         ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
    1057     }
    1058 
     646    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
     647    ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
    1059648    return _X4_retS13__anonymous22_1;
    1060649}
    1061650static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
    1062     {
    1063         ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1064     }
    1065 
     651    ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1066652}
    1067653static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
    … …  
    1075661static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
    1076662static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    1077     {
    1078         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
    1079     }
    1080 
     663    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
    1081664}
    1082665static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    1083     {
    1084         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
    1085     }
    1086 
     666    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
    1087667}
    1088668static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
    1089     {
    1090         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
    1091     }
    1092 
     669    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
    1093670}
    1094671static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
    1095672    struct __anonymous23 _X4_retS13__anonymous23_1;
    1096     {
    1097         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
    1098     }
    1099 
    1100     {
    1101         ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
    1102     }
    1103 
     673    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
     674    ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
    1104675    return _X4_retS13__anonymous23_1;
    1105676}
    1106677static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
    1107     {
    1108         ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1109     }
    1110 
     678    ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
    1111679}
    1112680static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
    … …  
    1121689signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
    1122690    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    1123     {
    1124         ((void)(_X12_retval_maini_1=0) /* ?{} */);
    1125     }
    1126 
     691    ((void)(_X12_retval_maini_1=0) /* ?{} */);
    1127692    return _X12_retval_maini_1;
    1128693}
    … …  
    1131696signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    1132697    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    1133     {
    1134         signed int _tmp_cp_ret4;
    1135         ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
    1136     }
    1137 
     698    signed int _tmp_cp_ret4;
     699    ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
     700    ((void)(_tmp_cp_ret4) /* ^?{} */);
    1138701    return _X12_retval_maini_1;
    1139702}

  • tests/.expect/extension.x64.txt

    r933f32f r292642a  
    1515static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1);
    1616static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    17     {
    18         ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
    19     }
    20 
    21     {
    22         ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    23     }
    24 
    25     {
    26         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    27     }
    28 
     17    ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
     18    ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
     19    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    2920}
    3021static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    31     {
    32         ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
    33     }
    34 
    35     {
    36         ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
    37     }
    38 
    39     {
    40         ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
    41     }
    42 
     22    ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
     23    ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
     24    ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
    4325}
    4426static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    45     {
    46         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
    47     }
    48 
    49     {
    50         ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
    51     }
    52 
    53     {
    54         ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
    55     }
    56 
     27    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
     28    ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
     29    ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
    5730}
    5831static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    5932    struct S _X4_retS1S_1;
    60     {
    61         ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
    62     }
    63 
    64     {
    65         ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
    66     }
    67 
    68     {
    69         ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
    70     }
    71 
    72     {
    73         ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    74     }
    75 
     33    ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
     34    ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
     35    ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
     36    ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    7637    return _X4_retS1S_1;
    7738}
    7839static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1){
    79     {
    80         ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    81     }
    82 
    83     {
    84         ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    85     }
    86 
    87     {
    88         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    89     }
    90 
     40    ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
     41    ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
     42    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    9143}
    9244static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1){
    93     {
    94         ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    95     }
    96 
    97     {
    98         ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    99     }
    100 
    101     {
    102         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    103     }
    104 
     45    ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
     46    ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
     47    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    10548}
    10649static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
    107     {
    108         ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    109     }
    110 
    111     {
    112         ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    113     }
    114 
    115     {
    116         ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
    117     }
    118 
     50    ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
     51    ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
     52    ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
    11953}
    12054__extension__ union U {
    … …  
    13165}
    13266static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    133     {
    134         ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    135     }
    136 
     67    ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    13768}
    13869static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
    … …  
    14071static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    14172    union U _X4_retU1U_1;
    142     {
    143         ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    144     }
    145 
    146     {
    147         ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
    148     }
    149 
     73    ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
     74    ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
    15075    return _X4_retU1U_1;
    15176}
    15277static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1){
    153     {
    154         ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
    155     }
    156 
     78    ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
    15779}
    15880__extension__ enum E {
    … …  
    17597    };
    17698    inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    177         {
    178             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    179         }
    180 
    181         {
    182             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    183         }
    184 
    185         {
    186             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    187         }
    188 
    189         {
    190             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    191         }
    192 
    193         {
    194             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    195         }
    196 
    197         {
    198             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    199         }
    200 
     99        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
     100        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     101        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     102        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     103        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     104        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    201105    }
    202106    inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    203         {
    204             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    205         }
    206 
    207         {
    208             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    209         }
    210 
    211         {
    212             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    213         }
    214 
    215         {
    216             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
    217         }
    218 
    219         {
    220             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
    221         }
    222 
    223         {
    224             ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
    225         }
    226 
     107        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
     108        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
     109        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
     110        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
     111        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
     112        ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
    227113    }
    228114    inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    229         {
    230             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
    231         }
    232 
    233         {
    234             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
    235         }
    236 
    237         {
    238             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
    239         }
    240 
    241         {
    242             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    243         }
    244 
    245         {
    246             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    247         }
    248 
    249         {
    250             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    251         }
    252 
     115        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
     116        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
     117        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
     118        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
     119        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
     120        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    253121    }
    254122    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    255123        struct S _X4_retS1S_2;
    256         {
    257             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    258         }
    259 
    260         {
    261             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    262         }
    263 
    264         {
    265             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    266         }
    267 
    268         {
    269             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
    270         }
    271 
    272         {
    273             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
    274         }
    275 
    276         {
    277             ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
    278         }
    279 
    280         {
    281             ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    282         }
    283 
     124        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
     125        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
     126        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
     127        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
     128        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
     129        ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
     130        ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    284131        return _X4_retS1S_2;
    285132    }
    286133    inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    287         {
    288             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    289         }
    290 
    291         {
    292             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    293         }
    294 
    295         {
    296             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    297         }
    298 
    299         {
    300             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    301         }
    302 
    303         {
    304             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    305         }
    306 
    307         {
    308             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    309         }
    310 
     134        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     135        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     136        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     137        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     138        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     139        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    311140    }
    312141    inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    313         {
    314             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    315         }
    316 
    317         {
    318             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    319         }
    320 
    321         {
    322             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    323         }
    324 
    325         {
    326             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    327         }
    328 
    329         {
    330             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    331         }
    332 
    333         {
    334             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    335         }
    336 
     142        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     143        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     144        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     145        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     146        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     147        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    337148    }
    338149    inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    339         {
    340             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    341         }
    342 
    343         {
    344             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    345         }
    346 
    347         {
    348             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    349         }
    350 
    351         {
    352             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    353         }
    354 
    355         {
    356             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    357         }
    358 
    359         {
    360             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    361         }
    362 
     150        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     151        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     152        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     153        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     154        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     155        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    363156    }
    364157    inline void _X12_constructorFv_S1SiiiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2){
    365         {
    366             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    367         }
    368 
    369         {
    370             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    371         }
    372 
    373         {
    374             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    375         }
    376 
    377         {
    378             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    379         }
    380 
    381         {
    382             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    383         }
    384 
    385         {
    386             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    387         }
    388 
     158        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     159        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     160        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     161        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
     162        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     163        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    389164    }
    390165    inline void _X12_constructorFv_S1SiiiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2){
    391         {
    392             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    393         }
    394 
    395         {
    396             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    397         }
    398 
    399         {
    400             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    401         }
    402 
    403         {
    404             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    405         }
    406 
    407         {
    408             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    409         }
    410 
    411         {
    412             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    413         }
    414 
     166        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     167        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     168        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     169        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
     170        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
     171        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    415172    }
    416173    inline void _X12_constructorFv_S1SiiiPiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2, signed int *_X1zPi_2){
    417         {
    418             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    419         }
    420 
    421         {
    422             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    423         }
    424 
    425         {
    426             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    427         }
    428 
    429         {
    430             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    431         }
    432 
    433         {
    434             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    435         }
    436 
    437         {
    438             ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
    439         }
    440 
     174        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     175        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     176        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     177        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
     178        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
     179        ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
    441180    }
    442181    signed int _X1ii_2 = (__extension__ _X1ai_1+__extension__ 3);
    443     {
    444         ((void)__extension__ 3);
    445     }
    446 
    447     {
    448         ((void)__extension__ _X1ai_1);
    449     }
    450 
     182    ((void)__extension__ 3);
     183    ((void)__extension__ _X1ai_1);
    451184    __extension__ signed int _X1ai_2;
    452185    __extension__ signed int _X1bi_2;
    453186    __extension__ signed int _X1ci_2;
    454     {
    455         ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
    456     }
    457 
    458     {
    459         signed int _tmp_cp_ret4;
    460         ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
    461     }
    462 
     187    ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
     188    signed int _tmp_cp_ret4;
     189    ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
     190    ((void)(_tmp_cp_ret4) /* ^?{} */);
    463191    __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){
    464192        __attribute__ ((unused)) signed int _X12_retval_maryi_2;
    465193    }
    466     {
    467         ((void)__extension__ sizeof(3));
    468     }
    469 
    470     {
    471         ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
    472     }
    473 
    474     {
    475         ((void)__extension__ __alignof__(__extension__ _X1ai_2));
    476     }
    477 
    478     {
    479         ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
    480     }
    481 
    482     {
    483         ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
    484     }
    485 
    486     {
    487         ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    488     }
    489 
    490     {
    491         ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    492     }
    493 
    494 }
     194    ((void)__extension__ sizeof(3));
     195    ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
     196    ((void)__extension__ __alignof__(__extension__ _X1ai_2));
     197    ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
     198    ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
     199    ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
     200    ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
     201}

  • tests/.expect/extension.x86.txt

    r933f32f r292642a  
    1515static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1);
    1616static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    17     {
    18         ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
    19     }
    20 
    21     {
    22         ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    23     }
    24 
    25     {
    26         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    27     }
    28 
     17    ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
     18    ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
     19    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    2920}
    3021static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    31     {
    32         ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
    33     }
    34 
    35     {
    36         ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
    37     }
    38 
    39     {
    40         ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
    41     }
    42 
     22    ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
     23    ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
     24    ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
    4325}
    4426static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    45     {
    46         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
    47     }
    48 
    49     {
    50         ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
    51     }
    52 
    53     {
    54         ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
    55     }
    56 
     27    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
     28    ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
     29    ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
    5730}
    5831static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    5932    struct S _X4_retS1S_1;
    60     {
    61         ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
    62     }
    63 
    64     {
    65         ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
    66     }
    67 
    68     {
    69         ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
    70     }
    71 
    72     {
    73         ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    74     }
    75 
     33    ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
     34    ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
     35    ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
     36    ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    7637    return _X4_retS1S_1;
    7738}
    7839static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1){
    79     {
    80         ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    81     }
    82 
    83     {
    84         ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
    85     }
    86 
    87     {
    88         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    89     }
    90 
     40    ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
     41    ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
     42    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    9143}
    9244static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1){
    93     {
    94         ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    95     }
    96 
    97     {
    98         ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    99     }
    100 
    101     {
    102         ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    103     }
    104 
     45    ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
     46    ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
     47    ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
    10548}
    10649static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
    107     {
    108         ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
    109     }
    110 
    111     {
    112         ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
    113     }
    114 
    115     {
    116         ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
    117     }
    118 
     50    ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
     51    ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
     52    ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
    11953}
    12054__extension__ union U {
    … …  
    13165}
    13266static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    133     {
    134         ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    135     }
    136 
     67    ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    13768}
    13869static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
    … …  
    14071static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
    14172    union U _X4_retU1U_1;
    142     {
    143         ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
    144     }
    145 
    146     {
    147         ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
    148     }
    149 
     73    ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
     74    ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
    15075    return _X4_retU1U_1;
    15176}
    15277static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1){
    153     {
    154         ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
    155     }
    156 
     78    ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
    15779}
    15880__extension__ enum E {
    … …  
    17597    };
    17698    inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    177         {
    178             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    179         }
    180 
    181         {
    182             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    183         }
    184 
    185         {
    186             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    187         }
    188 
    189         {
    190             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    191         }
    192 
    193         {
    194             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    195         }
    196 
    197         {
    198             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    199         }
    200 
     99        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
     100        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     101        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     102        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     103        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     104        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    201105    }
    202106    inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    203         {
    204             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    205         }
    206 
    207         {
    208             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    209         }
    210 
    211         {
    212             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    213         }
    214 
    215         {
    216             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
    217         }
    218 
    219         {
    220             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
    221         }
    222 
    223         {
    224             ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
    225         }
    226 
     107        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
     108        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
     109        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
     110        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
     111        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
     112        ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
    227113    }
    228114    inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    229         {
    230             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
    231         }
    232 
    233         {
    234             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
    235         }
    236 
    237         {
    238             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
    239         }
    240 
    241         {
    242             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    243         }
    244 
    245         {
    246             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    247         }
    248 
    249         {
    250             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    251         }
    252 
     115        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
     116        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
     117        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
     118        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
     119        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
     120        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    253121    }
    254122    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    255123        struct S _X4_retS1S_2;
    256         {
    257             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    258         }
    259 
    260         {
    261             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    262         }
    263 
    264         {
    265             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    266         }
    267 
    268         {
    269             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
    270         }
    271 
    272         {
    273             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
    274         }
    275 
    276         {
    277             ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
    278         }
    279 
    280         {
    281             ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    282         }
    283 
     124        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
     125        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
     126        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
     127        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
     128        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
     129        ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
     130        ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    284131        return _X4_retS1S_2;
    285132    }
    286133    inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    287         {
    288             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    289         }
    290 
    291         {
    292             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    293         }
    294 
    295         {
    296             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    297         }
    298 
    299         {
    300             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    301         }
    302 
    303         {
    304             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    305         }
    306 
    307         {
    308             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    309         }
    310 
     134        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     135        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     136        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     137        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     138        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     139        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    311140    }
    312141    inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    313         {
    314             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    315         }
    316 
    317         {
    318             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    319         }
    320 
    321         {
    322             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    323         }
    324 
    325         {
    326             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    327         }
    328 
    329         {
    330             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    331         }
    332 
    333         {
    334             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    335         }
    336 
     142        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     143        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     144        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
     145        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     146        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     147        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    337148    }
    338149    inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    339         {
    340             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    341         }
    342 
    343         {
    344             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    345         }
    346 
    347         {
    348             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    349         }
    350 
    351         {
    352             ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
    353         }
    354 
    355         {
    356             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    357         }
    358 
    359         {
    360             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    361         }
    362 
     150        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     151        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     152        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     153        ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
     154        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     155        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    363156    }
    364157    inline void _X12_constructorFv_S1SiiiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2){
    365         {
    366             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    367         }
    368 
    369         {
    370             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    371         }
    372 
    373         {
    374             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    375         }
    376 
    377         {
    378             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    379         }
    380 
    381         {
    382             ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
    383         }
    384 
    385         {
    386             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    387         }
    388 
     158        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     159        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     160        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     161        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
     162        ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
     163        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    389164    }
    390165    inline void _X12_constructorFv_S1SiiiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2){
    391         {
    392             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    393         }
    394 
    395         {
    396             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    397         }
    398 
    399         {
    400             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    401         }
    402 
    403         {
    404             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    405         }
    406 
    407         {
    408             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    409         }
    410 
    411         {
    412             ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    413         }
    414 
     166        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     167        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     168        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     169        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
     170        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
     171        ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
    415172    }
    416173    inline void _X12_constructorFv_S1SiiiPiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2, signed int *_X1zPi_2){
    417         {
    418             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    419         }
    420 
    421         {
    422             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    423         }
    424 
    425         {
    426             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    427         }
    428 
    429         {
    430             ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
    431         }
    432 
    433         {
    434             ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
    435         }
    436 
    437         {
    438             ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
    439         }
    440 
     174        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     175        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     176        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
     177        ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
     178        ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
     179        ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
    441180    }
    442181    signed int _X1ii_2 = (__extension__ _X1ai_1+__extension__ 3);
    443     {
    444         ((void)__extension__ 3);
    445     }
    446 
    447     {
    448         ((void)__extension__ _X1ai_1);
    449     }
    450 
     182    ((void)__extension__ 3);
     183    ((void)__extension__ _X1ai_1);
    451184    __extension__ signed int _X1ai_2;
    452185    __extension__ signed int _X1bi_2;
    453186    __extension__ signed int _X1ci_2;
    454     {
    455         ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
    456     }
    457 
    458     {
    459         signed int _tmp_cp_ret4;
    460         ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
    461     }
    462 
     187    ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
     188    signed int _tmp_cp_ret4;
     189    ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
     190    ((void)(_tmp_cp_ret4) /* ^?{} */);
    463191    __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){
    464192        __attribute__ ((unused)) signed int _X12_retval_maryi_2;
    465193    }
    466     {
    467         ((void)__extension__ sizeof(3));
    468     }
    469 
    470     {
    471         ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
    472     }
    473 
    474     {
    475         ((void)__extension__ __alignof__(__extension__ _X1ai_2));
    476     }
    477 
    478     {
    479         ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
    480     }
    481 
    482     {
    483         ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
    484     }
    485 
    486     {
    487         ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    488     }
    489 
    490     {
    491         ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    492     }
    493 
    494 }
     194    ((void)__extension__ sizeof(3));
     195    ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
     196    ((void)__extension__ __alignof__(__extension__ _X1ai_2));
     197    ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
     198    ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
     199    ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
     200    ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
     201}

  • tests/.expect/functions.x64.txt

    r933f32f r292642a  
    33signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(__attribute__ ((unused)) signed int (*__anonymous_object0)(void), __attribute__ ((unused)) signed int (*__anonymous_object1)(signed int __anonymous_object2), __attribute__ ((unused)) signed int (*__anonymous_object3)(void), __attribute__ ((unused)) signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
    44    __attribute__ ((unused)) signed int _X9_retval_fi_1;
    5     {
    6         ((void)(*_X1gFv___1)());
    7     }
    8 
    9     {
    10         ((void)_X1gFv___1());
    11     }
    12 
    13     {
    14         ((void)(_X1gFv___1=_X1hFv___1));
    15     }
    16 
     5    ((void)(*_X1gFv___1)());
     6    ((void)_X1gFv___1());
     7    ((void)(_X1gFv___1=_X1hFv___1));
    178}
    189signed int _X2f1Fi___1(){
    … …  
    192183const double _X3fooFd_d__1(__attribute__ ((unused)) double __anonymous_object20){
    193184    __attribute__ ((unused)) const double _X11_retval_fooKd_1;
    194     {
    195         ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
    196     }
    197 
     185    ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
    198186    return _X11_retval_fooKd_1;
    199187}
    … …  
    207195static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    208196static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    209     {
    210         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    211     }
    212 
     197    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    213198}
    214199static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    215     {
    216         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    217     }
    218 
     200    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    219201}
    220202static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    221     {
    222         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    223     }
    224 
     203    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    225204}
    226205static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    227206    struct S _X4_retS1S_1;
    228     {
    229         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    230     }
    231 
    232     {
    233         ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    234     }
    235 
     207    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
     208    ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    236209    return _X4_retS1S_1;
    237210}
    238211static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    239     {
    240         ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    241     }
    242 
     212    ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    243213}
    244214struct S _X3rtnFS1S_i__1(__attribute__ ((unused)) signed int __anonymous_object21){

  • tests/.expect/functions.x86.txt

    r933f32f r292642a  
    33signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(__attribute__ ((unused)) signed int (*__anonymous_object0)(void), __attribute__ ((unused)) signed int (*__anonymous_object1)(signed int __anonymous_object2), __attribute__ ((unused)) signed int (*__anonymous_object3)(void), __attribute__ ((unused)) signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
    44    __attribute__ ((unused)) signed int _X9_retval_fi_1;
    5     {
    6         ((void)(*_X1gFv___1)());
    7     }
    8 
    9     {
    10         ((void)_X1gFv___1());
    11     }
    12 
    13     {
    14         ((void)(_X1gFv___1=_X1hFv___1));
    15     }
    16 
     5    ((void)(*_X1gFv___1)());
     6    ((void)_X1gFv___1());
     7    ((void)(_X1gFv___1=_X1hFv___1));
    178}
    189signed int _X2f1Fi___1(){
    … …  
    192183const double _X3fooFd_d__1(__attribute__ ((unused)) double __anonymous_object20){
    193184    __attribute__ ((unused)) const double _X11_retval_fooKd_1;
    194     {
    195         ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
    196     }
    197 
     185    ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
    198186    return _X11_retval_fooKd_1;
    199187}
    … …  
    207195static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
    208196static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    209     {
    210         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    211     }
    212 
     197    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
    213198}
    214199static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    215     {
    216         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    217     }
    218 
     200    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
    219201}
    220202static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
    221     {
    222         ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    223     }
    224 
     203    ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
    225204}
    226205static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
    227206    struct S _X4_retS1S_1;
    228     {
    229         ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
    230     }
    231 
    232     {
    233         ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    234     }
    235 
     207    ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
     208    ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
    236209    return _X4_retS1S_1;
    237210}
    238211static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
    239     {
    240         ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    241     }
    242 
     212    ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
    243213}
    244214struct S _X3rtnFS1S_i__1(__attribute__ ((unused)) signed int __anonymous_object21){

  • tests/.expect/gccExtensions.x64.txt

    r933f32f r292642a  
    3838    };
    3939    inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    40         {
    41             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    42         }
    43 
    44         {
    45             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    46         }
    47 
    48         {
    49             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    50         }
    51 
     40        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
     41        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     42        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    5243    }
    5344    inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    54         {
    55             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    56         }
    57 
    58         {
    59             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    60         }
    61 
    62         {
    63             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    64         }
    65 
     45        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
     46        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
     47        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    6648    }
    6749    inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    68         {
    69             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    70         }
    71 
    72         {
    73             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    74         }
    75 
    76         {
    77             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    78         }
    79 
     50        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
     51        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
     52        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    8053    }
    8154    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    8255        struct S _X4_retS1S_2;
    83         {
    84             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    85         }
    86 
    87         {
    88             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    89         }
    90 
    91         {
    92             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    93         }
    94 
    95         {
    96             ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    97         }
    98 
     56        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
     57        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
     58        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
     59        ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    9960        return _X4_retS1S_2;
    10061    }
    10162    inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    102         {
    103             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    104         }
    105 
    106         {
    107             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    108         }
    109 
    110         {
    111             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    112         }
    113 
     63        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     64        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     65        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    11466    }
    11567    inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    116         {
    117             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    118         }
    119 
    120         {
    121             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    122         }
    123 
    124         {
    125             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    126         }
    127 
     68        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     69        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     70        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    12871    }
    12972    inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    130         {
    131             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    132         }
    133 
    134         {
    135             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    136         }
    137 
    138         {
    139             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    140         }
    141 
     73        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     74        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     75        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    14276    }
    14377    signed int _X1ii_2 = __extension__ 3;
    … …  
    14579    __extension__ signed int _X1bi_2;
    14680    __extension__ signed int _X1ci_2;
    147     {
    148         ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    149     }
    150 
    151     {
    152         ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
    153     }
    154 
    155     {
    156         ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    157     }
    158 
     81    ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
     82    ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
     83    ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    15984    signed int _X2a1i_2;
    16085    const signed int _X2a2Ki_2;
    … …  
    17196    };
    17297    inline void _X12_constructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    173         {
    174             ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
    175         }
    176 
     98        ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
    17799    }
    178100    inline void _X12_constructorFv_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    179         {
    180             ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
    181         }
    182 
     101        ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
    183102    }
    184103    inline void _X11_destructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    185         {
    186             ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
    187         }
    188 
     104        ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
    189105    }
    190106    inline struct s2 _X16_operator_assignFS2s2_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    191107        struct s2 _X4_retS2s2_2;
    192         {
    193             ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
    194         }
    195 
    196         {
    197             ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
    198         }
    199 
     108        ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
     109        ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
    200110        return _X4_retS2s2_2;
    201111    }
    202112    inline void _X12_constructorFv_S2s2i_autogen___2(struct s2 *_X4_dstS2s2_2, signed int _X1ii_2){
    203         {
    204             ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
    205         }
    206 
     113        ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
    207114    }
    208115    struct s3 {
    … …  
    210117    };
    211118    inline void _X12_constructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    212         {
    213             ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
    214         }
    215 
     119        ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
    216120    }
    217121    inline void _X12_constructorFv_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    218         {
    219             ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
    220         }
    221 
     122        ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
    222123    }
    223124    inline void _X11_destructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    224         {
    225             ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
    226         }
    227 
     125        ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
    228126    }
    229127    inline struct s3 _X16_operator_assignFS2s3_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    230128        struct s3 _X4_retS2s3_2;
    231         {
    232             ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
    233         }
    234 
    235         {
    236             ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
    237         }
    238 
     129        ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
     130        ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
    239131        return _X4_retS2s3_2;
    240132    }
    241133    inline void _X12_constructorFv_S2s3i_autogen___2(struct s3 *_X4_dstS2s3_2, signed int _X1ii_2){
    242         {
    243             ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    244         }
    245 
     134        ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    246135    }
    247136    struct s3 _X2x1S2s3_2;
    … …  
    251140    };
    252141    inline void _X12_constructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    253         {
    254             ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
    255         }
    256 
     142        ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
    257143    }
    258144    inline void _X12_constructorFv_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    259         {
    260             ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
    261         }
    262 
     145        ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
    263146    }
    264147    inline void _X11_destructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    265         {
    266             ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
    267         }
    268 
     148        ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
    269149    }
    270150    inline struct s4 _X16_operator_assignFS2s4_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    271151        struct s4 _X4_retS2s4_2;
    272         {
    273             ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
    274         }
    275 
    276         {
    277             ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
    278         }
    279 
     152        ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
     153        ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
    280154        return _X4_retS2s4_2;
    281155    }
    282156    inline void _X12_constructorFv_S2s4i_autogen___2(struct s4 *_X4_dstS2s4_2, signed int _X1ii_2){
    283         {
    284             ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
    285         }
    286 
     157        ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
    287158    }
    288159    struct s4 _X2x2S2s4_2;
    … …  
    291162    signed int _X2m2A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
    292163    signed int _X2m3A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
    293     {
    294         ((void)(_X12_retval_maini_1=0) /* ?{} */);
    295     }
    296 
     164    ((void)(_X12_retval_maini_1=0) /* ?{} */);
    297165    return _X12_retval_maini_1;
    298     {
    299         ((void)(_X12_retval_maini_1=0) /* ?{} */);
    300     }
    301 
     166    ((void)(_X12_retval_maini_1=0) /* ?{} */);
    302167    return _X12_retval_maini_1;
    303168}
    … …  
    306171signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    307172    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    308     {
    309         signed int _tmp_cp_ret4;
    310         ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
    311     }
    312 
     173    signed int _tmp_cp_ret4;
     174    ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
     175    ((void)(_tmp_cp_ret4) /* ^?{} */);
    313176    return _X12_retval_maini_1;
    314177}

  • tests/.expect/gccExtensions.x86.txt

    r933f32f r292642a  
    3838    };
    3939    inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    40         {
    41             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
    42         }
    43 
    44         {
    45             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    46         }
    47 
    48         {
    49             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    50         }
    51 
     40        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
     41        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     42        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    5243    }
    5344    inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    54         {
    55             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
    56         }
    57 
    58         {
    59             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
    60         }
    61 
    62         {
    63             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    64         }
    65 
     45        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
     46        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
     47        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
    6648    }
    6749    inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
    68         {
    69             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
    70         }
    71 
    72         {
    73             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
    74         }
    75 
    76         {
    77             ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    78         }
    79 
     50        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
     51        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
     52        ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
    8053    }
    8154    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
    8255        struct S _X4_retS1S_2;
    83         {
    84             ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
    85         }
    86 
    87         {
    88             ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
    89         }
    90 
    91         {
    92             ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
    93         }
    94 
    95         {
    96             ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    97         }
    98 
     56        ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
     57        ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
     58        ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
     59        ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
    9960        return _X4_retS1S_2;
    10061    }
    10162    inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
    102         {
    103             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    104         }
    105 
    106         {
    107             ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
    108         }
    109 
    110         {
    111             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    112         }
    113 
     63        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     64        ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
     65        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    11466    }
    11567    inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
    116         {
    117             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    118         }
    119 
    120         {
    121             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    122         }
    123 
    124         {
    125             ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    126         }
    127 
     68        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     69        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     70        ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
    12871    }
    12972    inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
    130         {
    131             ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
    132         }
    133 
    134         {
    135             ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
    136         }
    137 
    138         {
    139             ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    140         }
    141 
     73        ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
     74        ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
     75        ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
    14276    }
    14377    signed int _X1ii_2 = __extension__ 3;
    … …  
    14579    __extension__ signed int _X1bi_2;
    14680    __extension__ signed int _X1ci_2;
    147     {
    148         ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
    149     }
    150 
    151     {
    152         ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
    153     }
    154 
    155     {
    156         ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    157     }
    158 
     81    ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
     82    ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
     83    ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
    15984    signed int _X2a1i_2;
    16085    const signed int _X2a2Ki_2;
    … …  
    17196    };
    17297    inline void _X12_constructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    173         {
    174             ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
    175         }
    176 
     98        ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
    17799    }
    178100    inline void _X12_constructorFv_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    179         {
    180             ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
    181         }
    182 
     101        ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
    183102    }
    184103    inline void _X11_destructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
    185         {
    186             ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
    187         }
    188 
     104        ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
    189105    }
    190106    inline struct s2 _X16_operator_assignFS2s2_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
    191107        struct s2 _X4_retS2s2_2;
    192         {
    193             ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
    194         }
    195 
    196         {
    197             ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
    198         }
    199 
     108        ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
     109        ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
    200110        return _X4_retS2s2_2;
    201111    }
    202112    inline void _X12_constructorFv_S2s2i_autogen___2(struct s2 *_X4_dstS2s2_2, signed int _X1ii_2){
    203         {
    204             ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
    205         }
    206 
     113        ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
    207114    }
    208115    struct s3 {
    … …  
    210117    };
    211118    inline void _X12_constructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    212         {
    213             ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
    214         }
    215 
     119        ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
    216120    }
    217121    inline void _X12_constructorFv_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    218         {
    219             ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
    220         }
    221 
     122        ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
    222123    }
    223124    inline void _X11_destructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
    224         {
    225             ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
    226         }
    227 
     125        ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
    228126    }
    229127    inline struct s3 _X16_operator_assignFS2s3_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
    230128        struct s3 _X4_retS2s3_2;
    231         {
    232             ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
    233         }
    234 
    235         {
    236             ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
    237         }
    238 
     129        ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
     130        ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
    239131        return _X4_retS2s3_2;
    240132    }
    241133    inline void _X12_constructorFv_S2s3i_autogen___2(struct s3 *_X4_dstS2s3_2, signed int _X1ii_2){
    242         {
    243             ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    244         }
    245 
     134        ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
    246135    }
    247136    struct s3 _X2x1S2s3_2;
    … …  
    251140    };
    252141    inline void _X12_constructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    253         {
    254             ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
    255         }
    256 
     142        ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
    257143    }
    258144    inline void _X12_constructorFv_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    259         {
    260             ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
    261         }
    262 
     145        ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
    263146    }
    264147    inline void _X11_destructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
    265         {
    266             ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
    267         }
    268 
     148        ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
    269149    }
    270150    inline struct s4 _X16_operator_assignFS2s4_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
    271151        struct s4 _X4_retS2s4_2;
    272         {
    273             ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
    274         }
    275 
    276         {
    277             ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
    278         }
    279 
     152        ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
     153        ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
    280154        return _X4_retS2s4_2;
    281155    }
    282156    inline void _X12_constructorFv_S2s4i_autogen___2(struct s4 *_X4_dstS2s4_2, signed int _X1ii_2){
    283         {
    284             ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
    285         }
    286 
     157        ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
    287158    }
    288159    struct s4 _X2x2S2s4_2;
    … …  
    291162    signed int _X2m2A0A0i_2[((unsigned int )10)][((unsigned int )10)];
    292163    signed int _X2m3A0A0i_2[((unsigned int )10)][((unsigned int )10)];
    293     {
    294         ((void)(_X12_retval_maini_1=0) /* ?{} */);
    295     }
    296 
     164    ((void)(_X12_retval_maini_1=0) /* ?{} */);
    297165    return _X12_retval_maini_1;
    298     {
    299         ((void)(_X12_retval_maini_1=0) /* ?{} */);
    300     }
    301 
     166    ((void)(_X12_retval_maini_1=0) /* ?{} */);
    302167    return _X12_retval_maini_1;
    303168}
    … …  
    306171signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
    307172    __attribute__ ((unused)) signed int _X12_retval_maini_1;
    308     {
    309         signed int _tmp_cp_ret4;
    310         ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
    311     }
    312 
     173    signed int _tmp_cp_ret4;
     174    ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
     175    ((void)(_tmp_cp_ret4) /* ^?{} */);
    313176    return _X12_retval_maini_1;
    314177}

  • tests/raii/.expect/memberCtors-ERR1.txt

    r933f32f r292642a  
    1 raii/memberCtors.cfa:92:1 error: in void ?{}(B &b), field a2 used before being constructed
     1raii/memberCtors.cfa:71:1 error: in void ?{}(B &b), field a2 used before being constructed

  • tests/raii/.expect/memberCtors.txt

    r933f32f r292642a  
    11Before declaration of b1
    2 constructing int id: 0
    3 constructing int id: 1
    4 constructing int id: 2
    5 default construct A 0
    6 constructing int id: 3
    7 constructing int id: 4
    8 constructing int id: 5
    9 default construct A 1
    10 begin construct B id: 0
     2constructing int
     3constructing int
     4constructing int
     5constructing int
     6constructing int
     7constructing int
     8begin construct B
    119assign b.a2
    12 constructing int id: 6
    13 constructing int id: 7
    14 begin construct A id: 2
    15 construct a.x
    16 constructing int: 1001 id: 8
    17 assign a.y
    18 assigning int: 0 0 id: 6
    19 end construct A
    20 copy constructing int: 0 id: 9
    21 copy constructing int: 0 id: 10
    22 begin copy construct A id: 3
    23 copy construct this.x
    24 copy constructing int: 1001 id: 11
    25 assign this.y
    26 copy constructing int: 0 id: 12
    27 destructing int: 0 id: 12
    28 destructing int: 0 id: 12
    29 end copy construct A
    30 begin ?=? A id: 0
    31 copy constructing int: 1001 id: 13
    32 destructing int: 1001 id: 13
    33 destructing int: 1001 id: 13
    34 copy constructing int: 0 id: 14
    35 destructing int: 0 id: 14
    36 destructing int: 0 id: 14
    37 copy constructing int: 0 id: 15
    38 destructing int: 0 id: 15
    39 destructing int: 0 id: 15
     10constructing int
     11constructing int
     12begin construct A
     13construct a.x
     14constructing int: 1001
     15assign a.y
     16assigning int: 0 0
     17end construct A
     18copy constructing int: 0
     19copy constructing int: 0
     20begin copy construct A
     21copy construct this.x
     22copy constructing int: 1001
     23assign this.y
     24copy constructing int: 0
     25destructing int: 0
     26destructing int: 0
     27end copy construct A
     28begin ?=? A
     29copy constructing int: 1001
     30destructing int: 1001
     31destructing int: 1001
     32copy constructing int: 0
     33destructing int: 0
     34destructing int: 0
     35copy constructing int: 0
     36destructing int: 0
     37destructing int: 0
    4038end ?=? A
    41 copy constructing int: 0 id: 16
    42 copy constructing int: 0 id: 17
    43 begin copy construct A id: 4
    44 copy construct this.x
    45 copy constructing int: 1001 id: 18
    46 assign this.y
    47 copy constructing int: 0 id: 19
    48 destructing int: 0 id: 19
    49 destructing int: 0 id: 19
    50 end copy construct A
    51 destructing int: 0 id: 17
    52 destructing int: 0 id: 19
    53 destructing int: 1001 id: 18
    54 destructing int: 0 id: 10
    55 destructing int: 0 id: 12
    56 destructing int: 1001 id: 11
     39copy constructing int: 0
     40copy constructing int: 0
     41begin copy construct A
     42copy construct this.x
     43copy constructing int: 1001
     44assign this.y
     45copy constructing int: 0
     46destructing int: 0
     47destructing int: 0
     48end copy construct A
     49destructing int: 0
     50destructing int: 0
     51destructing int: 1001
     52destructing int: 0
     53destructing int: 0
     54destructing int: 1001
    5755construct b.a1
    58 constructing int id: 20
    59 constructing int id: 21
    60 begin construct A id: 5
    61 construct a.x
    62 constructing int: 1000 id: 22
    63 assign a.y
    64 assigning int: 0 0 id: 20
     56constructing int
     57constructing int
     58begin construct A
     59construct a.x
     60constructing int: 1000
     61assign a.y
     62assigning int: 0 0
    6563end construct A
    6664end construct B
    67 destructing int: 0 id: 7
    68 destructing int: 0 id: 6
    69 destructing int: 1001 id: 8
     65destructing int: 0
     66destructing int: 0
     67destructing int: 1001
    7068Before declaration of b2
    71 copy constructing int: 0 id: 23
    72 copy constructing int: 0 id: 24
    73 begin copy construct A id: 6
    74 copy construct this.x
    75 copy constructing int: 1000 id: 25
    76 assign this.y
    77 copy constructing int: 0 id: 26
    78 destructing int: 0 id: 26
    79 destructing int: 0 id: 26
    80 end copy construct A
    81 copy constructing int: 0 id: 27
    82 copy constructing int: 0 id: 28
    83 begin copy construct A id: 7
    84 copy construct this.x
    85 copy constructing int: 1001 id: 29
    86 assign this.y
    87 copy constructing int: 0 id: 30
    88 destructing int: 0 id: 30
    89 destructing int: 0 id: 30
    90 end copy construct A
    91 copy constructing int: 0 id: 31
    92 copy constructing int: 0 id: 32
    93 begin copy construct A id: 8
    94 copy construct this.x
    95 copy constructing int: 0 id: 33
    96 assign this.y
    97 copy constructing int: 0 id: 34
    98 destructing int: 0 id: 34
    99 destructing int: 0 id: 34
     69copy constructing int: 0
     70copy constructing int: 0
     71begin copy construct A
     72copy construct this.x
     73copy constructing int: 1000
     74assign this.y
     75copy constructing int: 0
     76destructing int: 0
     77destructing int: 0
     78end copy construct A
     79copy constructing int: 0
     80copy constructing int: 0
     81begin copy construct A
     82copy construct this.x
     83copy constructing int: 1001
     84assign this.y
     85copy constructing int: 0
     86destructing int: 0
     87destructing int: 0
     88end copy construct A
     89copy constructing int: 0
     90copy constructing int: 0
     91begin copy construct A
     92copy construct this.x
     93copy constructing int: 0
     94assign this.y
     95copy constructing int: 0
     96destructing int: 0
     97destructing int: 0
    10098end copy construct A
    10199End of main
    102 begin destruct B id: 1
    103 constructing int id: 35
    104 constructing int id: 36
    105 begin construct A id: 9
    106 construct a.x
    107 constructing int: 999 id: 37
    108 assign a.y
    109 assigning int: 0 0 id: 35
    110 end construct A
    111 copy constructing int: 0 id: 38
    112 copy constructing int: 0 id: 39
    113 begin copy construct A id: 10
    114 copy construct this.x
    115 copy constructing int: 999 id: 40
    116 assign this.y
    117 copy constructing int: 0 id: 41
    118 destructing int: 0 id: 41
    119 destructing int: 0 id: 41
    120 end copy construct A
    121 begin ?=? A id: 7
    122 copy constructing int: 999 id: 42
    123 destructing int: 999 id: 42
    124 destructing int: 999 id: 42
    125 copy constructing int: 0 id: 43
    126 destructing int: 0 id: 43
    127 destructing int: 0 id: 43
    128 copy constructing int: 0 id: 44
    129 destructing int: 0 id: 44
    130 destructing int: 0 id: 44
     100constructing int
     101constructing int
     102begin construct A
     103construct a.x
     104constructing int: 999
     105assign a.y
     106assigning int: 0 0
     107end construct A
     108copy constructing int: 0
     109copy constructing int: 0
     110begin copy construct A
     111copy construct this.x
     112copy constructing int: 999
     113assign this.y
     114copy constructing int: 0
     115destructing int: 0
     116destructing int: 0
     117end copy construct A
     118begin ?=? A
     119copy constructing int: 999
     120destructing int: 999
     121destructing int: 999
     122copy constructing int: 0
     123destructing int: 0
     124destructing int: 0
     125copy constructing int: 0
     126destructing int: 0
     127destructing int: 0
    131128end ?=? A
    132 copy constructing int: 0 id: 45
    133 copy constructing int: 0 id: 46
    134 begin copy construct A id: 11
    135 copy construct this.x
    136 copy constructing int: 999 id: 47
    137 assign this.y
    138 copy constructing int: 0 id: 48
    139 destructing int: 0 id: 48
    140 destructing int: 0 id: 48
    141 end copy construct A
    142 destructing int: 0 id: 46
    143 destructing int: 0 id: 48
    144 destructing int: 999 id: 47
    145 destructing int: 0 id: 39
    146 destructing int: 0 id: 41
    147 destructing int: 999 id: 40
    148 destructing int: 0 id: 24
    149 destructing int: 0 id: 26
    150 destructing int: 1000 id: 25
    151 end destruct B
    152 destructing int: 0 id: 36
    153 destructing int: 0 id: 35
    154 destructing int: 999 id: 37
    155 destructing int: 0 id: 32
    156 destructing int: 0 id: 34
    157 destructing int: 0 id: 33
    158 destructing int: 0 id: 44
    159 destructing int: 0 id: 43
    160 destructing int: 999 id: 42
    161 begin destruct B id: 2
    162 constructing int id: 49
    163 constructing int id: 50
    164 begin construct A id: 12
    165 construct a.x
    166 constructing int: 999 id: 51
    167 assign a.y
    168 assigning int: 0 0 id: 49
    169 end construct A
    170 copy constructing int: 0 id: 52
    171 copy constructing int: 0 id: 53
    172 begin copy construct A id: 13
    173 copy construct this.x
    174 copy constructing int: 999 id: 54
    175 assign this.y
    176 copy constructing int: 0 id: 55
    177 destructing int: 0 id: 55
    178 destructing int: 0 id: 55
    179 end copy construct A
    180 begin ?=? A id: 0
    181 copy constructing int: 999 id: 56
    182 destructing int: 999 id: 56
    183 destructing int: 999 id: 56
    184 copy constructing int: 0 id: 57
    185 destructing int: 0 id: 57
    186 destructing int: 0 id: 57
    187 copy constructing int: 0 id: 58
    188 destructing int: 0 id: 58
    189 destructing int: 0 id: 58
     129copy constructing int: 0
     130copy constructing int: 0
     131begin copy construct A
     132copy construct this.x
     133copy constructing int: 999
     134assign this.y
     135copy constructing int: 0
     136destructing int: 0
     137destructing int: 0
     138end copy construct A
     139destructing int: 0
     140destructing int: 0
     141destructing int: 999
     142destructing int: 0
     143destructing int: 0
     144destructing int: 999
     145destructing int: 0
     146destructing int: 0
     147destructing int: 1000
     148destructing int: 0
     149destructing int: 0
     150destructing int: 999
     151destructing int: 0
     152destructing int: 0
     153destructing int: 0
     154destructing int: 0
     155destructing int: 0
     156destructing int: 999
     157constructing int
     158constructing int
     159begin construct A
     160construct a.x
     161constructing int: 999
     162assign a.y
     163assigning int: 0 0
     164end construct A
     165copy constructing int: 0
     166copy constructing int: 0
     167begin copy construct A
     168copy construct this.x
     169copy constructing int: 999
     170assign this.y
     171copy constructing int: 0
     172destructing int: 0
     173destructing int: 0
     174end copy construct A
     175begin ?=? A
     176copy constructing int: 999
     177destructing int: 999
     178destructing int: 999
     179copy constructing int: 0
     180destructing int: 0
     181destructing int: 0
     182copy constructing int: 0
     183destructing int: 0
     184destructing int: 0
    190185end ?=? A
    191 copy constructing int: 0 id: 59
    192 copy constructing int: 0 id: 60
    193 begin copy construct A id: 14
    194 copy construct this.x
    195 copy constructing int: 999 id: 61
    196 assign this.y
    197 copy constructing int: 0 id: 62
    198 destructing int: 0 id: 62
    199 destructing int: 0 id: 62
    200 end copy construct A
    201 destructing int: 0 id: 60
    202 destructing int: 0 id: 62
    203 destructing int: 999 id: 61
    204 destructing int: 0 id: 53
    205 destructing int: 0 id: 55
    206 destructing int: 999 id: 54
    207 destructing int: 0 id: 21
    208 destructing int: 0 id: 20
    209 destructing int: 1000 id: 22
    210 end destruct B
    211 destructing int: 0 id: 50
    212 destructing int: 0 id: 49
    213 destructing int: 999 id: 51
    214 destructing int: 0 id: 5
    215 destructing int: 0 id: 4
    216 destructing int: 0 id: 3
    217 destructing int: 0 id: 58
    218 destructing int: 0 id: 57
    219 destructing int: 999 id: 56
     186copy constructing int: 0
     187copy constructing int: 0
     188begin copy construct A
     189copy construct this.x
     190copy constructing int: 999
     191assign this.y
     192copy constructing int: 0
     193destructing int: 0
     194destructing int: 0
     195end copy construct A
     196destructing int: 0
     197destructing int: 0
     198destructing int: 999
     199destructing int: 0
     200destructing int: 0
     201destructing int: 999
     202destructing int: 0
     203destructing int: 0
     204destructing int: 1000
     205destructing int: 0
     206destructing int: 0
     207destructing int: 999
     208destructing int: 0
     209destructing int: 0
     210destructing int: 0
     211destructing int: 0
     212destructing int: 0
     213destructing int: 999

  • tests/raii/memberCtors.cfa

    r933f32f r292642a  
    11struct WrappedInt {
    22  int x;
    3   int id;
    43};
    5 int intID = 0;
    64
    75void ?{}(WrappedInt & this) {
    8   this.id = intID++;
    9   printf("constructing int id: %d\n", this.id);
     6  printf("constructing int\n");
    107  this.x = 0;
    118}
    129
    1310void ?{}(WrappedInt & this, WrappedInt other) {
    14   this.id = intID++;
    15   printf("copy constructing int: %d id: %d\n", other.x, this.id);
     11  printf("copy constructing int: %d\n", other.x);
    1612  this.x = other.x;
    1713}
    1814
    1915void ?{}(WrappedInt & this, int x) {
    20   this.id = intID++;
    21   printf("constructing int: %d id: %d\n", x, this.id);
     16  printf("constructing int: %d\n", x);
    2217  this.x = x;
    2318}
    2419
    2520void ^?{}(WrappedInt & this) {
    26   printf("destructing int: %d id: %d\n", this.x, this.id);
     21  printf("destructing int: %d\n", this.x);
    2722}
    2823
    29 /* WrappedInt */ void ?=?(WrappedInt & this, int x) {
    30   printf("assigning int: %d %d id: %d\n", this.x, x, this.id);
     24void ?=?(WrappedInt & this, int x) {
     25  printf("assigning int: %d %d\n", this.x, x);
    3126  this.x = x;
    32   // return this;
    3327}
    34 
    35 // WrappedInt ?=?(WrappedInt & this, WrappedInt other) {
    36 //   printf("assigning int: %d %d\n", this.x, other.x);
    37 //   this.x = other.x;
    38 //   return this;
    39 // }
    4028
    4129struct A {
    4230  WrappedInt x, y, z;
    43   int id;
    4431};
    45 int AID = 0;
    4632
    4733void ?{}(A & a) {
    4834  // currently must define default ctor, since there's no "= default" syntax
    49   a.id = AID++;
    50   printf("default construct A %d\n", a.id);
    5135}
    5236
    5337void ?{}(A & a, int x) {
    54   a.id = AID++;
    55   printf("begin construct A id: %d\n", a.id);
     38  printf("begin construct A\n");
    5639  printf("construct a.x\n");
    5740  (a.x){ x+999 };
    … …  
    6245
    6346void ?{}(A & this, A other) {
    64   this.id = AID++;
    65   printf("begin copy construct A id: %d\n", this.id);
     47  printf("begin copy construct A\n");
    6648  printf("copy construct this.x\n");
    6749  (this.x){ other.x };
    … …  
    7254
    7355A ?=?(A & this, A other) {
    74   printf("begin ?=? A id: %d\n", this.id);
     56  printf("begin ?=? A\n");
    7557  this.x = other.x;
    7658  this.y = other.y;
    … …  
    8264struct B {
    8365  A a1, a2, a3;
    84   int id;
    8566};
    86 int BID = 0;
    8767
    8868void ?{}(B & b) {
    89   b.id = BID++;
    90   printf("begin construct B id: %d\n", b.id);
     69  printf("begin construct B\n");
    9170  printf("assign b.a2\n");
    9271  b.a2 = (A) { 2 };
    … …  
    10079
    10180void ^?{}(B & b) {
    102   b.id = BID++;
    103   printf("begin destruct B id: %d\n", b.id);
    10481  b.a2 = (A) { 0 };
    10582  ^(b.a1){};
    106   printf("end destruct B\n");
    10783} // a2, a3 never destructed - will be automatically destructed
    10884
    10985int main() {
    11086  printf("Before declaration of b1\n");
    111   B b1;  // b1 = { { 1000, 0, 0 }, { 1001, 0, 0 }, { 0, 0, 0 } }
     87  B b1;
    11288  printf("Before declaration of b2\n");
    11389  B b2 = b1;
Note: See TracChangeset for help on using the changeset viewer.